PS2 games in the browser: static recompilation to WebAssembly with a native runtime
C++
#include "vif.hpp"
#include "dmac.hpp"
#include "gs/gif.hpp"
#include "gs/queue.hpp"
#include "hw.hpp"
#include "vu_micro.hpp"
#include "ps2/state.hpp"
#include <cstdio>
#include <cstring>
#include <vector>
namespace ps2::vif {
namespace {
struct Unit {
std::uint32_t stat = 0, err = 0, mark = 0, cycle = 0, mode = 0, num = 0, mask = 0, code = 0;
std::uint32_t itops = 0, base = 0, ofst = 0, tops = 0, itop = 0, top = 0;
std::uint32_t row[4] = {}, col[4] = {};
bool dbf = false, stalled = false;
std::vector<std::uint32_t> pending;
};
Unit g_units[2];
Unit g_vu_side;
std::uint64_t g_commands[2][128];
std::uint8_t g_dry_run[16384];
bool on_vu_thread() { return gs::queue::role() == gs::queue::Role::Vu; }
bool shadow(int unit) { return unit == 1 && gs::queue::vu_active() && !on_vu_thread(); }
Unit &state(int unit) { return unit == 1 && on_vu_thread() ? g_vu_side : g_units[unit]; }
std::uint8_t *vu_data(int unit) { return unit ? g_vu1_mem : g_vu0_mem; }
std::uint32_t vu_qwords(int unit) { return unit ? 1024u : 256u; }
std::uint32_t element_bits(std::uint32_t vl) {
switch (vl) {
case 0: return 32;
case 1: return 16;
case 2: return 8;
default: return 16;
}
}
std::uint32_t unpack_words(std::uint32_t cmd, const Unit &u, std::uint32_t num) {
const std::uint32_t vn = (cmd >> 26) & 3u, vl = (cmd >> 24) & 3u;
const std::uint32_t cl = u.cycle & 0xFFu, wl = (u.cycle >> 8) & 0xFFu;
std::uint32_t data = num;
if (wl > cl && wl) data = (num / wl) * cl + std::min(num % wl, cl);
const std::uint32_t bits = (vn == 3 && vl == 3) ? 16u : (vn + 1) * element_bits(vl);
return (data * bits + 31) / 32;
}
void run_vu(int unit, std::uint32_t address) {
Unit &u = state(unit);
if (unit == 1) {
u.top = u.tops;
u.itop = u.itops;
u.dbf = !u.dbf;
u.tops = u.base + (u.dbf ? u.ofst : 0);
if (shadow(unit)) return;
vu::set_tops(1, u.top, u.itop);
} else {
u.itop = u.itops;
vu::set_tops(0, 0, u.itop);
}
vu::run(unit, address);
}
template <std::uint32_t Bits, std::uint32_t Components, bool Usn>
void unpack_fast(std::uint8_t *mem, std::uint32_t mask, std::uint32_t addr, std::uint32_t wl, std::uint32_t skip, const std::uint8_t *bytes, std::uint32_t num) {
std::uint32_t cycle = 0;
for (std::uint32_t n = 0; n < num; ++n) {
std::uint32_t value[4];
for (std::uint32_t j = 0; j < Components; ++j) {
const std::size_t at = static_cast<std::size_t>(n) * Components + j;
if constexpr (Bits == 32) {
std::memcpy(&value[j], bytes + at * 4, 4);
} else if constexpr (Bits == 16) {
std::uint16_t h;
std::memcpy(&h, bytes + at * 2, 2);
value[j] = Usn ? h : static_cast<std::uint32_t>(static_cast<std::int32_t>(static_cast<std::int16_t>(h)));
} else {
value[j] = Usn ? bytes[at] : static_cast<std::uint32_t>(static_cast<std::int32_t>(static_cast<std::int8_t>(bytes[at])));
}
}
if constexpr (Components == 1) {
value[1] = value[2] = value[3] = value[0];
} else if constexpr (Components == 2) {
value[2] = value[0];
value[3] = value[1];
} else if constexpr (Components == 3) {
value[3] = 0;
}
std::memcpy(mem + (addr & mask) * 16, value, 16);
++addr;
if (++cycle >= wl) {
addr += skip;
cycle = 0;
}
}
}
using FastUnpack = void (*)(std::uint8_t *, std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t, const std::uint8_t *, std::uint32_t);
template <std::uint32_t Bits>
constexpr FastUnpack fast_pair(std::uint32_t components, bool usn) {
switch (components) {
case 1: return usn ? unpack_fast<Bits, 1, true> : unpack_fast<Bits, 1, false>;
case 2: return usn ? unpack_fast<Bits, 2, true> : unpack_fast<Bits, 2, false>;
case 3: return usn ? unpack_fast<Bits, 3, true> : unpack_fast<Bits, 3, false>;
default: return usn ? unpack_fast<Bits, 4, true> : unpack_fast<Bits, 4, false>;
}
}
constexpr FastUnpack kFastUnpack[4][4][2] = {
{{fast_pair<32>(1, false), fast_pair<32>(1, true)}, {fast_pair<32>(2, false), fast_pair<32>(2, true)}, {fast_pair<32>(3, false), fast_pair<32>(3, true)}, {fast_pair<32>(4, false), fast_pair<32>(4, true)}},
{{fast_pair<16>(1, false), fast_pair<16>(1, true)}, {fast_pair<16>(2, false), fast_pair<16>(2, true)}, {fast_pair<16>(3, false), fast_pair<16>(3, true)}, {fast_pair<16>(4, false), fast_pair<16>(4, true)}},
{{fast_pair<8>(1, false), fast_pair<8>(1, true)}, {fast_pair<8>(2, false), fast_pair<8>(2, true)}, {fast_pair<8>(3, false), fast_pair<8>(3, true)}, {fast_pair<8>(4, false), fast_pair<8>(4, true)}},
{{fast_pair<16>(1, false), fast_pair<16>(1, true)}, {fast_pair<16>(2, false), fast_pair<16>(2, true)}, {fast_pair<16>(3, false), fast_pair<16>(3, true)}, {fast_pair<16>(4, false), fast_pair<16>(4, true)}},
};
void unpack(int unit, std::uint32_t cmd, const std::uint32_t *data) {
Unit &u = state(unit);
const bool dry = shadow(unit);
if (dry && u.mode != 2) {
u.num = 0;
return;
}
const std::uint32_t vn = (cmd >> 26) & 3u, vl = (cmd >> 24) & 3u;
const bool masked = (cmd >> 28) & 1u;
const bool usn = (cmd >> 14) & 1u;
std::uint32_t num = (cmd >> 16) & 0xFFu;
if (!num) num = 256;
std::uint32_t addr = cmd & 0x3FFu;
if (unit == 1 && ((cmd >> 15) & 1u)) addr += u.tops;
const std::uint32_t cl = u.cycle & 0xFFu, wl = (u.cycle >> 8) & 0xFFu;
const std::uint32_t components = vn + 1;
const std::uint32_t bits = element_bits(vl);
std::size_t bit_pos = 0;
auto read_element = [&]() -> std::uint32_t {
const std::size_t word = bit_pos / 32, shift = bit_pos % 32;
std::uint32_t raw = data[word] >> shift;
if (bits < 32) raw &= (1u << bits) - 1u;
bit_pos += bits;
if (bits == 16) return usn ? raw : static_cast<std::uint32_t>(static_cast<std::int32_t>(static_cast<std::int16_t>(raw)));
if (bits == 8) return usn ? raw : static_cast<std::uint32_t>(static_cast<std::int32_t>(static_cast<std::int8_t>(raw)));
return raw;
};
std::uint32_t cycle = 0;
std::uint8_t *mem = dry ? g_dry_run : vu_data(unit);
const std::uint32_t wrap = vu_qwords(unit);
if (!masked && u.mode == 0 && !(wl > cl) && !(vn == 3 && vl == 3)) {
kFastUnpack[vl][vn][usn ? 1 : 0](mem, wrap - 1, addr, wl, cl - wl, reinterpret_cast<const std::uint8_t *>(data), num);
u.num = 0;
return;
}
for (std::uint32_t n = 0; n < num; ++n) {
const bool fill = wl > cl && cycle >= cl;
std::uint32_t value[4] = {0, 0, 0, 0};
if (!fill) {
if (vn == 3 && vl == 3) {
const std::uint32_t c = read_element() & 0xFFFFu;
value[0] = (c & 0x1Fu) << 3;
value[1] = ((c >> 5) & 0x1Fu) << 3;
value[2] = ((c >> 10) & 0x1Fu) << 3;
value[3] = ((c >> 15) & 1u) << 7;
} else {
for (std::uint32_t j = 0; j < components; ++j) value[j] = read_element();
if (components == 1) value[1] = value[2] = value[3] = value[0];
else if (components == 2) { value[2] = value[0]; value[3] = value[1]; }
}
}
std::uint8_t *q = mem + (addr % wrap) * 16;
const std::uint32_t mrow = std::min<std::uint32_t>(cycle, 3u);
for (std::uint32_t j = 0; j < 4; ++j) {
std::uint32_t m = masked ? (u.mask >> ((mrow * 4 + j) * 2)) & 3u : 0u;
if (fill && m == 0) m = 1;
std::uint32_t out;
if (m == 3) continue;
if (m == 1) out = u.row[j];
else if (m == 2) out = u.col[mrow];
else if (u.mode == 1) out = value[j] + u.row[j];
else if (u.mode == 2) { out = value[j] + u.row[j]; u.row[j] = out; }
else out = value[j];
std::memcpy(q + j * 4, &out, 4);
}
++addr;
++cycle;
if (cl >= wl) {
if (cycle >= wl) {
addr += cl - wl;
cycle = 0;
}
} else if (cycle >= wl) {
cycle = 0;
}
}
u.num = 0;
}
std::uint32_t data_words(int unit, std::uint32_t cmd) {
const Unit &u = state(unit);
const std::uint32_t op = (cmd >> 24) & 0x7Fu;
const std::uint32_t num = (cmd >> 16) & 0xFFu;
switch (op) {
case 0x20: return 1;
case 0x30: case 0x31: return 4;
case 0x4A: return (num ? num : 256u) * 2u;
case 0x50: case 0x51: return ((cmd & 0xFFFFu) ? (cmd & 0xFFFFu) : 0x10000u) * 4u;
default:
if ((op & 0x60u) == 0x60u) return unpack_words(cmd, u, num ? num : 256u);
return 0;
}
}
void execute(int unit, std::uint32_t cmd, const std::uint32_t *data) {
Unit &u = state(unit);
const std::uint32_t op = (cmd >> 24) & 0x7Fu, imm = cmd & 0xFFFFu, num = (cmd >> 16) & 0xFFu;
u.code = cmd;
if (!on_vu_thread()) ++g_commands[unit][op];
switch (op) {
case 0x00: break;
case 0x01: u.cycle = imm; break;
case 0x02: u.ofst = imm & 0x3FFu; u.dbf = false; u.tops = u.base; break;
case 0x03: u.base = imm & 0x3FFu; break;
case 0x04: u.itops = imm & 0x3FFu; break;
case 0x05: u.mode = imm & 3u; break;
case 0x06: gif::set_path3_masked((imm >> 15) & 1u); break;
case 0x07: u.mark = imm; break;
case 0x10: case 0x11: case 0x13: break;
case 0x14: case 0x15: run_vu(unit, imm * 8u); break;
case 0x17: run_vu(unit, shadow(unit) ? 0u : vu::tpc(unit)); break;
case 0x20: u.mask = data[0]; break;
case 0x30: std::memcpy(u.row, data, 16); break;
case 0x31: std::memcpy(u.col, data, 16); break;
case 0x4A: {
if (shadow(unit)) break;
std::uint8_t *code = unit ? g_vu1_code : g_vu0_code;
const std::uint32_t size = unit ? 16384u : 4096u;
const std::uint32_t count = num ? num : 256u;
bool changed = false;
for (std::uint32_t i = 0; i < count; ++i) {
std::uint8_t *at = code + ((imm * 8u + i * 8u) & (size - 1));
if (std::memcmp(at, data + i * 2, 8) == 0) continue;
std::memcpy(at, data + i * 2, 8);
changed = true;
}
if (changed) vu::code_changed(unit);
break;
}
case 0x50: case 0x51:
if (shadow(unit)) gif::scan_signals(2, reinterpret_cast<const std::uint8_t *>(data), imm ? imm : 0x10000u);
else gif::transfer(2, reinterpret_cast<const std::uint8_t *>(data), imm ? imm : 0x10000u);
break;
default:
if ((op & 0x60u) == 0x60u) unpack(unit, cmd, data);
else std::fprintf(stderr, "[vif%d] unknown command 0x%08X\n", unit, cmd);
break;
}
if ((cmd & 0x80000000u) && !(u.err & 1u)) {
u.stat |= 0xC00u;
u.stalled = true;
if (!on_vu_thread()) hw::intc_raise(4u + static_cast<unsigned>(unit));
}
}
std::size_t run(int unit, const std::uint32_t *words, std::size_t count) {
Unit &u = state(unit);
std::size_t pos = 0;
while (pos < count && !u.stalled) {
const std::uint32_t cmd = words[pos];
const std::size_t start = pos + 1;
const std::uint32_t need = data_words(unit, cmd);
if (start + need > count) break;
execute(unit, cmd, words + start);
pos = start + need;
}
return pos;
}
void process(int unit) {
Unit &u = state(unit);
const std::size_t pos = run(unit, u.pending.data(), u.pending.size());
u.pending.erase(u.pending.begin(), u.pending.begin() + static_cast<std::ptrdiff_t>(pos));
}
}
void reset() {
for (Unit &u : g_units) u = Unit{};
}
void reset_vu_side() { g_vu_side = Unit{}; }
void stats() {
for (int u = 0; u < 2; ++u) {
std::fprintf(stderr, "[vif%d]", u);
for (int op = 0; op < 128; ++op)
if (g_commands[u][op]) std::fprintf(stderr, " %02X:%llu", op, static_cast<unsigned long long>(g_commands[u][op]));
std::fprintf(stderr, "\n");
}
}
void transfer(int unit, const std::uint8_t *data, std::uint32_t qwc) {
if (shadow(unit)) gs::queue::vu().post(gs::queue::kVif1, qwc, 0, data, qwc * 16);
Unit &u = state(unit);
if (u.pending.empty() && !u.stalled) {
const auto *words = reinterpret_cast<const std::uint32_t *>(data);
const std::size_t count = static_cast<std::size_t>(qwc) * 4;
const std::size_t pos = run(unit, words, count);
if (pos < count) u.pending.assign(words + pos, words + count);
return;
}
const std::size_t old = u.pending.size();
u.pending.resize(old + static_cast<std::size_t>(qwc) * 4);
std::memcpy(u.pending.data() + old, data, static_cast<std::size_t>(qwc) * 16);
process(unit);
}
bool stalled(int unit) { return state(unit).stalled; }
std::uint32_t read(int unit, std::uint32_t reg) {
const Unit &u = state(unit);
switch (reg) {
case 0x00: {
std::uint32_t stat = u.stat | (u.dbf ? 0x80u : 0u);
// With FDR set the FIFO runs from the GS, and a download keeps it as full as the
// game drains it: sceGsExecStoreImage polls FQC before each qword it reads.
if (unit == 1 && (u.stat & 0x800000u)) stat |= 16u << 24;
return stat;
}
case 0x20: return u.err;
case 0x30: return u.mark;
case 0x40: return u.cycle;
case 0x50: return u.mode;
case 0x60: return u.num;
case 0x70: return u.mask;
case 0x80: return u.code;
case 0x90: return u.itops;
case 0xA0: return u.base;
case 0xB0: return u.ofst;
case 0xC0: return u.tops;
case 0xD0: return u.itop;
case 0xE0: return u.top;
default:
if (reg >= 0x100 && reg < 0x140) return u.row[(reg - 0x100) >> 4];
if (reg >= 0x140 && reg < 0x180) return u.col[(reg - 0x140) >> 4];
return 0;
}
}
void write(int unit, std::uint32_t reg, std::uint32_t value) {
if (shadow(unit)) gs::queue::vu().post(gs::queue::kVif1Write, reg, value, nullptr, 0);
Unit &u = state(unit);
switch (reg) {
case 0x00:
if (unit == 1) u.stat = (u.stat & ~0x800000u) | (value & 0x800000u);
break;
case 0x10:
if (value & 1u) {
// A reset leaves the filling registers alone, as in PCSX2: Downhill
// Domination sets ROW once and resets the VIF before every frame.
Unit fresh{};
std::memcpy(fresh.row, u.row, sizeof fresh.row);
std::memcpy(fresh.col, u.col, sizeof fresh.col);
u = fresh;
}
if (value & 8u) {
u.stat &= ~0x3F00u;
if (u.stalled) {
u.stalled = false;
process(unit);
if (!u.stalled && !on_vu_thread()) dmac::resume(unit);
}
}
break;
case 0x20: u.err = value; break;
case 0x30: u.mark = value; break;
default:
if (reg >= 0x100 && reg < 0x140) u.row[(reg - 0x100) >> 4] = value;
else if (reg >= 0x140 && reg < 0x180) u.col[(reg - 0x140) >> 4] = value;
break;
}
}
}
namespace ps2::vif {
void state(ps2::state::Stream &s) {
s.tag("vif");
for (Unit *u : {&g_units[0], &g_units[1], &g_vu_side}) {
s.pod(u->stat);
s.pod(u->err);
s.pod(u->mark);
s.pod(u->cycle);
s.pod(u->mode);
s.pod(u->num);
s.pod(u->mask);
s.pod(u->code);
s.pod(u->itops);
s.pod(u->base);
s.pod(u->ofst);
s.pod(u->tops);
s.pod(u->itop);
s.pod(u->top);
s.pod(u->row);
s.pod(u->col);
s.pod(u->dbf);
s.pod(u->stalled);
s.vec(u->pending);
}
}
}