Skip to content

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

C++
57.1 KB
Raw Blame
#include "kernel.hpp"

#include "hw.hpp"

#include "ps2/state.hpp"

#include <algorithm>
#include <cstdio>
#include <deque>
#include <map>
#include <set>
#include <vector>

namespace ps2::iop::kernel {

namespace {

constexpr int kErrorUnknownThread = -407;
constexpr int kErrorUnknownSema = -408;
constexpr int kErrorUnknownEvent = -409;
constexpr int kErrorUnknownMbx = -410;
constexpr int kErrorUnknownFpl = -412;
constexpr int kErrorUnknownVpl = -411;
constexpr int kErrorWaitDelete = -425;
constexpr int kErrorSemaZero = -419;
constexpr int kErrorEventCondition = -421;
constexpr int kErrorMbxNone = -424;
constexpr int kErrorNoMemory = -400;
constexpr int kErrorIllegalObject = -201;
constexpr int kErrorUnknownModule = -202;

std::uint32_t arg(const Cpu &c, int i) { return i < 4 ? c.r[4 + i] : read32(c.r[29] + 16u + static_cast<std::uint32_t>(i - 4) * 4u); }

void def(const char *library, std::uint32_t index, const char *name, std::function<void(Cpu &)> body) {
    register_hle(library, index, [library, name, body = std::move(body)](Cpu &c) {
        trace_hle(library, name, c);
        body(c);
    });
}

std::string format(Cpu &c, std::uint32_t fmt_address, int first) {
    const std::string fmt = ram_string(fmt_address, 1024);
    std::string out;
    int next = first;
    for (std::size_t i = 0; i < fmt.size(); ++i) {
        if (fmt[i] != '%') { out += fmt[i]; continue; }
        std::string spec = "%";
        ++i;
        while (i < fmt.size() && std::strchr("-+ #0", fmt[i])) spec += fmt[i++];
        while (i < fmt.size() && (std::isdigit(static_cast<unsigned char>(fmt[i])) || fmt[i] == '.')) spec += fmt[i++];
        while (i < fmt.size() && (fmt[i] == 'l' || fmt[i] == 'h')) ++i;
        if (i >= fmt.size()) break;
        const char conv = fmt[i];
        char buf[512];
        switch (conv) {
        case 'd': case 'i': std::snprintf(buf, sizeof buf, (spec + "d").c_str(), static_cast<int>(arg(c, next++))); break;
        case 'u': std::snprintf(buf, sizeof buf, (spec + "u").c_str(), arg(c, next++)); break;
        case 'x': case 'X': case 'o': std::snprintf(buf, sizeof buf, (spec + conv).c_str(), arg(c, next++)); break;
        case 'p': std::snprintf(buf, sizeof buf, "%08x", arg(c, next++)); break;
        case 'c': std::snprintf(buf, sizeof buf, (spec + "c").c_str(), static_cast<int>(arg(c, next++))); break;
        case 's': std::snprintf(buf, sizeof buf, (spec + "s").c_str(), ram_string(arg(c, next++)).c_str()); break;
        case '%': std::snprintf(buf, sizeof buf, "%%"); break;
        default: std::snprintf(buf, sizeof buf, "%s%c", spec.c_str(), conv); break;
        }
        out += buf;
    }
    return out;
}

void print(const std::string &text) {
    static std::string line;
    for (char ch : text) {
        if (ch == '\n') {
            std::fprintf(stderr, "[iop-tty] %s\n", line.c_str());
            line.clear();
        } else if (ch != '\r') {
            line += ch;
        }
    }
}

struct Sema {
    int count, max;
    std::uint32_t attr, option;
    std::deque<int> waiters;
};

struct EventFlag {
    std::uint32_t bits, attr, option;
    std::deque<int> waiters;
};

struct Mbx {
    std::uint32_t attr, option;
    std::deque<std::uint32_t> messages;
    std::deque<int> waiters;
};

struct Fpl {
    std::uint32_t attr, option, block_size, blocks, base;
    std::vector<std::uint32_t> free;
    std::deque<int> waiters;
};

struct VplWaiter {
    int thread;
    std::uint32_t size;
};

struct Vpl {
    std::uint32_t attr, option, base, size;
    std::map<std::uint32_t, std::uint32_t> blocks;
    std::deque<VplWaiter> waiters;
};

std::map<int, Vpl> g_vpls;

struct VblankHandler {
    int edge;
    std::uint32_t handler, arg;
};

struct Alarm {
    std::uint32_t handler, arg;
    bool active;
};

std::map<int, Sema> g_semas;
std::map<int, EventFlag> g_events;
std::map<int, Mbx> g_mbxs;
std::map<int, Fpl> g_fpls;
std::map<std::uint32_t, std::set<std::uint32_t>> g_heaps;
std::vector<VblankHandler> g_vblank_handlers;
std::vector<int> g_vblank_start_waiters, g_vblank_end_waiters;
std::map<std::uint64_t, Alarm> g_alarms;
std::uint64_t g_next_alarm = 1;
int g_next_object = 1;
std::uint64_t g_rotate_order = 1ull << 40;
std::uint32_t g_strtok_next = 0;
std::uint32_t g_next_hard_timer = 1;

void signal_sema(Cpu &c, int id, bool from_interrupt) {
    auto it = g_semas.find(id);
    if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
    Sema &s = it->second;
    c.r[2] = 0;
    if (!s.waiters.empty()) {
        const int t = s.waiters.front();
        s.waiters.pop_front();
        if (Thread *th = thread(t)) wake(*th, 0);
        if (!from_interrupt) reschedule();
    } else if (s.count < s.max || s.max <= 0) {
        ++s.count;
    }
}

bool event_matches(const EventFlag &e, std::uint32_t bits, std::uint32_t mode) {
    return (mode & 1u) ? (e.bits & bits) != 0 : (e.bits & bits) == bits;
}

void event_take(EventFlag &e, std::uint32_t bits, std::uint32_t mode, std::uint32_t result_ptr) {
    if (result_ptr) write32(result_ptr, e.bits);
    if (mode & 0x10u) e.bits &= ~bits;
    if (mode & 0x20u) e.bits = 0;
}

void set_event(Cpu &c, int id, std::uint32_t bits, bool from_interrupt) {
    auto it = g_events.find(id);
    if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
    EventFlag &e = it->second;
    e.bits |= bits;
    c.r[2] = 0;
    for (auto w = e.waiters.begin(); w != e.waiters.end();) {
        Thread *t = thread(*w);
        if (t && event_matches(e, t->event_bits, t->event_mode)) {
            event_take(e, t->event_bits, t->event_mode, t->event_result);
            wake(*t, 0);
            w = e.waiters.erase(w);
            if (!from_interrupt) reschedule();
        } else {
            ++w;
        }
    }
}

void send_mbx(Cpu &c, int id, std::uint32_t message, bool from_interrupt) {
    auto it = g_mbxs.find(id);
    if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
    Mbx &m = it->second;
    c.r[2] = 0;
    if (!m.waiters.empty()) {
        const int t = m.waiters.front();
        m.waiters.pop_front();
        if (Thread *th = thread(t)) {
            if (th->message_out) write32(th->message_out, message);
            wake(*th, 0);
        }
        if (!from_interrupt) reschedule();
    } else {
        m.messages.push_back(message);
    }
}

struct HardTimer {
    std::uint32_t compare = 0, handler = 0, common = 0, source = 1, prescale = 1, mode = 0, reached = 0;
    bool running = false, interrupt = false;
    std::uint64_t generation = 0;
};
struct LegacyHardTimer {
    std::uint32_t compare = 0, handler = 0, common = 0, source = 1, prescale = 1;
    bool running = false;
    std::uint64_t generation = 0;
};
std::map<std::uint32_t, HardTimer> g_hard_timers;
std::map<std::uint32_t, std::uint64_t> g_hard_timer_start;

std::uint64_t timer_cycles(const HardTimer &t, std::uint32_t ticks) {
    const std::uint64_t per_tick = (t.source & 4u) ? 2343u : std::max<std::uint32_t>(t.prescale, 1u);
    return std::max<std::uint64_t>(static_cast<std::uint64_t>(ticks) * per_tick, 1u);
}

void arm_hard_timer(std::uint32_t id);

std::uint32_t hard_timer_counter(std::uint32_t id) {
    const auto it = g_hard_timers.find(id);
    if (it == g_hard_timers.end()) return 0;
    const std::uint64_t start = g_hard_timer_start.try_emplace(id, now()).first->second;
    return static_cast<std::uint32_t>((now() - start) / timer_cycles(it->second, 1));
}

void fire_hard_timer(std::uint32_t id, std::uint64_t generation) {
    auto it = g_hard_timers.find(id);
    if (it != g_hard_timers.end() && it->second.running && it->second.generation == generation && it->second.interrupt) {
        it->second.reached |= 0x800u;
        hw::raise_interrupt(14);
        it = g_hard_timers.find(id);
        if (it == g_hard_timers.end() || !it->second.running || it->second.generation != generation) return;
        if (it->second.mode & 0x40u) arm_hard_timer(id);
        else it->second.running = false;
        return;
    }
    if (it == g_hard_timers.end() || !it->second.running || it->second.generation != generation || !it->second.handler) return;
    const std::uint32_t next = call_guest(it->second.handler, it->second.common);
    it = g_hard_timers.find(id);
    if (it == g_hard_timers.end() || !it->second.running || it->second.generation != generation) return;
    if (!next) {
        it->second.running = false;
        return;
    }
    it->second.compare = next;
    arm_hard_timer(id);
}

void arm_hard_timer(std::uint32_t id) {
    HardTimer &t = g_hard_timers[id];
    const std::uint64_t generation = ++t.generation;
    if (!t.running || (!t.handler && !t.interrupt) || !t.compare) return;
    schedule(now() + timer_cycles(t, t.compare), Job{kJobHardTimer, id, static_cast<std::uint32_t>(generation), static_cast<std::uint32_t>(generation >> 32)});
}

void fire_alarm(std::uint64_t key) {
    auto it = g_alarms.find(key);
    if (it == g_alarms.end() || !it->second.active) return;
    const Alarm a = it->second;
    g_alarms.erase(it);
    const std::uint32_t again = call_guest(a.handler, a.arg);
    if (again) {
        const std::uint64_t k = g_next_alarm++;
        g_alarms[k] = Alarm{a.handler, a.arg, true};
        schedule(now() + again, Job{kJobAlarm, static_cast<std::uint32_t>(k), static_cast<std::uint32_t>(k >> 32)});
    }
}

void write_clock(std::uint32_t p, std::uint64_t cycles) {
    write32(p, static_cast<std::uint32_t>(cycles));
    write32(p + 4, static_cast<std::uint32_t>(cycles >> 32));
}

std::uint64_t read_clock(std::uint32_t p) {
    return read32(p) | (static_cast<std::uint64_t>(read32(p + 4)) << 32);
}

void install_sysmem() {
    register_hle_library("sysmem", 0x0101);
    def("sysmem", 4, "AllocSysMemory", [](Cpu &c) { c.r[2] = alloc(arg(c, 1), static_cast<int>(arg(c, 0)), arg(c, 2)); });
    def("sysmem", 5, "FreeSysMemory", [](Cpu &c) { free(arg(c, 0)); c.r[2] = 0; });
    def("sysmem", 6, "QueryMemSize", [](Cpu &c) { c.r[2] = kRamSize; });
    def("sysmem", 7, "QueryMaxFreeMemSize", [](Cpu &c) { c.r[2] = free_max(); });
    def("sysmem", 8, "QueryTotalFreeMemSize", [](Cpu &c) { c.r[2] = free_total(); });
    def("sysmem", 9, "QueryBlockTopAddress", [](Cpu &c) { c.r[2] = arg(c, 0); });
    def("sysmem", 10, "QueryBlockSize", [](Cpu &c) { c.r[2] = 0; });
    def("sysmem", 14, "Kprintf", [](Cpu &c) { print(format(c, arg(c, 0), 1)); c.r[2] = 0; });
}

void install_loadcore() {
    register_hle_library("loadcore", 0x0101);
    def("loadcore", 4, "FlushIcache", [](Cpu &c) { c.r[2] = 0; });
    def("loadcore", 5, "FlushDcache", [](Cpu &c) { c.r[2] = 0; });
    def("loadcore", 6, "RegisterLibraryEntries", [](Cpu &c) {
        const std::uint32_t table = arg(c, 0);
        char raw[9] = {};
        std::memcpy(raw, ram_ptr(table + 12), 8);
        register_library(raw, table);
        c.r[2] = 0;
    });
    def("loadcore", 7, "ReleaseLibraryEntries", [](Cpu &c) { c.r[2] = 0; });
    def("loadcore", 12, "QueryBootMode", [](Cpu &c) { c.r[2] = 0; });
    def("loadcore", 27, "SetRebootTimeLibraryHandlingMode", [](Cpu &c) { c.r[2] = 0; });
}

void install_intrman() {
    register_hle_library("intrman", 0x0102);
    def("intrman", 4, "RegisterIntrHandler", [](Cpu &c) {
        register_interrupt(arg(c, 0), arg(c, 2), arg(c, 3), arg(c, 1));
        c.r[2] = 0;
    });
    def("intrman", 5, "ReleaseIntrHandler", [](Cpu &c) { release_interrupt(arg(c, 0)); c.r[2] = 0; });
    def("intrman", 6, "EnableIntr", [](Cpu &c) { enable_interrupt(arg(c, 0), true); c.r[2] = 0; });
    def("intrman", 7, "DisableIntr", [](Cpu &c) {
        enable_interrupt(arg(c, 0), false);
        if (arg(c, 1)) write32(arg(c, 1), arg(c, 0));
        c.r[2] = 0;
    });
    def("intrman", 8, "CpuDisableIntr", [](Cpu &c) { interrupt_state(true); c.r[2] = 0; });
    def("intrman", 9, "CpuEnableIntr", [](Cpu &c) { interrupt_state(false); c.r[2] = 0; });
    def("intrman", 17, "CpuSuspendIntr", [](Cpu &c) {
        const bool was = interrupts_suspended();
        if (arg(c, 0)) write32(arg(c, 0), was ? 0u : 1u);
        interrupt_state(true);
        c.r[2] = was ? static_cast<std::uint32_t>(-102) : 0u;
    });
    def("intrman", 18, "CpuResumeIntr", [](Cpu &c) {
        interrupt_state(arg(c, 0) == 0);
        c.r[2] = 0;
    });
    def("intrman", 23, "QueryIntrContext", [](Cpu &c) { c.r[2] = in_interrupt() ? 1u : 0u; });
}

void install_thbase() {
    register_hle_library("thbase", 0x0101);
    def("thbase", 4, "CreateThread", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        c.r[2] = static_cast<std::uint32_t>(create_thread(read32(p + 8), read32(p + 12), static_cast<int>(read32(p + 16)), c.r[28], read32(p), read32(p + 4)));
    });
    def("thbase", 5, "DeleteThread", [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        c.r[2] = delete_thread(t->id) ? 0u : static_cast<std::uint32_t>(-414);
    });
    def("thbase", 6, "StartThread", [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        start_thread(t->id, arg(c, 1));
        c.r[2] = 0;
    });
    def("thbase", 7, "StartThreadArgs", [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        start_thread(t->id, arg(c, 1), arg(c, 2));
        c.r[2] = 0;
    });
    auto exit_thread = [](Cpu &c) {
        Thread *t = current();
        if (!t) return;
        t->context = c;
        t->status = kDormant;
        auto on_exit = std::move(t->on_exit);
        t->on_exit = nullptr;
        if (on_exit) on_exit();
        reschedule();
    };
    def("thbase", 8, "ExitThread", exit_thread);
    def("thbase", 9, "ExitDeleteThread", [exit_thread](Cpu &c) {
        Thread *t = current();
        const int id = t ? t->id : 0;
        exit_thread(c);
        if (id) schedule(now() + 1, Job{kJobDeleteThread, static_cast<std::uint32_t>(id)});
    });
    auto terminate = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (t && t != current()) {
            t->status = kDormant;
            t->wait = kWaitNone;
        }
        c.r[2] = t ? 0u : static_cast<std::uint32_t>(kErrorUnknownThread);
    };
    def("thbase", 10, "TerminateThread", terminate);
    def("thbase", 11, "iTerminateThread", terminate);
    def("thbase", 12, "DisableDispatchThread", [](Cpu &c) { c.r[2] = 0; });
    def("thbase", 13, "EnableDispatchThread", [](Cpu &c) { c.r[2] = 0; });
    auto change_priority = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        int prio = static_cast<int>(arg(c, 1));
        if (prio == 0) prio = t->init_priority;
        t->priority = prio;
        reschedule();
        c.r[2] = 0;
    };
    def("thbase", 14, "ChangeThreadPriority", change_priority);
    def("thbase", 15, "iChangeThreadPriority", change_priority);
    auto rotate = [](Cpu &c) {
        Thread *t = current();
        if (t && (arg(c, 0) == 0 || static_cast<int>(arg(c, 0)) == t->priority)) {
            t->order = ++g_rotate_order;
            reschedule();
        }
        c.r[2] = 0;
    };
    def("thbase", 16, "RotateThreadReadyQueue", rotate);
    def("thbase", 17, "iRotateThreadReadyQueue", rotate);
    auto release_wait = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (t) {
            for (auto &[id, s] : g_semas) s.waiters.erase(std::remove(s.waiters.begin(), s.waiters.end(), t->id), s.waiters.end());
            for (auto &[id, e] : g_events) e.waiters.erase(std::remove(e.waiters.begin(), e.waiters.end(), t->id), e.waiters.end());
            wake(*t, static_cast<std::uint32_t>(-418));
            reschedule();
        }
        c.r[2] = t ? 0u : static_cast<std::uint32_t>(kErrorUnknownThread);
    };
    def("thbase", 18, "ReleaseWaitThread", release_wait);
    def("thbase", 19, "iReleaseWaitThread", release_wait);
    def("thbase", 20, "GetThreadId", [](Cpu &c) { c.r[2] = current() ? static_cast<std::uint32_t>(current()->id) : 0u; });
    def("thbase", 21, "CheckThreadStack", [](Cpu &c) { c.r[2] = 0x1000; });
    auto refer = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        const std::uint32_t p = arg(c, 1);
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        if (p) {
            write32(p + 0, t->attr);
            write32(p + 4, t->option);
            write32(p + 8, static_cast<std::uint32_t>(t->status));
            write32(p + 12, t->entry);
            write32(p + 16, t->stack);
            write32(p + 20, t->stack_size);
            write32(p + 24, t->gp);
            write32(p + 28, static_cast<std::uint32_t>(t->init_priority));
            write32(p + 32, static_cast<std::uint32_t>(t->priority));
            write32(p + 36, static_cast<std::uint32_t>(t->wait));
            write32(p + 40, static_cast<std::uint32_t>(t->wait_id));
            write32(p + 44, static_cast<std::uint32_t>(t->wakeups));
        }
        c.r[2] = 0;
    };
    def("thbase", 22, "ReferThreadStatus", refer);
    def("thbase", 23, "iReferThreadStatus", refer);
    def("thbase", 24, "SleepThread", [](Cpu &c) {
        Thread *t = current();
        c.r[2] = 0;
        if (t && t->wakeups > 0) { --t->wakeups; return; }
        block(c, kWaitSleep, 0);
    });
    auto wakeup = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        if (!t) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownThread); return; }
        if (t->status == kWait && t->wait == kWaitSleep) {
            wake(*t, 0);
            reschedule();
        } else {
            ++t->wakeups;
        }
        c.r[2] = 0;
    };
    def("thbase", 25, "WakeupThread", wakeup);
    def("thbase", 26, "iWakeupThread", wakeup);
    auto cancel_wakeup = [](Cpu &c) {
        Thread *t = thread(static_cast<int>(arg(c, 0)));
        c.r[2] = t ? static_cast<std::uint32_t>(t->wakeups) : static_cast<std::uint32_t>(kErrorUnknownThread);
        if (t) t->wakeups = 0;
    };
    def("thbase", 27, "CancelWakeupThread", cancel_wakeup);
    def("thbase", 28, "iCancelWakeupThread", cancel_wakeup);
    def("thbase", 29, "SuspendThread", [](Cpu &c) { c.r[2] = 0; });
    def("thbase", 31, "ResumeThread", [](Cpu &c) { c.r[2] = 0; });
    def("thbase", 33, "DelayThread", [](Cpu &c) {
        Thread *t = current();
        c.r[2] = 0;
        if (!t) return;
        const int id = t->id;
        block(c, kWaitDelay, 0);
        schedule(now() + std::max<std::uint64_t>(1, usec_to_cycles(arg(c, 0))), Job{kJobDelayWake, static_cast<std::uint32_t>(id)});
    });
    def("thbase", 34, "GetSystemTime", [](Cpu &c) { write_clock(arg(c, 0), now()); c.r[2] = 0; });
    auto set_alarm = [](Cpu &c) {
        const std::uint64_t delay = read_clock(arg(c, 0));
        const std::uint64_t key = g_next_alarm++;
        g_alarms[key] = Alarm{arg(c, 1), arg(c, 2), true};
        schedule(now() + std::max<std::uint64_t>(1, delay), Job{kJobAlarm, static_cast<std::uint32_t>(key), static_cast<std::uint32_t>(key >> 32)});
        c.r[2] = 0;
    };
    def("thbase", 35, "SetAlarm", set_alarm);
    def("thbase", 36, "iSetAlarm", set_alarm);
    auto cancel_alarm = [](Cpu &c) {
        for (auto &[k, a] : g_alarms)
            if (a.handler == arg(c, 0) && a.arg == arg(c, 1)) a.active = false;
        c.r[2] = 0;
    };
    def("thbase", 37, "CancelAlarm", cancel_alarm);
    def("thbase", 38, "iCancelAlarm", cancel_alarm);
    def("thbase", 39, "USec2SysClock", [](Cpu &c) { write_clock(arg(c, 1), usec_to_cycles(arg(c, 0))); c.r[2] = 0; });
    def("thbase", 40, "SysClock2USec", [](Cpu &c) {
        const std::uint64_t usec = read_clock(arg(c, 0)) * 1000u / 36864u;
        write32(arg(c, 1), static_cast<std::uint32_t>(usec / 1000000u));
        write32(arg(c, 2), static_cast<std::uint32_t>(usec % 1000000u));
        c.r[2] = 0;
    });
    def("thbase", 41, "GetSystemStatusFlag", [](Cpu &c) { c.r[2] = 0; });
    def("thbase", 43, "GetSystemTimeLow", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(now()); });
}

