Feature/runtime ecosystem refactor (#107)

* feat: remove memory and pad from stub section

* feat: add support for resume entry targets in CodeGenerator (this allow jumps in address outside function)
feat: refactor entry point discovery one more try to reduce big generated file

* feat: optmizations for release build

* feat: remove unused  file

* feat: added some test cases for code gen

* feat: added log macro and remove win specific code

* feat: refactor runtime folder structure
feat: added reset sound driver RPC state and compatibility layout
feat: rename and added new test
feat: update RPC calls to use defined constants
feat: added more PSMC(16, 32)
feat: change cd read to try find the asset ignoring case sensitive
fix: fix some render problems
feat: add logs on pad
feat: added more RPC handles

* feat: added game override for code veronica

* feat: apply vita patch

* feat: flags to disable build

* feat: fix merges
feat: break a lot of tests

* feat: better throw error on empty cd path
feat: remove recompiler unusde function
feat: apply missing patch

* feat: gamedp is now part of lib
feat: missing file

* feat: small cleanup

* feat: missing vita changes

* feat: fix more merge

* feat: fix tests

* feat: last missing feature

* feat: added missing import

* feat: rename test local functions

* feat: init syscall on ps2 list

* feat: added DMA helpers

* feat: faster builds
feat: more implement for darkcloud

* feat: back missing file

* feat: added missing includes

* feat: remove test

* feat: missing include

* feat: read register funtion

* feat: build  fix

* feat: force  exit on detach thread
This commit is contained in:
Ranieri
2026-04-04 23:09:56 -03:00
committed by GitHub
parent 553a9027d8
commit 93e221feaa
137 changed files with 26594 additions and 15314 deletions
+188 -14
View File
@@ -1,10 +1,13 @@
#include "MiniTest.h"
#include "ps2_stubs.h"
#include "ps2_syscalls.h"
#include "Stubs/Pad.h"
#include <vector>
#include <cstdint>
#include <string>
namespace
{
constexpr uint32_t kPadDataAddr = 0x1000;
@@ -31,8 +34,25 @@ namespace
ctx.r[reg] = _mm_set_epi64x(0, static_cast<int64_t>(value));
}
void openPadPort(R5900Context &ctx, std::vector<uint8_t> &rdram, uint32_t port = 0, uint32_t slot = 0)
{
setRegU32(ctx, 4, port);
setRegU32(ctx, 5, slot);
setRegU32(ctx, 6, kPadDataAddr + 0x200u);
ps2_stubs::scePadPortOpen(rdram.data(), &ctx, nullptr);
}
void closePadPort(R5900Context &ctx, std::vector<uint8_t> &rdram, uint32_t port = 0, uint32_t slot = 0)
{
setRegU32(ctx, 4, port);
setRegU32(ctx, 5, slot);
ps2_stubs::scePadPortClose(rdram.data(), &ctx, nullptr);
}
void runPadRead(R5900Context &ctx, std::vector<uint8_t> &rdram)
{
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, kPadDataAddr); // a2
ps2_stubs::scePadRead(rdram.data(), &ctx, nullptr);
}
@@ -53,6 +73,9 @@ void register_pad_input_tests()
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
openPadPort(ctx, rdram);
const uint16_t buttons = static_cast<uint16_t>(0xFFFFu & ~kPadBtnCross & ~kPadBtnStart);
ps2_stubs::setPadOverrideState(buttons, 0x00, 0xFF, 0x10, 0xEE);
@@ -67,6 +90,7 @@ void register_pad_input_tests()
t.Equals(data[7], static_cast<uint8_t>(0xFF), "ly should match override");
ps2_stubs::clearPadOverrideState();
closePadPort(ctx, rdram);
});
tc.Run("scePadRead button bits are active-low", [](TestCase &t)
@@ -74,6 +98,9 @@ void register_pad_input_tests()
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
openPadPort(ctx, rdram);
struct ButtonCase
{
uint16_t mask;
@@ -104,11 +131,13 @@ void register_pad_input_tests()
ps2_stubs::setPadOverrideState(buttons, 0x80, 0x80, 0x80, 0x80);
runPadRead(ctx, rdram);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadRead should succeed for opened ports");
const uint16_t mask = readButtons(rdram);
t.IsTrue((mask & entry.mask) == 0, std::string("button should be active-low: ").append(entry.name));
}
ps2_stubs::clearPadOverrideState();
closePadPort(ctx, rdram);
});
tc.Run("scePadGetButtonMask returns all buttons", [](TestCase &t)
@@ -120,34 +149,50 @@ void register_pad_input_tests()
tc.Run("basic pad init/port/state functions return expected values", [](TestCase &t)
{
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(nullptr, &ctx, nullptr);
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadInit should succeed");
ps2_stubs::scePadInit2(nullptr, &ctx, nullptr);
ps2_stubs::scePadInit2(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadInit2 should succeed");
ps2_stubs::scePadPortOpen(nullptr, &ctx, nullptr);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadGetState(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "closed port should report DISCONNECTED");
openPadPort(ctx, rdram);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadPortOpen should succeed");
ps2_stubs::scePadPortClose(nullptr, &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadPortClose should succeed");
ps2_stubs::scePadGetState(nullptr, &ctx, nullptr);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadGetState(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(6), "scePadGetState should return STABLE");
ps2_stubs::scePadGetReqState(nullptr, &ctx, nullptr);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadGetReqState(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "scePadGetReqState should return completed");
ps2_stubs::scePadGetPortMax(nullptr, &ctx, nullptr);
ps2_stubs::scePadGetPortMax(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(2), "scePadGetPortMax should be 2");
ps2_stubs::scePadGetSlotMax(nullptr, &ctx, nullptr);
setRegU32(ctx, 4, 0u);
ps2_stubs::scePadGetSlotMax(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadGetSlotMax should be 1");
ps2_stubs::scePadGetModVersion(nullptr, &ctx, nullptr);
ps2_stubs::scePadGetModVersion(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0x0200), "scePadGetModVersion should be 0x0200");
closePadPort(ctx, rdram);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadPortClose should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadGetState(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "closed port should return DISCONNECTED after close");
});
tc.Run("pad info and mode helpers return consistent values", [](TestCase &t)
@@ -155,24 +200,64 @@ void register_pad_input_tests()
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
openPadPort(ctx, rdram);
setRegU32(ctx, 6, static_cast<uint32_t>(-1));
ps2_stubs::scePadInfoAct(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "scePadInfoAct should return 0");
t.IsTrue(static_cast<uint32_t>(getRegU32(&ctx, 2)) >= 1u, "scePadInfoAct should report at least one actuator descriptor");
ps2_stubs::scePadInfoComb(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "scePadInfoComb should return 0");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 1);
setRegU32(ctx, 7, 0);
ps2_stubs::scePadInfoMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(7), "scePadInfoMode CURID should return DualShock");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 4);
setRegU32(ctx, 7, static_cast<uint32_t>(-1));
ps2_stubs::scePadInfoMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadInfoMode table count should be 1");
t.IsTrue(static_cast<uint32_t>(getRegU32(&ctx, 2)) >= 1u, "scePadInfoMode table count should be non-zero");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadInfoPressMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "scePadInfoPressMode should be 0");
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadInfoPressMode should report pressure support");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 0u);
setRegU32(ctx, 7, 3u);
ps2_stubs::scePadSetMainMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetMainMode should accept digital mode");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 1u);
setRegU32(ctx, 7, 0u);
ps2_stubs::scePadInfoMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(4), "CURID should switch to digital mode");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 1u);
setRegU32(ctx, 7, 3u);
ps2_stubs::scePadSetMainMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetMainMode should accept analog mode");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 4);
setRegU32(ctx, 7, 0u);
ps2_stubs::scePadInfoMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(7), "mode table entry should return DualShock in analog mode");
closePadPort(ctx, rdram);
});
tc.Run("pad setters return success", [](TestCase &t)
@@ -180,35 +265,124 @@ void register_pad_input_tests()
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
openPadPort(ctx, rdram);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadSetActAlign(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetActAlign should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadSetActDirect(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetActDirect should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 0xFFFFu);
ps2_stubs::scePadSetButtonInfo(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetButtonInfo should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 1u);
setRegU32(ctx, 7, 3u);
ps2_stubs::scePadSetMainMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetMainMode should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadSetReqState(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetReqState should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadSetVrefParam(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetVrefParam should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadSetWarningLevel(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(0), "scePadSetWarningLevel should return 0");
ps2_stubs::scePadEnd(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadEnd should succeed");
openPadPort(ctx, rdram);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadEnterPressMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadEnterPressMode should succeed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadExitPressMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadExitPressMode should succeed");
closePadPort(ctx, rdram);
});
tc.Run("scePadRead fills pressure bytes and honors button info mask", [](TestCase &t)
{
std::vector<uint8_t> rdram(PS2_RAM_SIZE, 0);
R5900Context ctx;
ps2_stubs::scePadInit(rdram.data(), &ctx, nullptr);
openPadPort(ctx, rdram);
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, 0xFFFFu);
ps2_stubs::scePadSetButtonInfo(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetButtonInfo should accept all buttons");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
ps2_stubs::scePadEnterPressMode(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadEnterPressMode should enable pressure data");
const uint16_t pressedButtons = static_cast<uint16_t>(0xFFFFu &
~kPadBtnLeft &
~kPadBtnUp &
~kPadBtnTriangle &
~kPadBtnCross &
~kPadBtnL1 &
~kPadBtnR2);
ps2_stubs::setPadOverrideState(pressedButtons, 0x80, 0x80, 0x80, 0x80);
runPadRead(ctx, rdram);
const uint8_t *data = rdram.data() + kPadDataAddr;
t.Equals(data[8], static_cast<uint8_t>(0x00), "right pressure should be clear when not pressed");
t.Equals(data[9], static_cast<uint8_t>(0xFF), "left pressure should be populated when pressed");
t.Equals(data[10], static_cast<uint8_t>(0xFF), "up pressure should be populated when pressed");
t.Equals(data[11], static_cast<uint8_t>(0x00), "down pressure should be clear when not pressed");
t.Equals(data[12], static_cast<uint8_t>(0xFF), "triangle pressure should be populated when pressed");
t.Equals(data[13], static_cast<uint8_t>(0x00), "circle pressure should be clear when not pressed");
t.Equals(data[14], static_cast<uint8_t>(0xFF), "cross pressure should be populated when pressed");
t.Equals(data[15], static_cast<uint8_t>(0x00), "square pressure should be clear when not pressed");
t.Equals(data[16], static_cast<uint8_t>(0xFF), "L1 pressure should be populated when pressed");
t.Equals(data[17], static_cast<uint8_t>(0x00), "L2 pressure should be clear when not pressed");
t.Equals(data[18], static_cast<uint8_t>(0x00), "R1 pressure should be clear when not pressed");
t.Equals(data[19], static_cast<uint8_t>(0xFF), "R2 pressure should be populated when pressed");
setRegU32(ctx, 4, 0u);
setRegU32(ctx, 5, 0u);
setRegU32(ctx, 6, static_cast<uint32_t>(kPadBtnL1 | kPadBtnR2));
ps2_stubs::scePadSetButtonInfo(rdram.data(), &ctx, nullptr);
t.Equals(static_cast<uint32_t>(getRegU32(&ctx, 2)), static_cast<uint32_t>(1), "scePadSetButtonInfo should narrow the enabled pressure mask");
runPadRead(ctx, rdram);
t.Equals(data[9], static_cast<uint8_t>(0x00), "masked-out direction pressure should clear");
t.Equals(data[10], static_cast<uint8_t>(0x00), "masked-out direction pressure should clear");
t.Equals(data[12], static_cast<uint8_t>(0x00), "masked-out face-button pressure should clear");
t.Equals(data[14], static_cast<uint8_t>(0x00), "masked-out face-button pressure should clear");
t.Equals(data[16], static_cast<uint8_t>(0xFF), "enabled L1 pressure should remain populated");
t.Equals(data[19], static_cast<uint8_t>(0xFF), "enabled R2 pressure should remain populated");
ps2_stubs::clearPadOverrideState();
closePadPort(ctx, rdram);
});
tc.Run("pad string helpers map state codes", [](TestCase &t)