void install_thsemap() {
    register_hle_library("thsemap", 0x0101);
    def("thsemap", 4, "CreateSema", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        const int id = g_next_object++;
        g_semas[id] = Sema{static_cast<int>(read32(p + 8)), static_cast<int>(read32(p + 12)), read32(p), read32(p + 4), {}};
        c.r[2] = static_cast<std::uint32_t>(id);
    });
    def("thsemap", 5, "DeleteSema", [](Cpu &c) {
        auto it = g_semas.find(static_cast<int>(arg(c, 0)));
        if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
        for (int t : it->second.waiters)
            if (Thread *th = thread(t)) wake(*th, static_cast<std::uint32_t>(-425));
        g_semas.erase(it);
        reschedule();
        c.r[2] = 0;
    });
    def("thsemap", 6, "SignalSema", [](Cpu &c) { signal_sema(c, static_cast<int>(arg(c, 0)), false); });
    def("thsemap", 7, "iSignalSema", [](Cpu &c) { signal_sema(c, static_cast<int>(arg(c, 0)), true); });
    def("thsemap", 8, "WaitSema", [](Cpu &c) {
        auto it = g_semas.find(static_cast<int>(arg(c, 0)));
        if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
        c.r[2] = 0;
        if (it->second.count > 0) { --it->second.count; return; }
        it->second.waiters.push_back(current() ? current()->id : 0);
        block(c, kWaitSema, it->first);
    });
    def("thsemap", 9, "PollSema", [](Cpu &c) {
        auto it = g_semas.find(static_cast<int>(arg(c, 0)));
        if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
        if (it->second.count > 0) { --it->second.count; c.r[2] = 0; }
        else c.r[2] = static_cast<std::uint32_t>(kErrorSemaZero);
    });
    auto refer = [](Cpu &c) {
        auto it = g_semas.find(static_cast<int>(arg(c, 0)));
        if (it == g_semas.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownSema); return; }
        const std::uint32_t p = arg(c, 1);
        write32(p + 0, it->second.attr);
        write32(p + 4, it->second.option);
        write32(p + 8, 0);
        write32(p + 12, static_cast<std::uint32_t>(it->second.max));
        write32(p + 16, static_cast<std::uint32_t>(it->second.count));
        write32(p + 20, static_cast<std::uint32_t>(it->second.waiters.size()));
        c.r[2] = 0;
    };
    def("thsemap", 11, "ReferSemaStatus", refer);
    def("thsemap", 12, "iReferSemaStatus", refer);
}

void install_thevent() {
    register_hle_library("thevent", 0x0101);
    def("thevent", 4, "CreateEventFlag", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        const int id = g_next_object++;
        g_events[id] = EventFlag{read32(p + 8), read32(p), read32(p + 4), {}};
        c.r[2] = static_cast<std::uint32_t>(id);
    });
    def("thevent", 5, "DeleteEventFlag", [](Cpu &c) {
        auto it = g_events.find(static_cast<int>(arg(c, 0)));
        if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
        for (int t : it->second.waiters)
            if (Thread *th = thread(t)) wake(*th, static_cast<std::uint32_t>(-425));
        g_events.erase(it);
        c.r[2] = 0;
    });
    def("thevent", 6, "SetEventFlag", [](Cpu &c) { set_event(c, static_cast<int>(arg(c, 0)), arg(c, 1), false); });
    def("thevent", 7, "iSetEventFlag", [](Cpu &c) { set_event(c, static_cast<int>(arg(c, 0)), arg(c, 1), true); });
    auto clear = [](Cpu &c) {
        auto it = g_events.find(static_cast<int>(arg(c, 0)));
        if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
        it->second.bits &= arg(c, 1);
        c.r[2] = 0;
    };
    def("thevent", 8, "ClearEventFlag", clear);
    def("thevent", 9, "iClearEventFlag", clear);
    def("thevent", 10, "WaitEventFlag", [](Cpu &c) {
        auto it = g_events.find(static_cast<int>(arg(c, 0)));
        if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
        EventFlag &e = it->second;
        c.r[2] = 0;
        if (event_matches(e, arg(c, 1), arg(c, 2))) {
            event_take(e, arg(c, 1), arg(c, 2), arg(c, 3));
            return;
        }
        Thread *t = current();
        if (!t) return;
        t->event_bits = arg(c, 1);
        t->event_mode = arg(c, 2);
        t->event_result = arg(c, 3);
        e.waiters.push_back(t->id);
        block(c, kWaitEvent, it->first);
    });
    auto poll = [](Cpu &c) {
        auto it = g_events.find(static_cast<int>(arg(c, 0)));
        if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
        if (event_matches(it->second, arg(c, 1), arg(c, 2))) {
            event_take(it->second, arg(c, 1), arg(c, 2), arg(c, 3));
            c.r[2] = 0;
        } else {
            c.r[2] = static_cast<std::uint32_t>(kErrorEventCondition);
        }
    };
    def("thevent", 11, "PollEventFlag", poll);
    def("thevent", 12, "iPollEventFlag", poll);
    auto refer = [](Cpu &c) {
        auto it = g_events.find(static_cast<int>(arg(c, 0)));
        if (it == g_events.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownEvent); return; }
        const std::uint32_t p = arg(c, 1);
        write32(p + 0, it->second.attr);
        write32(p + 4, it->second.option);
        write32(p + 8, 0);
        write32(p + 12, it->second.bits);
        write32(p + 16, static_cast<std::uint32_t>(it->second.waiters.size()));
        c.r[2] = 0;
    };
    def("thevent", 13, "ReferEventFlagStatus", refer);
    def("thevent", 14, "iReferEventFlagStatus", refer);
}

void install_thmsgbx() {
    register_hle_library("thmsgbx", 0x0101);
    def("thmsgbx", 4, "CreateMbx", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        const int id = g_next_object++;
        g_mbxs[id] = Mbx{read32(p), read32(p + 4), {}, {}};
        c.r[2] = static_cast<std::uint32_t>(id);
    });
    def("thmsgbx", 5, "DeleteMbx", [](Cpu &c) { g_mbxs.erase(static_cast<int>(arg(c, 0))); c.r[2] = 0; });
    def("thmsgbx", 6, "SendMbx", [](Cpu &c) { send_mbx(c, static_cast<int>(arg(c, 0)), arg(c, 1), false); });
    def("thmsgbx", 7, "iSendMbx", [](Cpu &c) { send_mbx(c, static_cast<int>(arg(c, 0)), arg(c, 1), true); });
    def("thmsgbx", 8, "ReceiveMbx", [](Cpu &c) {
        auto it = g_mbxs.find(static_cast<int>(arg(c, 1)));
        if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
        c.r[2] = 0;
        if (!it->second.messages.empty()) {
            write32(arg(c, 0), it->second.messages.front());
            it->second.messages.pop_front();
            return;
        }
        Thread *t = current();
        if (!t) return;
        t->message_out = arg(c, 0);
        it->second.waiters.push_back(t->id);
        block(c, kWaitMbx, it->first);
    });
    def("thmsgbx", 9, "PollMbx", [](Cpu &c) {
        auto it = g_mbxs.find(static_cast<int>(arg(c, 1)));
        if (it == g_mbxs.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownMbx); return; }
        if (it->second.messages.empty()) { c.r[2] = static_cast<std::uint32_t>(kErrorMbxNone); return; }
        write32(arg(c, 0), it->second.messages.front());
        it->second.messages.pop_front();
        c.r[2] = 0;
    });
}

void install_thfpool() {
    register_hle_library("thfpool", 0x0101);
    def("thfpool", 4, "CreateFpl", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        Fpl f{read32(p), read32(p + 4), (read32(p + 8) + 3u) & ~3u, read32(p + 12), 0, {}, {}};
        f.base = alloc(f.block_size * f.blocks);
        if (!f.base) { c.r[2] = static_cast<std::uint32_t>(kErrorNoMemory); return; }
        for (std::uint32_t i = f.blocks; i-- > 0;) f.free.push_back(f.base + i * f.block_size);
        const int id = g_next_object++;
        g_fpls[id] = f;
        c.r[2] = static_cast<std::uint32_t>(id);
    });
    def("thfpool", 5, "DeleteFpl", [](Cpu &c) {
        auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
        if (it != g_fpls.end()) { free(it->second.base); g_fpls.erase(it); }
        c.r[2] = 0;
    });
    def("thfpool", 6, "AllocateFpl", [](Cpu &c) {
        auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
        if (!it->second.free.empty()) { c.r[2] = it->second.free.back(); it->second.free.pop_back(); return; }
        it->second.waiters.push_back(current() ? current()->id : 0);
        block(c, kWaitFpl, it->first);
    });
    auto poll = [](Cpu &c) {
        auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
        if (it->second.free.empty()) { c.r[2] = 0; return; }
        c.r[2] = it->second.free.back();
        it->second.free.pop_back();
    };
    def("thfpool", 7, "pAllocateFpl", poll);
    def("thfpool", 8, "ipAllocateFpl", poll);
    def("thfpool", 9, "FreeFpl", [](Cpu &c) {
        auto it = g_fpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_fpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownFpl); return; }
        if (!it->second.waiters.empty()) {
            const int t = it->second.waiters.front();
            it->second.waiters.pop_front();
            if (Thread *th = thread(t)) wake(*th, arg(c, 1));
            reschedule();
        } else {
            it->second.free.push_back(arg(c, 1));
        }
        c.r[2] = 0;
    });
}

std::uint32_t vpl_take(Vpl &v, std::uint32_t size) {
    size = (size + 7u) & ~7u;
    if (size == 0u) size = 8u;
    std::uint32_t at = v.base;
    for (const auto &[address, length] : v.blocks) {
        if (address - at >= size) break;
        at = address + length;
    }
    if (at + size > v.base + v.size) return 0;
    v.blocks[at] = size;
    return at;
}

std::uint32_t vpl_used(const Vpl &v) {
    std::uint32_t used = 0;
    for (const auto &[address, length] : v.blocks) {
        (void)address;
        used += length;
    }
    return used;
}

void install_thvpool() {
    register_hle_library("thvpool", 0x0101);
    def("thvpool", 4, "CreateVpl", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        Vpl v{read32(p), read32(p + 4), 0, (read32(p + 8) + 7u) & ~7u, {}, {}};
        v.base = alloc(v.size);
        if (!v.base) { c.r[2] = static_cast<std::uint32_t>(kErrorNoMemory); return; }
        const int id = g_next_object++;
        g_vpls[id] = v;
        c.r[2] = static_cast<std::uint32_t>(id);
    });
    def("thvpool", 5, "DeleteVpl", [](Cpu &c) {
        auto it = g_vpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_vpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownVpl); return; }
        for (const VplWaiter &w : it->second.waiters)
            if (Thread *th = thread(w.thread)) wake(*th, static_cast<std::uint32_t>(kErrorWaitDelete));
        if (!it->second.waiters.empty()) reschedule();
        free(it->second.base);
        g_vpls.erase(it);
        c.r[2] = 0;
    });
    def("thvpool", 6, "AllocateVpl", [](Cpu &c) {
        auto it = g_vpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_vpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownVpl); return; }
        if (const std::uint32_t at = vpl_take(it->second, arg(c, 1))) { c.r[2] = at; return; }
        it->second.waiters.push_back(VplWaiter{current() ? current()->id : 0, arg(c, 1)});
        block(c, kWaitVpl, it->first);
    });
    auto poll = [](Cpu &c) {
        auto it = g_vpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_vpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownVpl); return; }
        const std::uint32_t at = vpl_take(it->second, arg(c, 1));
        c.r[2] = at ? at : static_cast<std::uint32_t>(kErrorNoMemory);
    };
    def("thvpool", 7, "pAllocateVpl", poll);
    def("thvpool", 8, "ipAllocateVpl", poll);
    def("thvpool", 9, "FreeVpl", [](Cpu &c) {
        auto it = g_vpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_vpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownVpl); return; }
        Vpl &v = it->second;
        v.blocks.erase(arg(c, 1));
        bool woke = false;
        while (!v.waiters.empty()) {
            const std::uint32_t at = vpl_take(v, v.waiters.front().size);
            if (!at) break;
            if (Thread *th = thread(v.waiters.front().thread)) wake(*th, at);
            v.waiters.pop_front();
            woke = true;
        }
        if (woke) reschedule();
        c.r[2] = 0;
    });
    auto refer = [](Cpu &c) {
        auto it = g_vpls.find(static_cast<int>(arg(c, 0)));
        if (it == g_vpls.end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownVpl); return; }
        const Vpl &v = it->second;
        if (const std::uint32_t p = arg(c, 1)) {
            write32(p + 0, v.attr);
            write32(p + 4, v.option);
            write32(p + 8, v.size);
            write32(p + 12, v.size - vpl_used(v));
            write32(p + 16, static_cast<std::uint32_t>(v.waiters.size()));
        }
        c.r[2] = 0;
    };
    def("thvpool", 11, "ReferVplStatus", refer);
    def("thvpool", 12, "iReferVplStatus", refer);
}

void install_sysclib() {
    register_hle_library("sysclib", 0x0103);
    def("sysclib", 4, "setjmp", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0);
        const int regs[12] = {31, 29, 30, 16, 17, 18, 19, 20, 21, 22, 23, 28};
        for (int i = 0; i < 12; ++i) write32(p + 4u * static_cast<std::uint32_t>(i), c.r[regs[i]]);
        c.r[2] = 0;
    });
    def("sysclib", 5, "longjmp", [](Cpu &c) {
        const std::uint32_t p = arg(c, 0), value = arg(c, 1);
        const int regs[12] = {31, 29, 30, 16, 17, 18, 19, 20, 21, 22, 23, 28};
        for (int i = 0; i < 12; ++i) c.r[regs[i]] = read32(p + 4u * static_cast<std::uint32_t>(i));
        c.pc = c.r[31];
        c.npc = c.pc + 4;
        c.r[2] = value ? value : 1u;
    });
    def("sysclib", 6, "_toupper", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(std::toupper(static_cast<int>(arg(c, 0) & 0xFF))); });
    def("sysclib", 7, "_tolower", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(std::tolower(static_cast<int>(arg(c, 0) & 0xFF))); });
    def("sysclib", 8, "look_ctype_table", [](Cpu &c) {
        const int ch = static_cast<int>(arg(c, 0) & 0xFF);
        std::uint32_t t = 0;
        if (std::isupper(ch)) t |= 1;
        if (std::islower(ch)) t |= 2;
        if (std::isdigit(ch)) t |= 4;
        if (std::isspace(ch)) t |= 8;
        if (std::ispunct(ch)) t |= 16;
        if (std::iscntrl(ch)) t |= 32;
        if (std::isxdigit(ch)) t |= 64;
        c.r[2] = t;
    });
    def("sysclib", 10, "memchr", [](Cpu &c) {
        for (std::uint32_t i = 0; i < arg(c, 2); ++i)
            if (read8(arg(c, 0) + i) == (arg(c, 1) & 0xFF)) { c.r[2] = arg(c, 0) + i; return; }
        c.r[2] = 0;
    });
    def("sysclib", 11, "memcmp", [](Cpu &c) {
        for (std::uint32_t i = 0; i < arg(c, 2); ++i) {
            const int d = read8(arg(c, 0) + i) - read8(arg(c, 1) + i);
            if (d) { c.r[2] = static_cast<std::uint32_t>(d); return; }
        }
        c.r[2] = 0;
    });
    auto copy = [](std::uint32_t dst, std::uint32_t src, std::uint32_t n) {
        if (phys(dst) + n <= kRamSize && phys(src) + n <= kRamSize) std::memmove(ram_ptr(dst), ram_ptr(src), n);
        else if (dst < src) for (std::uint32_t i = 0; i < n; ++i) write8(dst + i, read8(src + i));
        else for (std::uint32_t i = n; i-- > 0;) write8(dst + i, read8(src + i));
    };
    def("sysclib", 12, "memcpy", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
    def("sysclib", 13, "memmove", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
    def("sysclib", 14, "memset", [](Cpu &c) {
        if (phys(arg(c, 0)) + arg(c, 2) <= kRamSize) std::memset(ram_ptr(arg(c, 0)), static_cast<int>(arg(c, 1) & 0xFF), arg(c, 2));
        else for (std::uint32_t i = 0; i < arg(c, 2); ++i) write8(arg(c, 0) + i, static_cast<std::uint8_t>(arg(c, 1)));
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 15, "bcmp", [](Cpu &c) {
        c.r[2] = std::memcmp(ram_ptr(arg(c, 0)), ram_ptr(arg(c, 1)), arg(c, 2)) ? 1u : 0u;
    });
    def("sysclib", 16, "bcopy", [copy](Cpu &c) { copy(arg(c, 1), arg(c, 0), arg(c, 2)); });
    def("sysclib", 17, "bzero", [](Cpu &c) { std::memset(ram_ptr(arg(c, 0)), 0, arg(c, 1)); });
    def("sysclib", 19, "sprintf", [](Cpu &c) {
        const std::string s = format(c, arg(c, 1), 2);
        std::memcpy(ram_ptr(arg(c, 0)), s.c_str(), s.size() + 1);
        c.r[2] = static_cast<std::uint32_t>(s.size());
    });
    def("sysclib", 20, "strcat", [](Cpu &c) {
        const std::string a = ram_string(arg(c, 0), 4096), b = ram_string(arg(c, 1), 4096);
        std::memcpy(ram_ptr(arg(c, 0) + static_cast<std::uint32_t>(a.size())), b.c_str(), b.size() + 1);
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 21, "strchr", [](Cpu &c) {
        for (std::uint32_t p = arg(c, 0);; ++p) {
            const std::uint8_t ch = read8(p);
            if (ch == (arg(c, 1) & 0xFF)) { c.r[2] = p; return; }
            if (!ch) { c.r[2] = 0; return; }
        }
    });
    def("sysclib", 22, "strcmp", [](Cpu &c) {
        const int r = std::strcmp(ram_string(arg(c, 0), 4096).c_str(), ram_string(arg(c, 1), 4096).c_str());
        c.r[2] = static_cast<std::uint32_t>(r < 0 ? -1 : r > 0 ? 1 : 0);
    });
    def("sysclib", 23, "strcpy", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 1), 4096);
        std::memcpy(ram_ptr(arg(c, 0)), s.c_str(), s.size() + 1);
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 25, "index", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 0), 4096);
        const auto pos = s.find(static_cast<char>(arg(c, 1)));
        c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
    });
    def("sysclib", 27, "strlen", [](Cpu &c) { c.r[2] = static_cast<std::uint32_t>(ram_string(arg(c, 0), 65536).size()); });
    def("sysclib", 28, "strncat", [](Cpu &c) {
        const std::string a = ram_string(arg(c, 0), 4096), b = ram_string(arg(c, 1), arg(c, 2));
        std::memcpy(ram_ptr(arg(c, 0) + static_cast<std::uint32_t>(a.size())), b.c_str(), b.size() + 1);
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 29, "strncmp", [](Cpu &c) {
        const int r = std::strncmp(ram_string(arg(c, 0), 4096).c_str(), ram_string(arg(c, 1), 4096).c_str(), arg(c, 2));
        c.r[2] = static_cast<std::uint32_t>(r < 0 ? -1 : r > 0 ? 1 : 0);
    });
    def("sysclib", 30, "strncpy", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 1), arg(c, 2));
        for (std::uint32_t i = 0; i < arg(c, 2); ++i) write8(arg(c, 0) + i, i < s.size() ? static_cast<std::uint8_t>(s[i]) : 0);
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 32, "strrchr", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 0), 4096);
        const auto pos = s.rfind(static_cast<char>(arg(c, 1)));
        c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
    });
    def("sysclib", 34, "strstr", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 0), 4096), n = ram_string(arg(c, 1), 4096);
        const auto pos = s.find(n);
        c.r[2] = pos == std::string::npos ? 0u : arg(c, 0) + static_cast<std::uint32_t>(pos);
    });
    def("sysclib", 35, "strtok", [](Cpu &c) {
        std::uint32_t p = arg(c, 0) ? arg(c, 0) : g_strtok_next;
        const std::string delim = ram_string(arg(c, 1), 256);
        const auto is_delim = [&delim](std::uint8_t ch) { return ch && delim.find(static_cast<char>(ch)) != std::string::npos; };
        while (p && is_delim(read8(p))) ++p;
        if (!p || !read8(p)) {
            g_strtok_next = 0;
            c.r[2] = 0;
            return;
        }
        const std::uint32_t token = p;
        while (read8(p) && !is_delim(read8(p))) ++p;
        if (read8(p)) {
            write8(p, 0);
            g_strtok_next = p + 1;
        } else {
            g_strtok_next = p;
        }
        c.r[2] = token;
    });
    def("sysclib", 36, "strtol", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 0), 256);
        char *end = nullptr;
        const long v = std::strtol(s.c_str(), &end, static_cast<int>(arg(c, 2)));
        if (arg(c, 1)) write32(arg(c, 1), arg(c, 0) + static_cast<std::uint32_t>(end - s.c_str()));
        c.r[2] = static_cast<std::uint32_t>(v);
    });
    def("sysclib", 38, "strtoul", [](Cpu &c) {
        const std::string s = ram_string(arg(c, 0), 256);
        char *end = nullptr;
        const unsigned long v = std::strtoul(s.c_str(), &end, static_cast<int>(arg(c, 2)));
        if (arg(c, 1)) write32(arg(c, 1), arg(c, 0) + static_cast<std::uint32_t>(end - s.c_str()));
        c.r[2] = static_cast<std::uint32_t>(v);
    });
    def("sysclib", 40, "_wmemcopy", [copy](Cpu &c) { copy(arg(c, 0), arg(c, 1), arg(c, 2)); c.r[2] = arg(c, 0); });
    def("sysclib", 41, "_wmemset", [](Cpu &c) {
        for (std::uint32_t i = 0; i < arg(c, 2); i += 4) write32(arg(c, 0) + i, arg(c, 1));
        c.r[2] = arg(c, 0);
    });
    def("sysclib", 42, "vsprintf", [](Cpu &c) {
        const std::uint32_t list = arg(c, 2);
        std::string out;
        const std::string fmt = ram_string(arg(c, 1), 1024);
        std::uint32_t ap = list;
        for (std::size_t i = 0; i < fmt.size(); ++i) {
            if (fmt[i] != '%') { out += fmt[i]; continue; }
            std::string spec = "%";
            ++i;
            while (i < fmt.size() && std::strchr("-+ #0.0123456789", fmt[i])) spec += fmt[i++];
            while (i < fmt.size() && (fmt[i] == 'l' || fmt[i] == 'h')) ++i;
            if (i >= fmt.size()) break;
            char buf[512];
            const char conv = fmt[i];
            if (conv == '%') { out += '%'; continue; }
            const std::uint32_t v = read32(ap);
            ap += 4;
            if (conv == 's') std::snprintf(buf, sizeof buf, (spec + "s").c_str(), ram_string(v).c_str());
            else if (conv == 'd' || conv == 'i') std::snprintf(buf, sizeof buf, (spec + "d").c_str(), static_cast<int>(v));
            else if (conv == 'c') std::snprintf(buf, sizeof buf, (spec + "c").c_str(), static_cast<int>(v));
            else std::snprintf(buf, sizeof buf, (spec + conv).c_str(), v);
            out += buf;
        }
        std::memcpy(ram_ptr(arg(c, 0)), out.c_str(), out.size() + 1);
        c.r[2] = static_cast<std::uint32_t>(out.size());
    });
}

void install_stdio() {
    register_hle_library("stdio", 0x0102);
    def("stdio", 4, "printf", [](Cpu &c) {
        const std::string s = format(c, arg(c, 0), 1);
        print(s);
        c.r[2] = static_cast<std::uint32_t>(s.size());
    });
    def("stdio", 6, "putchar", [](Cpu &c) { print(std::string(1, static_cast<char>(arg(c, 0)))); c.r[2] = arg(c, 0); });
    def("stdio", 7, "puts", [](Cpu &c) { print(ram_string(arg(c, 0), 4096) + "\n"); c.r[2] = 0; });
}

void install_modload() {
    register_hle_library("modload", 0x0102);
    // the calling thread waits until the module's start routine returns, *result gets what it returned
    const auto start_and_wait = [](Cpu &c, int id, std::uint32_t arglen, std::uint32_t args, std::uint32_t result_at) {
        Thread *caller = current();
        if (!caller) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule); return; }
        std::string text;
        if (args && arglen && phys(args) + arglen <= kRamSize) text.assign(reinterpret_cast<const char *>(ram_ptr(args)), arglen);
        const int waiter = caller->id;
        const bool started = start_module(id, text, [waiter, result_at](int module, int result) {
            if (result_at) write32(result_at, static_cast<std::uint32_t>(result));
            if (Thread *t = thread(waiter)) wake(*t, static_cast<std::uint32_t>(module));
        });
        if (!started) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule); return; }
        block(c, kWaitHle, 0);
    };
    def("modload", 7, "LoadStartModule", [](Cpu &c) {
        Thread *caller = current();
        if (!caller) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule); return; }
        std::string text;
        const std::uint32_t arglen = arg(c, 1), args = arg(c, 2), result_at = arg(c, 3);
        if (args && arglen && phys(args) + arglen <= kRamSize) text.assign(reinterpret_cast<const char *>(ram_ptr(args)), arglen);
        const int waiter = caller->id;
        const std::int32_t id = load_module(ram_string(arg(c, 0), 256), text, [waiter, result_at](int module, int result) {
            if (result_at) write32(result_at, static_cast<std::uint32_t>(result));
            if (Thread *t = thread(waiter)) wake(*t, static_cast<std::uint32_t>(module));
        });
        if (id < 0) { c.r[2] = static_cast<std::uint32_t>(kErrorIllegalObject); return; }
        block(c, kWaitHle, 0);
    });
    def("modload", 8, "StartModule", [start_and_wait](Cpu &c) {
        start_and_wait(c, static_cast<int>(arg(c, 0)), arg(c, 2), arg(c, 3), arg(c, 4));
    });
    def("modload", 10, "LoadModuleBuffer", [](Cpu &c) {
        const std::uint32_t at = phys(arg(c, 0));
        if (at >= kRamSize) { c.r[2] = static_cast<std::uint32_t>(kErrorIllegalObject); return; }
        const std::uint8_t *p = ram_ptr(at);
        const std::int32_t id = link_module(std::vector<std::uint8_t>(p, p + (kRamSize - at)), "buffer");
        c.r[2] = static_cast<std::uint32_t>(id < 0 ? kErrorIllegalObject : id);
    });
    def("modload", 13, "SetCheckKelfPathCallback", [](Cpu &c) { c.r[2] = 0; });
    def("modload", 16, "GetModuleIdList", [](Cpu &c) {
        std::uint32_t n = 0;
        for (const auto &[id, m] : modules()) {
            if (n < arg(c, 1)) write32(arg(c, 0) + 4 * n, static_cast<std::uint32_t>(id));
            ++n;
        }
        if (arg(c, 2)) write32(arg(c, 2), n);
        c.r[2] = 0;
    });
    def("modload", 18, "GetModuleIdListByName", [](Cpu &c) {
        std::string name = ram_string(arg(c, 0), 64);
        for (char &ch : name) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
        std::uint32_t n = 0;
        for (const auto &[id, m] : modules()) {
            std::string a = m.name;
            for (char &ch : a) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
            if (a != name) continue;
            if (n < arg(c, 2)) write32(arg(c, 1) + 4 * n, static_cast<std::uint32_t>(id));
            ++n;
        }
        if (arg(c, 3)) write32(arg(c, 3), n);
        c.r[2] = 0;
    });
    def("modload", 17, "ReferModuleStatus", [](Cpu &c) {
        auto it = modules().find(static_cast<int>(arg(c, 0)));
        if (it == modules().end()) { c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule); return; }
        const std::uint32_t p = arg(c, 1);
        std::memset(ram_ptr(p), 0, 0x50);
        std::memcpy(ram_ptr(p), it->second.name.c_str(), std::min<std::size_t>(it->second.name.size(), 55));
        write32(p + 0x38, static_cast<std::uint32_t>(it->first));
        write32(p + 0x40, it->second.entry);
        write32(p + 0x44, it->second.gp);
        write32(p + 0x48, it->second.base);
        write32(p + 0x4C, it->second.size);
        c.r[2] = 0;
    });
    def("modload", 22, "SearchModuleByName", [](Cpu &c) {
        std::string name = ram_string(arg(c, 0), 64);
        for (const auto &[id, m] : modules()) {
            std::string a = m.name, b = name;
            for (char &ch : a) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
            for (char &ch : b) ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
            if (a == b) { c.r[2] = static_cast<std::uint32_t>(id); return; }
        }
        c.r[2] = static_cast<std::uint32_t>(kErrorUnknownModule);
    });
}

void install_vblank() {
    register_hle_library("vblank", 0x0101);
    def("vblank", 4, "WaitVblankStart", [](Cpu &c) {
        c.r[2] = 0;
        if (!current()) return;
        g_vblank_start_waiters.push_back(current()->id);
        block(c, kWaitVblank, 0);
    });
    def("vblank", 5, "WaitVblankEnd", [](Cpu &c) {
        c.r[2] = 0;
        if (!current()) return;
        g_vblank_end_waiters.push_back(current()->id);
        block(c, kWaitVblank, 1);
    });
    def("vblank", 6, "WaitVblank", [](Cpu &c) {
        c.r[2] = 0;
        if (!current()) return;
        g_vblank_start_waiters.push_back(current()->id);
        block(c, kWaitVblank, 0);
    });
    def("vblank", 7, "WaitNonVblank", [](Cpu &c) {
        c.r[2] = 0;
        if (!current()) return;
        g_vblank_end_waiters.push_back(current()->id);
        block(c, kWaitVblank, 1);
    });
    def("vblank", 8, "RegisterVblankHandler", [](Cpu &c) {
        g_vblank_handlers.push_back(VblankHandler{static_cast<int>(arg(c, 0)), arg(c, 2), arg(c, 3)});
        c.r[2] = 0;
    });
    def("vblank", 9, "ReleaseVblankHandler", [](Cpu &c) {
        g_vblank_handlers.erase(std::remove_if(g_vblank_handlers.begin(), g_vblank_handlers.end(), [&](const VblankHandler &h) {
            return h.edge == static_cast<int>(arg(c, 0)) && h.handler == arg(c, 1);
        }), g_vblank_handlers.end());
        c.r[2] = 0;
    });
}

void install_timrman() {
    register_hle_library("timrman", 0x0101);
    def("timrman", 4, "AllocHardTimer", [](Cpu &c) {
        const std::uint32_t id = g_next_hard_timer++;
        HardTimer &t = g_hard_timers[id];
        t.source = arg(c, 0);
        t.prescale = std::max<std::uint32_t>(arg(c, 2), 1u);
        c.r[2] = id;
    });
    def("timrman", 5, "ReferHardTimer", [](Cpu &c) { c.r[2] = 1; });
    def("timrman", 6, "FreeHardTimer", [](Cpu &c) { c.r[2] = 0; });
    def("timrman", 7, "SetTimerMode", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        t.mode = arg(c, 1);
        t.interrupt = (t.mode & 0x30u) != 0;
        t.running = t.interrupt;
        g_hard_timer_start[arg(c, 0)] = now();
        if (t.running) arm_hard_timer(arg(c, 0));
        else ++t.generation;
        c.r[2] = 0;
    });
    def("timrman", 8, "GetTimerStatus", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        c.r[2] = t.mode | t.reached;
        t.reached = 0;
    });
    def("timrman", 9, "SetTimerCounter", [](Cpu &c) {
        const auto it = g_hard_timers.find(arg(c, 0));
        if (it != g_hard_timers.end()) g_hard_timer_start[arg(c, 0)] = now() - std::min<std::uint64_t>(now(), static_cast<std::uint64_t>(arg(c, 1)) * timer_cycles(it->second, 1));
        c.r[2] = 0;
    });
    def("timrman", 10, "GetTimerCounter", [](Cpu &c) { c.r[2] = hard_timer_counter(arg(c, 0)); });
    def("timrman", 11, "SetTimerCompare", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        t.compare = arg(c, 1);
        if (t.running && t.interrupt) arm_hard_timer(arg(c, 0));
        c.r[2] = 0;
    });
    def("timrman", 16, "GetHardTimerIntrCode", [](Cpu &c) { c.r[2] = 14; });
    def("timrman", 20, "SetTimerHandler", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        t.compare = arg(c, 1);
        t.handler = arg(c, 2);
        t.common = arg(c, 3);
        if (t.running) arm_hard_timer(arg(c, 0));
        c.r[2] = 0;
    });
    def("timrman", 22, "SetupHardTimer", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        t.source = arg(c, 1);
        t.prescale = arg(c, 3);
        c.r[2] = 0;
    });
    def("timrman", 23, "StartHardTimer", [](Cpu &c) {
        g_hard_timers[arg(c, 0)].running = true;
        g_hard_timer_start[arg(c, 0)] = now();
        arm_hard_timer(arg(c, 0));
        c.r[2] = 0;
    });
    def("timrman", 24, "StopHardTimer", [](Cpu &c) {
        HardTimer &t = g_hard_timers[arg(c, 0)];
        t.running = false;
        ++t.generation;
        c.r[2] = 0;
    });
}

std::uint32_t dma_register(std::uint32_t ch, std::uint32_t reg) {
    return (ch < 7 ? 0x1F801080u + ch * 0x10u : 0x1F801500u + (ch - 7) * 0x10u) + reg * 4u;
}

std::uint32_t g_dma_direction[16];

void install_dmacman() {
    register_hle_library("dmacman", 0x0101);
    def("dmacman", 16, "dmac_set_dpcr2", [](Cpu &c) { c.r[2] = 0; });
    def("dmacman", 17, "dmac_get_dpcr2", [](Cpu &c) { c.r[2] = 0; });
    def("dmacman", 28, "sceSetSliceDMA", [](Cpu &c) {
        const std::uint32_t ch = arg(c, 0) & 15u;
        write32(dma_register(ch, 0), arg(c, 1));
        write32(dma_register(ch, 1), (arg(c, 3) << 16) | (arg(c, 2) & 0xFFFFu));
        g_dma_direction[ch] = arg(c, 4);
        c.r[2] = 1;
    });
    def("dmacman", 32, "sceStartDMA", [](Cpu &c) {
        const std::uint32_t ch = arg(c, 0) & 15u;
        write32(dma_register(ch, 2), 0x01000200u | (g_dma_direction[ch] & 1u));
        c.r[2] = 1;
    });
    def("dmacman", 33, "sceSetDMAPriority", [](Cpu &c) { c.r[2] = 1; });
    def("dmacman", 34, "sceEnableDMAChannel", [](Cpu &c) { c.r[2] = 1; });
    def("dmacman", 35, "sceDisableDMAChannel", [](Cpu &c) { c.r[2] = 1; });
}

void install_heaplib() {
    register_hle_library("heaplib", 0x0101);
    def("heaplib", 4, "CreateHeap", [](Cpu &c) {
        c.r[2] = kernel_alloc(16);
        g_heaps[c.r[2]];
    });
    def("heaplib", 5, "DeleteHeap", [](Cpu &c) {
        auto it = g_heaps.find(arg(c, 0));
        if (it != g_heaps.end()) {
            for (std::uint32_t block : it->second) free(block);
            g_heaps.erase(it);
        }
        c.r[2] = 0;
    });
    def("heaplib", 6, "AllocHeapMemory", [](Cpu &c) {
        c.r[2] = alloc(arg(c, 1));
        if (c.r[2]) g_heaps[arg(c, 0)].insert(c.r[2]);
    });
    def("heaplib", 7, "FreeHeapMemory", [](Cpu &c) {
        free(arg(c, 1));
        g_heaps[arg(c, 0)].erase(arg(c, 1));
        c.r[2] = 0;
    });
}

void install_misc() {
    register_hle_library("secrman", 0x0101);
    for (std::uint32_t i : {4u, 5u}) def("secrman", i, "secrman", [](Cpu &c) { c.r[2] = 0; });
    def("secrman", 6, "SecrAuthCard", [](Cpu &c) { c.r[2] = 1; });
}

}

void vblank_edge(bool start) {
    auto &waiters = start ? g_vblank_start_waiters : g_vblank_end_waiters;
    for (int id : waiters)
        if (Thread *t = thread(id)) wake(*t, 0);
    if (!waiters.empty()) reschedule();
    waiters.clear();
    for (const VblankHandler h : std::vector<VblankHandler>(g_vblank_handlers))
        if ((h.edge == 0) == start) call_guest(h.handler, h.arg);
}

void install_libraries() {
    g_semas.clear();
    g_events.clear();
    g_mbxs.clear();
    g_fpls.clear();
    g_heaps.clear();
    g_vblank_handlers.clear();
    g_vblank_start_waiters.clear();
    g_vblank_end_waiters.clear();
    g_alarms.clear();
    g_hard_timers.clear();
    g_hard_timer_start.clear();
    g_vpls.clear();
    g_next_object = 1;
    g_next_alarm = 1;
    g_rotate_order = 1ull << 40;
    g_strtok_next = 0;
    g_next_hard_timer = 1;
    register_job(kJobHardTimer, [](const Job &j) { fire_hard_timer(j.a, j.b | (static_cast<std::uint64_t>(j.c) << 32)); });
    register_job(kJobAlarm, [](const Job &j) { fire_alarm(j.a | (static_cast<std::uint64_t>(j.b) << 32)); });
    register_job(kJobDeleteThread, [](const Job &j) { delete_thread(static_cast<int>(j.a)); });
    register_job(kJobDelayWake, [](const Job &j) {
        Thread *th = thread(static_cast<int>(j.a));
        if (th && th->wait == kWaitDelay) wake(*th, 0);
    });
    install_sysmem();
    install_loadcore();
    install_intrman();
    install_thbase();
    install_thsemap();
    install_thevent();
    install_thmsgbx();
    install_thfpool();
    install_thvpool();
    install_sysclib();
    install_stdio();
    install_modload();
    install_vblank();
    install_timrman();
    install_dmacman();
    install_heaplib();
    install_misc();
}

void libs_state(ps2::state::Stream &s) {
    s.tag("ioplibs");
    s.map(g_semas, [&s](Sema &v) {
        s.pod(v.count);
        s.pod(v.max);
        s.pod(v.attr);
        s.pod(v.option);
        s.deque(v.waiters);
    });
    s.map(g_events, [&s](EventFlag &v) {
        s.pod(v.bits);
        s.pod(v.attr);
        s.pod(v.option);
        s.deque(v.waiters);
    });
    s.map(g_mbxs, [&s](Mbx &v) {
        s.pod(v.attr);
        s.pod(v.option);
        s.deque(v.messages);
        s.deque(v.waiters);
    });
    s.map(g_fpls, [&s](Fpl &v) {
        s.pod(v.attr);
        s.pod(v.option);
        s.pod(v.block_size);
        s.pod(v.blocks);
        s.pod(v.base);
        s.vec(v.free);
        s.deque(v.waiters);
    });
    if (s.version() >= 3)
        s.map(g_vpls, [&s](Vpl &v) {
            s.pod(v.attr);
            s.pod(v.option);
            s.pod(v.base);
            s.pod(v.size);
            s.map(v.blocks);
            s.deque(v.waiters);
        });
    s.map(g_heaps, [&s](std::set<std::uint32_t> &v) { s.set(v); });
    s.vec(g_vblank_handlers);
    s.vec(g_vblank_start_waiters);
    s.vec(g_vblank_end_waiters);
    s.map(g_alarms);
    if (s.version() >= 5)
        s.map(g_hard_timers, [&s](HardTimer &t) {
            s.pod(t.compare);
            s.pod(t.handler);
            s.pod(t.common);
            s.pod(t.source);
            s.pod(t.prescale);
            s.pod(t.mode);
            s.pod(t.reached);
            s.pod(t.running);
            s.pod(t.interrupt);
            s.pod(t.generation);
        });
    else
        s.map(g_hard_timers, [&s](HardTimer &t) {
            LegacyHardTimer old;
            s.pod(old);
            t.compare = old.compare;
            t.handler = old.handler;
            t.common = old.common;
            t.source = old.source;
            t.prescale = old.prescale;
            t.running = old.running;
            t.generation = old.generation;
        });
    s.pod(g_next_alarm);
    s.pod(g_next_object);
    s.pod(g_rotate_order);
    s.pod(g_strtok_next);
    s.pod(g_next_hard_timer);
    s.pod(g_dma_direction);
}

}

namespace ps2::iop {

void vblank(bool start) {
    hw::raise_interrupt(start ? 0u : 11u);
    kernel::vblank_edge(start);
}

}