Emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-04-02 11:01:50 -04:00
Code Issues Projects Releases Packages Wiki Activity

Rename some module-related functions to include HLE where appropriate

Browse source
This commit is contained in:
Henrik Rydgård 2025-03-31 11:17:50 +02:00
parent b516682df7
commit 4e25f44eef
70 changed files with 151 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
Core/HLE/HLE.cpp
View file

@ -179,21 +179,21 @@ void HLEShutdown() {
mipsCallActions.clear(); mipsCallActions.clear();
} }
int GetNumRegisteredModules() { int GetNumRegisteredHLEModules() {
return (int)moduleDB.size(); return (int)moduleDB.size();
} }
void RegisterModule(std::string_view name, int numFunctions, const HLEFunction *funcTable) { void RegisterHLEModule(std::string_view name, int numFunctions, const HLEFunction *funcTable) {
HLEModule module = {name, numFunctions, funcTable}; HLEModule module = {name, numFunctions, funcTable};
moduleDB.push_back(module); moduleDB.push_back(module);
} }
const HLEModule *GetModuleByIndex(int index) { const HLEModule *GetHLEModuleByIndex(int index) {
return &moduleDB[index]; return &moduleDB[index];
} }
// TODO: Do something faster. // TODO: Do something faster.
const HLEModule *GetModuleByName(std::string_view name) { const HLEModule *GetHLEModuleByName(std::string_view name) {
for (auto &module : moduleDB) { for (auto &module : moduleDB) {
if (name == module.name) { if (name == module.name) {
return &module; return &module;
@ -203,7 +203,7 @@ const HLEModule *GetModuleByName(std::string_view name) {
} }
// TODO: Do something faster. // TODO: Do something faster.
const HLEFunction *GetFuncByName(const HLEModule *module, std::string_view name) { const HLEFunction *GetHLEFuncByName(const HLEModule *module, std::string_view name) {
for (int i = 0; i < module->numFunctions; i++) { for (int i = 0; i < module->numFunctions; i++) {
auto &func = module->funcTable[i]; auto &func = module->funcTable[i];
if (func.name == name) { if (func.name == name) {
@ -213,14 +213,14 @@ const HLEFunction *GetFuncByName(const HLEModule *module, std::string_view name)
return nullptr; return nullptr;
} }
int GetModuleIndex(std::string_view moduleName) { int GetHLEModuleIndex(std::string_view moduleName) {
for (size_t i = 0; i < moduleDB.size(); i++) for (size_t i = 0; i < moduleDB.size(); i++)
if (moduleDB[i].name == moduleName) if (moduleDB[i].name == moduleName)
return (int)i; return (int)i;
return -1; return -1;
} }
int GetFuncIndex(int moduleIndex, u32 nib) { int GetHLEFuncIndexByNib(int moduleIndex, u32 nib) {
const HLEModule &module = moduleDB[moduleIndex]; const HLEModule &module = moduleDB[moduleIndex];
for (int i = 0; i < module.numFunctions; i++) { for (int i = 0; i < module.numFunctions; i++) {
if (module.funcTable[i].ID == nib) if (module.funcTable[i].ID == nib)
@ -230,7 +230,7 @@ int GetFuncIndex(int moduleIndex, u32 nib) {
} }
u32 GetNibByName(std::string_view moduleName, std::string_view function) { u32 GetNibByName(std::string_view moduleName, std::string_view function) {
int moduleIndex = GetModuleIndex(moduleName); int moduleIndex = GetHLEModuleIndex(moduleName);
if (moduleIndex == -1) if (moduleIndex == -1)
return -1; return -1;
@ -242,20 +242,21 @@ u32 GetNibByName(std::string_view moduleName, std::string_view function) {
return -1; return -1;
} }
const HLEFunction *GetFunc(std::string_view moduleName, u32 nib) { const HLEFunction *GetHLEFunc(std::string_view moduleName, u32 nib) {
int moduleIndex = GetModuleIndex(moduleName); int moduleIndex = GetHLEModuleIndex(moduleName);
if (moduleIndex != -1) { if (moduleIndex != -1) {
int idx = GetFuncIndex(moduleIndex, nib); int idx = GetHLEFuncIndexByNib(moduleIndex, nib);
if (idx != -1) if (idx != -1)
return &(moduleDB[moduleIndex].funcTable[idx]); return &(moduleDB[moduleIndex].funcTable[idx]);
} }
return 0; return 0;
} }
const char *GetFuncName(std::string_view moduleName, u32 nib) { // WARNING: Not thread-safe!
const char *GetHLEFuncName(std::string_view moduleName, u32 nib) {
_dbg_assert_msg_(!moduleName.empty(), "Invalid module name."); _dbg_assert_msg_(!moduleName.empty(), "Invalid module name.");
const HLEFunction *func = GetFunc(moduleName, nib); const HLEFunction *func = GetHLEFunc(moduleName, nib);
if (func) if (func)
return func->name; return func->name;
@ -264,15 +265,25 @@ const char *GetFuncName(std::string_view moduleName, u32 nib) {
return temp; return temp;
} }
const char *GetHLEFuncName(int moduleIndex, int func) {
if (moduleIndex >= 0 && moduleIndex < (int)moduleDB.size()) {
const HLEModule &module = moduleDB[moduleIndex];
if (func >= 0 && func < module.numFunctions) {
return module.funcTable[func].name;
}
}
return "[unknown]";
}
u32 GetSyscallOp(std::string_view moduleName, u32 nib) { u32 GetSyscallOp(std::string_view moduleName, u32 nib) {
// Special case to hook up bad imports. // Special case to hook up bad imports.
if (moduleName.empty()) { if (moduleName.empty()) {
return (0x03FFFFCC); // invalid syscall return (0x03FFFFCC); // invalid syscall
} }
int modindex = GetModuleIndex(moduleName); int modindex = GetHLEModuleIndex(moduleName);
if (modindex != -1) { if (modindex != -1) {
int funcindex = GetFuncIndex(modindex, nib); int funcindex = GetHLEFuncIndexByNib(modindex, nib);
if (funcindex != -1) { if (funcindex != -1) {
return (0x0000000c | (modindex<<18) | (funcindex<<6)); return (0x0000000c | (modindex<<18) | (funcindex<<6));
} else { } else {
@ -287,7 +298,7 @@ u32 GetSyscallOp(std::string_view moduleName, u32 nib) {
bool FuncImportIsSyscall(std::string_view module, u32 nib) bool FuncImportIsSyscall(std::string_view module, u32 nib)
{ {
return GetFunc(module, nib) != nullptr; return GetHLEFunc(module, nib) != nullptr;
} }
void WriteFuncStub(u32 stubAddr, u32 symAddr) void WriteFuncStub(u32 stubAddr, u32 symAddr)
@ -315,7 +326,7 @@ bool WriteSyscall(std::string_view moduleName, u32 nib, u32 address)
Memory::Write_U32(MIPS_MAKE_NOP(), address+4); //patched out? Memory::Write_U32(MIPS_MAKE_NOP(), address+4); //patched out?
return true; return true;
} }
int modindex = GetModuleIndex(moduleName); int modindex = GetHLEModuleIndex(moduleName);
if (modindex != -1) if (modindex != -1)
{ {
Memory::Write_U32(MIPS_MAKE_JR_RA(), address); // jr ra Memory::Write_U32(MIPS_MAKE_JR_RA(), address); // jr ra
@ -329,19 +340,6 @@ bool WriteSyscall(std::string_view moduleName, u32 nib, u32 address)
} }
} }
const char *GetFuncName(int moduleIndex, int func)
{
if (moduleIndex >= 0 && moduleIndex < (int)moduleDB.size())
{
const HLEModule &module = moduleDB[moduleIndex];
if (func >= 0 && func < module.numFunctions)
{
return module.funcTable[func].name;
}
}
return "[unknown]";
}
void hleCheckCurrentCallbacks() void hleCheckCurrentCallbacks()
{ {
hleAfterSyscall |= HLE_AFTER_CURRENT_CALLBACKS; hleAfterSyscall |= HLE_AFTER_CURRENT_CALLBACKS;
@ -858,12 +856,12 @@ void CallSyscall(MIPSOpcode op) {
} }
void hlePushFuncDesc(std::string_view module, std::string_view funcName) { void hlePushFuncDesc(std::string_view module, std::string_view funcName) {
const HLEModule *mod = GetModuleByName(module); const HLEModule *mod = GetHLEModuleByName(module);
_dbg_assert_(mod != nullptr); _dbg_assert_(mod != nullptr);
if (!mod) { if (!mod) {
return; return;
} }
const HLEFunction *func = GetFuncByName(mod, funcName); const HLEFunction *func = GetHLEFuncByName(mod, funcName);
_dbg_assert_(func != nullptr); _dbg_assert_(func != nullptr);
// Push to the stack. Be careful (due to the nasty adhoc thread..) // Push to the stack. Be careful (due to the nasty adhoc thread..)
int stackSize = g_stackSize; int stackSize = g_stackSize;

18
Core/HLE/HLE.h
View file

@ -97,15 +97,16 @@ struct Syscall {
#define RETURN64(n) {u64 RETURN64_tmp = n; currentMIPS->r[MIPS_REG_V0] = RETURN64_tmp & 0xFFFFFFFF; currentMIPS->r[MIPS_REG_V1] = RETURN64_tmp >> 32;} #define RETURN64(n) {u64 RETURN64_tmp = n; currentMIPS->r[MIPS_REG_V0] = RETURN64_tmp & 0xFFFFFFFF; currentMIPS->r[MIPS_REG_V1] = RETURN64_tmp >> 32;}
#define RETURNF(fl) currentMIPS->f[0] = fl #define RETURNF(fl) currentMIPS->f[0] = fl
const char *GetFuncName(std::string_view module, u32 nib); const char *GetHLEFuncName(std::string_view module, u32 nib);
const char *GetFuncName(int module, int func); const char *GetHLEFuncName(int module, int func);
const HLEFunction *GetFunc(std::string_view module, u32 nib); const HLEFunction *GetHLEFunc(std::string_view module, u32 nib);
int GetFuncIndex(int moduleIndex, u32 nib); int GetHLEFuncIndexByNib(int moduleIndex, u32 nib);
int GetModuleIndex(std::string_view modulename); int GetHLEModuleIndex(std::string_view modulename);
u32 GetNibByName(std::string_view module, std::string_view function);
void RegisterModule(std::string_view name, int numFunctions, const HLEFunction *funcTable); void RegisterHLEModule(std::string_view name, int numFunctions, const HLEFunction *funcTable);
int GetNumRegisteredModules(); int GetNumRegisteredHLEModules();
const HLEModule *GetModuleByIndex(int index); const HLEModule *GetHLEModuleByIndex(int index);
// Run the current thread's callbacks after the syscall finishes. // Run the current thread's callbacks after the syscall finishes.
void hleCheckCurrentCallbacks(); void hleCheckCurrentCallbacks();
@ -158,7 +159,6 @@ inline s64 hleDelayResult(s64 result, const char *reason, int usec) {
void HLEInit(); void HLEInit();
void HLEDoState(PointerWrap &p); void HLEDoState(PointerWrap &p);
void HLEShutdown(); void HLEShutdown();
u32 GetNibByName(std::string_view module, std::string_view function);
u32 GetSyscallOp(std::string_view module, u32 nib); u32 GetSyscallOp(std::string_view module, u32 nib);
bool FuncImportIsSyscall(std::string_view module, u32 nib); bool FuncImportIsSyscall(std::string_view module, u32 nib);
bool WriteSyscall(std::string_view module, u32 nib, u32 address); bool WriteSyscall(std::string_view module, u32 nib, u32 address);

4
Core/HLE/HLETables.cpp
View file

@ -288,13 +288,13 @@ void RegisterAllModules() {
Register_sceHeap(); Register_sceHeap();
for (int i = 0; i < numModules; i++) { for (int i = 0; i < numModules; i++) {
RegisterModule(moduleList[i].name, moduleList[i].numFunctions, moduleList[i].funcTable); RegisterHLEModule(moduleList[i].name, moduleList[i].numFunctions, moduleList[i].funcTable);
} }
// IMPORTANT: New modules have to be added at the end, or they will break savestates. // IMPORTANT: New modules have to be added at the end, or they will break savestates.
Register_StdioForKernel(); Register_StdioForKernel();
RegisterModule("LoadCoreForKernel", ARRAY_SIZE(LoadCoreForKernel), LoadCoreForKernel); RegisterHLEModule("LoadCoreForKernel", ARRAY_SIZE(LoadCoreForKernel), LoadCoreForKernel);
Register_IoFileMgrForKernel(); Register_IoFileMgrForKernel();
Register_LoadExecForKernel(); Register_LoadExecForKernel();
Register_SysMemForKernel(); Register_SysMemForKernel();

2
Core/HLE/KUBridge.cpp
View file

@ -43,5 +43,5 @@ const HLEFunction KUBridge[] =
}; };
void Register_KUBridge() { void Register_KUBridge() {
RegisterModule("KUBridge", ARRAY_SIZE(KUBridge), KUBridge); RegisterHLEModule("KUBridge", ARRAY_SIZE(KUBridge), KUBridge);
} }

2
Core/HLE/sceAac.cpp
View file

@ -219,5 +219,5 @@ const HLEFunction sceAac[] = {
}; };
void Register_sceAac() { void Register_sceAac() {
RegisterModule("sceAac", ARRAY_SIZE(sceAac), sceAac); RegisterHLEModule("sceAac", ARRAY_SIZE(sceAac), sceAac);
} }

2
Core/HLE/sceAdler.cpp
View file

@ -44,5 +44,5 @@ const HLEFunction sceAdler[] = {
}; };
void Register_sceAdler() { void Register_sceAdler() {
RegisterModule("sceAdler", ARRAY_SIZE(sceAdler), sceAdler); RegisterHLEModule("sceAdler", ARRAY_SIZE(sceAdler), sceAdler);
} }

4
Core/HLE/sceAtrac.cpp
View file

@ -1200,6 +1200,6 @@ const HLEFunction sceAtrac3plus[] = {
void Register_sceAtrac3plus() { void Register_sceAtrac3plus() {
// Two names // Two names
RegisterModule("sceATRAC3plus_Library", ARRAY_SIZE(sceAtrac3plus), sceAtrac3plus); RegisterHLEModule("sceATRAC3plus_Library", ARRAY_SIZE(sceAtrac3plus), sceAtrac3plus);
RegisterModule("sceAtrac3plus", ARRAY_SIZE(sceAtrac3plus), sceAtrac3plus); RegisterHLEModule("sceAtrac3plus", ARRAY_SIZE(sceAtrac3plus), sceAtrac3plus);
} }

2
Core/HLE/sceAudio.cpp
View file

@ -549,5 +549,5 @@ const HLEFunction sceAudio[] =
void Register_sceAudio() void Register_sceAudio()
{ {
RegisterModule("sceAudio", ARRAY_SIZE(sceAudio), sceAudio); RegisterHLEModule("sceAudio", ARRAY_SIZE(sceAudio), sceAudio);
} }

2
Core/HLE/sceAudioRouting.cpp
View file

@ -61,5 +61,5 @@ const HLEFunction sceAudioRouting[] =
void Register_sceAudioRouting() void Register_sceAudioRouting()
{ {
RegisterModule("sceAudioRouting", ARRAY_SIZE(sceAudioRouting), sceAudioRouting); RegisterHLEModule("sceAudioRouting", ARRAY_SIZE(sceAudioRouting), sceAudioRouting);
} }

2
Core/HLE/sceAudiocodec.cpp
View file

@ -174,7 +174,7 @@ const HLEFunction sceAudiocodec[] = {
}; };
void Register_sceAudiocodec() { void Register_sceAudiocodec() {
RegisterModule("sceAudiocodec", ARRAY_SIZE(sceAudiocodec), sceAudiocodec); RegisterHLEModule("sceAudiocodec", ARRAY_SIZE(sceAudiocodec), sceAudiocodec);
} }
void __sceAudiocodecDoState(PointerWrap &p){ void __sceAudiocodecDoState(PointerWrap &p){

2
Core/HLE/sceCcc.cpp
View file

@ -567,5 +567,5 @@ const HLEFunction sceCcc[] =
void Register_sceCcc() void Register_sceCcc()
{ {
RegisterModule("sceCcc", ARRAY_SIZE(sceCcc), sceCcc); RegisterHLEModule("sceCcc", ARRAY_SIZE(sceCcc), sceCcc);
} }

2
Core/HLE/sceChnnlsv.cpp
View file

@ -525,6 +525,6 @@ const HLEFunction sceChnnlsv[] =
void Register_sceChnnlsv() void Register_sceChnnlsv()
{ {
RegisterModule("sceChnnlsv", ARRAY_SIZE(sceChnnlsv), sceChnnlsv); RegisterHLEModule("sceChnnlsv", ARRAY_SIZE(sceChnnlsv), sceChnnlsv);
kirk_init(); kirk_init();
} }

4
Core/HLE/sceCtrl.cpp
View file

@ -591,12 +591,12 @@ static const HLEFunction sceCtrl[] =
void Register_sceCtrl() void Register_sceCtrl()
{ {
RegisterModule("sceCtrl", ARRAY_SIZE(sceCtrl), sceCtrl); RegisterHLEModule("sceCtrl", ARRAY_SIZE(sceCtrl), sceCtrl);
} }
void Register_sceCtrl_driver() void Register_sceCtrl_driver()
{ {
RegisterModule("sceCtrl_driver", ARRAY_SIZE(sceCtrl), sceCtrl); RegisterHLEModule("sceCtrl_driver", ARRAY_SIZE(sceCtrl), sceCtrl);
} }
u16 sceCtrlGetRightVibration() { u16 sceCtrlGetRightVibration() {

2
Core/HLE/sceDeflt.cpp
View file

@ -96,5 +96,5 @@ const HLEFunction sceDeflt[] = {
}; };
void Register_sceDeflt() { void Register_sceDeflt() {
RegisterModule("sceDeflt", ARRAY_SIZE(sceDeflt), sceDeflt); RegisterHLEModule("sceDeflt", ARRAY_SIZE(sceDeflt), sceDeflt);
} }

4
Core/HLE/sceDisplay.cpp
View file

@ -1132,11 +1132,11 @@ const HLEFunction sceDisplay[] = {
}; };
void Register_sceDisplay() { void Register_sceDisplay() {
RegisterModule("sceDisplay", ARRAY_SIZE(sceDisplay), sceDisplay); RegisterHLEModule("sceDisplay", ARRAY_SIZE(sceDisplay), sceDisplay);
} }
void Register_sceDisplay_driver() { void Register_sceDisplay_driver() {
RegisterModule("sceDisplay_driver", ARRAY_SIZE(sceDisplay), sceDisplay); RegisterHLEModule("sceDisplay_driver", ARRAY_SIZE(sceDisplay), sceDisplay);
} }
static void __DisplaySetFramerate(void) { static void __DisplaySetFramerate(void) {

2
Core/HLE/sceDmac.cpp
View file

@ -121,5 +121,5 @@ const HLEFunction sceDmac[] = {
}; };
void Register_sceDmac() { void Register_sceDmac() {
RegisterModule("sceDmac", ARRAY_SIZE(sceDmac), sceDmac); RegisterHLEModule("sceDmac", ARRAY_SIZE(sceDmac), sceDmac);
} }

4
Core/HLE/sceFont.cpp
View file

@ -1669,9 +1669,9 @@ const HLEFunction sceLibFont[] = {
}; };
void Register_sceFont() { void Register_sceFont() {
RegisterModule("sceLibFont", ARRAY_SIZE(sceLibFont), sceLibFont); RegisterHLEModule("sceLibFont", ARRAY_SIZE(sceLibFont), sceLibFont);
} }
void Register_sceLibFttt() { void Register_sceLibFttt() {
RegisterModule("sceLibFttt", ARRAY_SIZE(sceLibFont), sceLibFont); RegisterHLEModule("sceLibFttt", ARRAY_SIZE(sceLibFont), sceLibFont);
} }

2
Core/HLE/sceG729.cpp
View file

@ -36,5 +36,5 @@ const HLEFunction sceG729[] =
void Register_sceG729() void Register_sceG729()
{ {
RegisterModule("sceG729", ARRAY_SIZE(sceG729), sceG729); RegisterHLEModule("sceG729", ARRAY_SIZE(sceG729), sceG729);
} }

2
Core/HLE/sceGameUpdate.cpp
View file

@ -53,5 +53,5 @@ const HLEFunction sceGameUpdate[] =
void Register_sceGameUpdate() void Register_sceGameUpdate()
{ {
RegisterModule("sceGameUpdate", ARRAY_SIZE(sceGameUpdate), sceGameUpdate); RegisterHLEModule("sceGameUpdate", ARRAY_SIZE(sceGameUpdate), sceGameUpdate);
} }

2
Core/HLE/sceGe.cpp
View file

@ -643,5 +643,5 @@ const HLEFunction sceGe_user[] = {
}; };
void Register_sceGe_user() { void Register_sceGe_user() {
RegisterModule("sceGe_user", ARRAY_SIZE(sceGe_user), sceGe_user); RegisterHLEModule("sceGe_user", ARRAY_SIZE(sceGe_user), sceGe_user);
} }

2
Core/HLE/sceHeap.cpp
View file

@ -250,5 +250,5 @@ static const HLEFunction sceHeap[] =
void Register_sceHeap() void Register_sceHeap()
{ {
RegisterModule("sceHeap", ARRAY_SIZE(sceHeap), sceHeap); RegisterHLEModule("sceHeap", ARRAY_SIZE(sceHeap), sceHeap);
} }

2
Core/HLE/sceHprm.cpp
View file

@ -72,5 +72,5 @@ const HLEFunction sceHprm[] =
void Register_sceHprm() void Register_sceHprm()
{ {
RegisterModule("sceHprm", ARRAY_SIZE(sceHprm), sceHprm); RegisterHLEModule("sceHprm", ARRAY_SIZE(sceHprm), sceHprm);
} }

2
Core/HLE/sceHttp.cpp
View file

@ -874,5 +874,5 @@ const HLEFunction sceHttp[] = {
void Register_sceHttp() void Register_sceHttp()
{ {
RegisterModule("sceHttp",ARRAY_SIZE(sceHttp),sceHttp); RegisterHLEModule("sceHttp",ARRAY_SIZE(sceHttp),sceHttp);
} }

2
Core/HLE/sceImpose.cpp
View file

@ -125,5 +125,5 @@ const HLEFunction sceImpose[] = {
}; };
void Register_sceImpose() { void Register_sceImpose() {
RegisterModule("sceImpose", ARRAY_SIZE(sceImpose), sceImpose); RegisterHLEModule("sceImpose", ARRAY_SIZE(sceImpose), sceImpose);
} }

8
Core/HLE/sceIo.cpp
View file

@ -3013,7 +3013,7 @@ const HLEFunction IoFileMgrForUser[] = {
}; };
void Register_IoFileMgrForUser() { void Register_IoFileMgrForUser() {
RegisterModule("IoFileMgrForUser", ARRAY_SIZE(IoFileMgrForUser), IoFileMgrForUser); RegisterHLEModule("IoFileMgrForUser", ARRAY_SIZE(IoFileMgrForUser), IoFileMgrForUser);
} }
const HLEFunction IoFileMgrForKernel[] = { const HLEFunction IoFileMgrForKernel[] = {
@ -3053,7 +3053,7 @@ const HLEFunction IoFileMgrForKernel[] = {
}; };
void Register_IoFileMgrForKernel() { void Register_IoFileMgrForKernel() {
RegisterModule("IoFileMgrForKernel", ARRAY_SIZE(IoFileMgrForKernel), IoFileMgrForKernel); RegisterHLEModule("IoFileMgrForKernel", ARRAY_SIZE(IoFileMgrForKernel), IoFileMgrForKernel);
} }
const HLEFunction StdioForUser[] = { const HLEFunction StdioForUser[] = {
@ -3071,7 +3071,7 @@ const HLEFunction StdioForUser[] = {
}; };
void Register_StdioForUser() { void Register_StdioForUser() {
RegisterModule("StdioForUser", ARRAY_SIZE(StdioForUser), StdioForUser); RegisterHLEModule("StdioForUser", ARRAY_SIZE(StdioForUser), StdioForUser);
} }
const HLEFunction StdioForKernel[] = { const HLEFunction StdioForKernel[] = {
@ -3086,5 +3086,5 @@ const HLEFunction StdioForKernel[] = {
}; };
void Register_StdioForKernel() { void Register_StdioForKernel() {
RegisterModule("StdioForKernel", ARRAY_SIZE(StdioForKernel), StdioForKernel); RegisterHLEModule("StdioForKernel", ARRAY_SIZE(StdioForKernel), StdioForKernel);
} }

2
Core/HLE/sceJpeg.cpp
View file

@ -655,5 +655,5 @@ const HLEFunction sceJpeg[] =
}; };
void Register_sceJpeg() { void Register_sceJpeg() {
RegisterModule("sceJpeg", ARRAY_SIZE(sceJpeg), sceJpeg); RegisterHLEModule("sceJpeg", ARRAY_SIZE(sceJpeg), sceJpeg);
} }

12
Core/HLE/sceKernel.cpp
View file

@ -946,7 +946,7 @@ const HLEFunction ThreadManForKernel[] =
void Register_ThreadManForUser() void Register_ThreadManForUser()
{ {
RegisterModule("ThreadManForUser", ARRAY_SIZE(ThreadManForUser), ThreadManForUser); RegisterHLEModule("ThreadManForUser", ARRAY_SIZE(ThreadManForUser), ThreadManForUser);
} }
@ -962,7 +962,7 @@ const HLEFunction LoadExecForUser[] =
void Register_LoadExecForUser() void Register_LoadExecForUser()
{ {
RegisterModule("LoadExecForUser", ARRAY_SIZE(LoadExecForUser), LoadExecForUser); RegisterHLEModule("LoadExecForUser", ARRAY_SIZE(LoadExecForUser), LoadExecForUser);
} }
const HLEFunction LoadExecForKernel[] = const HLEFunction LoadExecForKernel[] =
@ -975,7 +975,7 @@ const HLEFunction LoadExecForKernel[] =
void Register_LoadExecForKernel() void Register_LoadExecForKernel()
{ {
RegisterModule("LoadExecForKernel", ARRAY_SIZE(LoadExecForKernel), LoadExecForKernel); RegisterHLEModule("LoadExecForKernel", ARRAY_SIZE(LoadExecForKernel), LoadExecForKernel);
} }
const HLEFunction ExceptionManagerForKernel[] = const HLEFunction ExceptionManagerForKernel[] =
@ -992,7 +992,7 @@ const HLEFunction ExceptionManagerForKernel[] =
void Register_ExceptionManagerForKernel() void Register_ExceptionManagerForKernel()
{ {
RegisterModule("ExceptionManagerForKernel", ARRAY_SIZE(ExceptionManagerForKernel), ExceptionManagerForKernel); RegisterHLEModule("ExceptionManagerForKernel", ARRAY_SIZE(ExceptionManagerForKernel), ExceptionManagerForKernel);
} }
// Seen in some homebrew // Seen in some homebrew
@ -1021,12 +1021,12 @@ const HLEFunction UtilsForKernel[] = {
void Register_UtilsForKernel() void Register_UtilsForKernel()
{ {
RegisterModule("UtilsForKernel", ARRAY_SIZE(UtilsForKernel), UtilsForKernel); RegisterHLEModule("UtilsForKernel", ARRAY_SIZE(UtilsForKernel), UtilsForKernel);
} }
void Register_ThreadManForKernel() void Register_ThreadManForKernel()
{ {
RegisterModule("ThreadManForKernel", ARRAY_SIZE(ThreadManForKernel), ThreadManForKernel); RegisterHLEModule("ThreadManForKernel", ARRAY_SIZE(ThreadManForKernel), ThreadManForKernel);
} }
const char *KernelErrorToString(u32 err) { const char *KernelErrorToString(u32 err) {

2
Core/HLE/sceKernelHeap.cpp
View file

@ -174,5 +174,5 @@ const HLEFunction SysMemForKernel[] = {
}; };
void Register_SysMemForKernel() { void Register_SysMemForKernel() {
RegisterModule("SysMemForKernel", ARRAY_SIZE(SysMemForKernel), SysMemForKernel); RegisterHLEModule("SysMemForKernel", ARRAY_SIZE(SysMemForKernel), SysMemForKernel);
} }

8
Core/HLE/sceKernelInterrupt.cpp
View file

@ -1005,12 +1005,12 @@ const HLEFunction SysclibForKernel[] =
void Register_Kernel_Library() void Register_Kernel_Library()
{ {
RegisterModule("Kernel_Library", ARRAY_SIZE(Kernel_Library), Kernel_Library); RegisterHLEModule("Kernel_Library", ARRAY_SIZE(Kernel_Library), Kernel_Library);
} }
void Register_SysclibForKernel() void Register_SysclibForKernel()
{ {
RegisterModule("SysclibForKernel", ARRAY_SIZE(SysclibForKernel), SysclibForKernel); RegisterHLEModule("SysclibForKernel", ARRAY_SIZE(SysclibForKernel), SysclibForKernel);
} }
const HLEFunction InterruptManager[] = const HLEFunction InterruptManager[] =
@ -1029,7 +1029,7 @@ const HLEFunction InterruptManager[] =
void Register_InterruptManager() void Register_InterruptManager()
{ {
RegisterModule("InterruptManager", ARRAY_SIZE(InterruptManager), InterruptManager); RegisterHLEModule("InterruptManager", ARRAY_SIZE(InterruptManager), InterruptManager);
} }
@ -1057,5 +1057,5 @@ const HLEFunction InterruptManagerForKernel[] =
void Register_InterruptManagerForKernel() void Register_InterruptManagerForKernel()
{ {
RegisterModule("InterruptManagerForKernel", ARRAY_SIZE(InterruptManagerForKernel), InterruptManagerForKernel); RegisterHLEModule("InterruptManagerForKernel", ARRAY_SIZE(InterruptManagerForKernel), InterruptManagerForKernel);
} }

2
Core/HLE/sceKernelMemory.cpp
View file

@ -2118,5 +2118,5 @@ const HLEFunction SysMemUserForUser[] = {
}; };
void Register_SysMemUserForUser() { void Register_SysMemUserForUser() {
RegisterModule("SysMemUserForUser", ARRAY_SIZE(SysMemUserForUser), SysMemUserForUser); RegisterHLEModule("SysMemUserForUser", ARRAY_SIZE(SysMemUserForUser), SysMemUserForUser);
} }

20
Core/HLE/sceKernelModule.cpp
View file

@ -286,11 +286,11 @@ void PSPModule::ImportFunc(const FuncSymbolImport &func, bool reimporting) {
return; return;
} }
DEBUG_LOG(Log::Loader, "Importing %s : %08x", GetFuncName(func.moduleName, func.nid), func.stubAddr); DEBUG_LOG(Log::Loader, "Importing %s : %08x", GetHLEFuncName(func.moduleName, func.nid), func.stubAddr);
// Add the symbol to the symbol map for debugging. // Add the symbol to the symbol map for debugging.
char temp[256]; char temp[256];
snprintf(temp, sizeof(temp), "zz_%s", GetFuncName(func.moduleName, func.nid)); snprintf(temp, sizeof(temp), "zz_%s", GetHLEFuncName(func.moduleName, func.nid));
g_symbolMap->AddFunction(temp, func.stubAddr, 8); g_symbolMap->AddFunction(temp, func.stubAddr, 8);
// Keep track and actually hook it up if possible. // Keep track and actually hook it up if possible.
@ -644,7 +644,7 @@ void ImportFuncSymbol(const FuncSymbolImport &func, bool reimporting, const char
// TODO: Or not? // TODO: Or not?
if (FuncImportIsSyscall(func.moduleName, func.nid)) { if (FuncImportIsSyscall(func.moduleName, func.nid)) {
if (reimporting && Memory::Read_Instruction(func.stubAddr + 4) != GetSyscallOp(func.moduleName, func.nid)) { if (reimporting && Memory::Read_Instruction(func.stubAddr + 4) != GetSyscallOp(func.moduleName, func.nid)) {
WARN_LOG(Log::Loader, "Reimporting updated syscall %s", GetFuncName(func.moduleName, func.nid)); WARN_LOG(Log::Loader, "Reimporting updated syscall %s", GetHLEFuncName(func.moduleName, func.nid));
} }
WriteSyscall(func.moduleName, func.nid, func.stubAddr); WriteSyscall(func.moduleName, func.nid, func.stubAddr);
currentMIPS->InvalidateICache(func.stubAddr, 8); currentMIPS->InvalidateICache(func.stubAddr, 8);
@ -677,15 +677,15 @@ void ImportFuncSymbol(const FuncSymbolImport &func, bool reimporting, const char
} }
} }
// It hasn't been exported yet, but hopefully it will later. // It hasn't been exported yet, but hopefully it will later. Check if we know about it through HLE.
bool isKnownModule = GetModuleIndex(func.moduleName) != -1; const bool isKnownHLEModule = GetHLEModuleIndex(func.moduleName) != -1;
if (isKnownModule) { if (isKnownHLEModule) {
// We used to report this, but I don't think it's very interesting anymore. // We used to report this, but I don't think it's very interesting anymore.
WARN_LOG(Log::Loader, "Unknown syscall from known module '%s': 0x%08x (import for '%s')", func.moduleName, func.nid, importingModule); WARN_LOG(Log::Loader, "Unknown syscall from known HLE module '%s': 0x%08x (import for '%s')", func.moduleName, func.nid, importingModule);
} else { } else {
INFO_LOG(Log::Loader, "Function (%s,%08x) unresolved in '%s', storing for later resolving", func.moduleName, func.nid, importingModule); INFO_LOG(Log::Loader, "Function (%s,%08x) unresolved in '%s', storing for later resolving", func.moduleName, func.nid, importingModule);
} }
if (isKnownModule || !reimporting) { if (isKnownHLEModule || !reimporting) {
WriteFuncMissingStub(func.stubAddr, func.nid); WriteFuncMissingStub(func.stubAddr, func.nid);
currentMIPS->InvalidateICache(func.stubAddr, 8); currentMIPS->InvalidateICache(func.stubAddr, 8);
} }
@ -2607,9 +2607,9 @@ const HLEFunction ModuleMgrForKernel[] = {
}; };
void Register_ModuleMgrForUser() { void Register_ModuleMgrForUser() {
RegisterModule("ModuleMgrForUser", ARRAY_SIZE(ModuleMgrForUser), ModuleMgrForUser); RegisterHLEModule("ModuleMgrForUser", ARRAY_SIZE(ModuleMgrForUser), ModuleMgrForUser);
} }
void Register_ModuleMgrForKernel() { void Register_ModuleMgrForKernel() {
RegisterModule("ModuleMgrForKernel", ARRAY_SIZE(ModuleMgrForKernel), ModuleMgrForKernel); RegisterHLEModule("ModuleMgrForKernel", ARRAY_SIZE(ModuleMgrForKernel), ModuleMgrForKernel);
} }

2
Core/HLE/sceKernelSemaphore.cpp
View file

@ -427,5 +427,5 @@ const HLEFunction semaphore[] = {
}; };
void Register_semaphore() { void Register_semaphore() {
RegisterModule("semaphore", ARRAY_SIZE(semaphore), semaphore); RegisterHLEModule("semaphore", ARRAY_SIZE(semaphore), semaphore);
} }

2
Core/HLE/sceMd5.cpp
View file

@ -185,5 +185,5 @@ const HLEFunction sceMd5[] = {
}; };
void Register_sceMd5() { void Register_sceMd5() {
RegisterModule("sceMd5", ARRAY_SIZE(sceMd5), sceMd5); RegisterHLEModule("sceMd5", ARRAY_SIZE(sceMd5), sceMd5);
} }

2
Core/HLE/sceMp3.cpp
View file

@ -782,5 +782,5 @@ const HLEFunction sceMp3[] = {
}; };
void Register_sceMp3() { void Register_sceMp3() {
RegisterModule("sceMp3", ARRAY_SIZE(sceMp3), sceMp3); RegisterHLEModule("sceMp3", ARRAY_SIZE(sceMp3), sceMp3);
} }

4
Core/HLE/sceMp4.cpp
View file

@ -185,9 +185,9 @@ const HLEFunction mp4msv[] = {
}; };
void Register_sceMp4() { void Register_sceMp4() {
RegisterModule("sceMp4", ARRAY_SIZE(sceMp4), sceMp4); RegisterHLEModule("sceMp4", ARRAY_SIZE(sceMp4), sceMp4);
} }
void Register_mp4msv() { void Register_mp4msv() {
RegisterModule("mp4msv", ARRAY_SIZE(mp4msv), mp4msv); RegisterHLEModule("mp4msv", ARRAY_SIZE(mp4msv), mp4msv);
} }

4
Core/HLE/sceMpeg.cpp
View file

@ -2318,7 +2318,7 @@ const HLEFunction sceMpeg[] =
void Register_sceMpeg() void Register_sceMpeg()
{ {
RegisterModule("sceMpeg", ARRAY_SIZE(sceMpeg), sceMpeg); RegisterHLEModule("sceMpeg", ARRAY_SIZE(sceMpeg), sceMpeg);
} }
// This function is currently only been used for PMP videos // This function is currently only been used for PMP videos
@ -2354,5 +2354,5 @@ const HLEFunction sceMpegbase[] =
void Register_sceMpegbase() void Register_sceMpegbase()
{ {
RegisterModule("sceMpegbase", ARRAY_SIZE(sceMpegbase), sceMpegbase); RegisterHLEModule("sceMpegbase", ARRAY_SIZE(sceMpegbase), sceMpegbase);
}; };

2
Core/HLE/sceMt19937.cpp
View file

@ -56,5 +56,5 @@ const HLEFunction sceMt19937[] =
void Register_sceMt19937() void Register_sceMt19937()
{ {
RegisterModule("sceMt19937", ARRAY_SIZE(sceMt19937), sceMt19937); RegisterHLEModule("sceMt19937", ARRAY_SIZE(sceMt19937), sceMt19937);
} }

10
Core/HLE/sceNet.cpp
View file

@ -1720,21 +1720,21 @@ const HLEFunction sceNetIfhandle[] = {
}; };
void Register_sceNet() { void Register_sceNet() {
RegisterModule("sceNet", ARRAY_SIZE(sceNet), sceNet); RegisterHLEModule("sceNet", ARRAY_SIZE(sceNet), sceNet);
} }
void Register_sceNetApctl() { void Register_sceNetApctl() {
RegisterModule("sceNetApctl", ARRAY_SIZE(sceNetApctl), sceNetApctl); RegisterHLEModule("sceNetApctl", ARRAY_SIZE(sceNetApctl), sceNetApctl);
} }
void Register_sceWlanDrv() { void Register_sceWlanDrv() {
RegisterModule("sceWlanDrv", ARRAY_SIZE(sceWlanDrv), sceWlanDrv); RegisterHLEModule("sceWlanDrv", ARRAY_SIZE(sceWlanDrv), sceWlanDrv);
} }
void Register_sceNetUpnp() { void Register_sceNetUpnp() {
RegisterModule("sceNetUpnp", ARRAY_SIZE(sceNetUpnp), sceNetUpnp); RegisterHLEModule("sceNetUpnp", ARRAY_SIZE(sceNetUpnp), sceNetUpnp);
} }
void Register_sceNetIfhandle() { void Register_sceNetIfhandle() {
RegisterModule("sceNetIfhandle", ARRAY_SIZE(sceNetIfhandle), sceNetIfhandle); RegisterHLEModule("sceNetIfhandle", ARRAY_SIZE(sceNetIfhandle), sceNetIfhandle);
} }

6
Core/HLE/sceNetAdhoc.cpp
View file

@ -5235,13 +5235,13 @@ const HLEFunction sceNetAdhocDiscover[] = {
}; };
void Register_sceNetAdhoc() { void Register_sceNetAdhoc() {
RegisterModule("sceNetAdhoc", ARRAY_SIZE(sceNetAdhoc), sceNetAdhoc); RegisterHLEModule("sceNetAdhoc", ARRAY_SIZE(sceNetAdhoc), sceNetAdhoc);
} }
void Register_sceNetAdhocDiscover() { void Register_sceNetAdhocDiscover() {
RegisterModule("sceNetAdhocDiscover", ARRAY_SIZE(sceNetAdhocDiscover), sceNetAdhocDiscover); RegisterHLEModule("sceNetAdhocDiscover", ARRAY_SIZE(sceNetAdhocDiscover), sceNetAdhocDiscover);
} }
void Register_sceNetAdhocctl() { void Register_sceNetAdhocctl() {
RegisterModule("sceNetAdhocctl", ARRAY_SIZE(sceNetAdhocctl), sceNetAdhocctl); RegisterHLEModule("sceNetAdhocctl", ARRAY_SIZE(sceNetAdhocctl), sceNetAdhocctl);
} }

2
Core/HLE/sceNetAdhocMatching.cpp
View file

@ -2677,7 +2677,7 @@ const HLEFunction sceNetAdhocMatching[] = {
void Register_sceNetAdhocMatching() { void Register_sceNetAdhocMatching() {
RegisterModule("sceNetAdhocMatching", ARRAY_SIZE(sceNetAdhocMatching), sceNetAdhocMatching); RegisterHLEModule("sceNetAdhocMatching", ARRAY_SIZE(sceNetAdhocMatching), sceNetAdhocMatching);
} }
void __NetAdhocMatchingInit() { void __NetAdhocMatchingInit() {

2
Core/HLE/sceNetInet.cpp
View file

@ -1205,5 +1205,5 @@ const HLEFunction sceNetInet[] = {
}; };
void Register_sceNetInet() { void Register_sceNetInet() {
RegisterModule("sceNetInet", std::size(sceNetInet), sceNetInet); RegisterHLEModule("sceNetInet", std::size(sceNetInet), sceNetInet);
} }

2
Core/HLE/sceNetResolver.cpp
View file

@ -294,5 +294,5 @@ const HLEFunction sceNetResolver[] = {
}; };
void Register_sceNetResolver() { void Register_sceNetResolver() {
RegisterModule("sceNetResolver", ARRAY_SIZE(sceNetResolver), sceNetResolver); RegisterHLEModule("sceNetResolver", ARRAY_SIZE(sceNetResolver), sceNetResolver);
} }

2
Core/HLE/sceNet_lib.cpp
View file

@ -133,5 +133,5 @@ const HLEFunction sceNet_lib[] = {
void Register_sceNet_lib() { void Register_sceNet_lib() {
RegisterModule("sceNet_lib", ARRAY_SIZE(sceNet_lib), sceNet_lib); RegisterHLEModule("sceNet_lib", ARRAY_SIZE(sceNet_lib), sceNet_lib);
} }

8
Core/HLE/sceNp.cpp
View file

@ -307,7 +307,7 @@ const HLEFunction sceNp[] = {
void Register_sceNp() void Register_sceNp()
{ {
RegisterModule("sceNp", ARRAY_SIZE(sceNp), sceNp); RegisterHLEModule("sceNp", ARRAY_SIZE(sceNp), sceNp);
} }
static int sceNpAuthTerm() static int sceNpAuthTerm()
@ -552,7 +552,7 @@ const HLEFunction sceNpAuth[] = {
void Register_sceNpAuth() void Register_sceNpAuth()
{ {
RegisterModule("sceNpAuth", ARRAY_SIZE(sceNpAuth), sceNpAuth); RegisterHLEModule("sceNpAuth", ARRAY_SIZE(sceNpAuth), sceNpAuth);
} }
static int sceNpServiceTerm() static int sceNpServiceTerm()
@ -637,7 +637,7 @@ const HLEFunction sceNpService[] = {
void Register_sceNpService() void Register_sceNpService()
{ {
RegisterModule("sceNpService", ARRAY_SIZE(sceNpService), sceNpService); RegisterHLEModule("sceNpService", ARRAY_SIZE(sceNpService), sceNpService);
} }
// TODO: Move NpCommerce2-related stuff to sceNpCommerce2.cpp? // TODO: Move NpCommerce2-related stuff to sceNpCommerce2.cpp?
@ -662,6 +662,6 @@ const HLEFunction sceNpCommerce2[] = {
void Register_sceNpCommerce2() void Register_sceNpCommerce2()
{ {
RegisterModule("sceNpCommerce2", ARRAY_SIZE(sceNpCommerce2), sceNpCommerce2); RegisterHLEModule("sceNpCommerce2", ARRAY_SIZE(sceNpCommerce2), sceNpCommerce2);
} }

2
Core/HLE/sceNp2.cpp
View file

@ -602,5 +602,5 @@ const HLEFunction sceNpMatching2[] = {
void Register_sceNpMatching2() void Register_sceNpMatching2()
{ {
RegisterModule("sceNpMatching2", ARRAY_SIZE(sceNpMatching2), sceNpMatching2); RegisterHLEModule("sceNpMatching2", ARRAY_SIZE(sceNpMatching2), sceNpMatching2);
} }

6
Core/HLE/sceOpenPSID.cpp
View file

@ -82,7 +82,7 @@ const HLEFunction sceOpenPSID[] = {
void Register_sceOpenPSID() void Register_sceOpenPSID()
{ {
RegisterModule("sceOpenPSID", ARRAY_SIZE(sceOpenPSID), sceOpenPSID); RegisterHLEModule("sceOpenPSID", ARRAY_SIZE(sceOpenPSID), sceOpenPSID);
} }
// According to https://playstationdev.wiki/pspprxlibraries/5.00/kd/openpsid.xml // According to https://playstationdev.wiki/pspprxlibraries/5.00/kd/openpsid.xml
@ -95,7 +95,7 @@ const HLEFunction sceOpenPSID_driver[] =
void Register_sceOpenPSID_driver() void Register_sceOpenPSID_driver()
{ {
RegisterModule("sceOpenPSID_driver", ARRAY_SIZE(sceOpenPSID_driver), sceOpenPSID_driver); RegisterHLEModule("sceOpenPSID_driver", ARRAY_SIZE(sceOpenPSID_driver), sceOpenPSID_driver);
} }
const HLEFunction sceDdrdb[] = const HLEFunction sceDdrdb[] =
{ {
@ -104,5 +104,5 @@ const HLEFunction sceDdrdb[] =
void Register_sceDdrdb() void Register_sceDdrdb()
{ {
RegisterModule("sceDdrdb", ARRAY_SIZE(sceDdrdb), sceDdrdb); RegisterHLEModule("sceDdrdb", ARRAY_SIZE(sceDdrdb), sceDdrdb);
} }

2
Core/HLE/sceP3da.cpp
View file

@ -73,5 +73,5 @@ const HLEFunction sceP3da[] =
void Register_sceP3da() void Register_sceP3da()
{ {
RegisterModule("sceP3da", ARRAY_SIZE(sceP3da), sceP3da); RegisterHLEModule("sceP3da", ARRAY_SIZE(sceP3da), sceP3da);
} }

2
Core/HLE/sceParseHttp.cpp
View file

@ -175,5 +175,5 @@ const HLEFunction sceParseHttp[] = {
}; };
void Register_sceParseHttp() { void Register_sceParseHttp() {
RegisterModule("sceParseHttp", ARRAY_SIZE(sceParseHttp), sceParseHttp); RegisterHLEModule("sceParseHttp", ARRAY_SIZE(sceParseHttp), sceParseHttp);
} }

2
Core/HLE/sceParseUri.cpp
View file

@ -163,5 +163,5 @@ const HLEFunction sceParseUri[] =
void Register_sceParseUri() void Register_sceParseUri()
{ {
RegisterModule("sceParseUri", ARRAY_SIZE(sceParseUri), sceParseUri); RegisterHLEModule("sceParseUri", ARRAY_SIZE(sceParseUri), sceParseUri);
} }

2
Core/HLE/scePauth.cpp
View file

@ -68,5 +68,5 @@ const HLEFunction scePauth[] = {
void Register_scePauth() void Register_scePauth()
{ {
RegisterModule("scePauth", ARRAY_SIZE(scePauth), scePauth); RegisterHLEModule("scePauth", ARRAY_SIZE(scePauth), scePauth);
} }

4
Core/HLE/scePower.cpp
View file

@ -630,9 +630,9 @@ const HLEFunction sceSuspendForUser[] = {
void Register_scePower() { void Register_scePower() {
RegisterModule("scePower",ARRAY_SIZE(scePower),scePower); RegisterHLEModule("scePower",ARRAY_SIZE(scePower),scePower);
} }
void Register_sceSuspendForUser() { void Register_sceSuspendForUser() {
RegisterModule("sceSuspendForUser", ARRAY_SIZE(sceSuspendForUser), sceSuspendForUser); RegisterHLEModule("sceSuspendForUser", ARRAY_SIZE(sceSuspendForUser), sceSuspendForUser);
} }

4
Core/HLE/scePsmf.cpp
View file

@ -2051,9 +2051,9 @@ const HLEFunction scePsmfPlayer[] =
}; };
void Register_scePsmf() { void Register_scePsmf() {
RegisterModule("scePsmf",ARRAY_SIZE(scePsmf),scePsmf); RegisterHLEModule("scePsmf",ARRAY_SIZE(scePsmf),scePsmf);
} }
void Register_scePsmfPlayer() { void Register_scePsmfPlayer() {
RegisterModule("scePsmfPlayer",ARRAY_SIZE(scePsmfPlayer),scePsmfPlayer); RegisterHLEModule("scePsmfPlayer",ARRAY_SIZE(scePsmfPlayer),scePsmfPlayer);
} }

4
Core/HLE/scePspNpDrm_user.cpp
View file

@ -53,7 +53,7 @@ const HLEFunction sceNpDrm[] = {
}; };
void Register_sceNpDrm() { void Register_sceNpDrm() {
RegisterModule("sceNpDrm", ARRAY_SIZE(sceNpDrm), sceNpDrm); RegisterHLEModule("sceNpDrm", ARRAY_SIZE(sceNpDrm), sceNpDrm);
RegisterModule("scePspNpDrm_user", ARRAY_SIZE(sceNpDrm), sceNpDrm); RegisterHLEModule("scePspNpDrm_user", ARRAY_SIZE(sceNpDrm), sceNpDrm);
} }

2
Core/HLE/sceRtc.cpp
View file

@ -1015,5 +1015,5 @@ const HLEFunction sceRtc[] =
void Register_sceRtc() void Register_sceRtc()
{ {
RegisterModule("sceRtc", ARRAY_SIZE(sceRtc), sceRtc); RegisterHLEModule("sceRtc", ARRAY_SIZE(sceRtc), sceRtc);
} }

2
Core/HLE/sceSas.cpp
View file

@ -764,6 +764,6 @@ const HLEFunction sceSasCore[] = {
void Register_sceSasCore() void Register_sceSasCore()
{ {
RegisterModule("sceSasCore", ARRAY_SIZE(sceSasCore), sceSasCore); RegisterHLEModule("sceSasCore", ARRAY_SIZE(sceSasCore), sceSasCore);
} }

2
Core/HLE/sceSfmt19937.cpp
View file

@ -119,5 +119,5 @@ const HLEFunction sceSfmt19937[] =
void Register_sceSfmt19937() void Register_sceSfmt19937()
{ {
RegisterModule("sceSfmt19937", ARRAY_SIZE(sceSfmt19937), sceSfmt19937); RegisterHLEModule("sceSfmt19937", ARRAY_SIZE(sceSfmt19937), sceSfmt19937);
} }

2
Core/HLE/sceSha256.cpp
View file

@ -45,5 +45,5 @@ const HLEFunction sceSha256[] =
void Register_sceSha256() void Register_sceSha256()
{ {
RegisterModule("sceSha256", ARRAY_SIZE(sceSha256), sceSha256); RegisterHLEModule("sceSha256", ARRAY_SIZE(sceSha256), sceSha256);
} }

2
Core/HLE/sceSircs.cpp
View file

@ -52,5 +52,5 @@ const HLEFunction sceSircs[] =
void Register_sceSircs() void Register_sceSircs()
{ {
RegisterModule("sceSircs", ARRAY_SIZE(sceSircs), sceSircs); RegisterHLEModule("sceSircs", ARRAY_SIZE(sceSircs), sceSircs);
} }

2
Core/HLE/sceSsl.cpp
View file

@ -122,5 +122,5 @@ const HLEFunction sceSsl[] =
void Register_sceSsl() void Register_sceSsl()
{ {
RegisterModule("sceSsl", ARRAY_SIZE(sceSsl), sceSsl); RegisterHLEModule("sceSsl", ARRAY_SIZE(sceSsl), sceSsl);
} }

2
Core/HLE/sceUmd.cpp
View file

@ -534,5 +534,5 @@ const HLEFunction sceUmdUser[] =
void Register_sceUmdUser() void Register_sceUmdUser()
{ {
RegisterModule("sceUmdUser", ARRAY_SIZE(sceUmdUser), sceUmdUser); RegisterHLEModule("sceUmdUser", ARRAY_SIZE(sceUmdUser), sceUmdUser);
} }

6
Core/HLE/sceUsb.cpp
View file

@ -241,7 +241,7 @@ const HLEFunction sceUsbstorBoot[] =
void Register_sceUsb() void Register_sceUsb()
{ {
RegisterModule("sceUsbstor", ARRAY_SIZE(sceUsbstor), sceUsbstor); RegisterHLEModule("sceUsbstor", ARRAY_SIZE(sceUsbstor), sceUsbstor);
RegisterModule("sceUsbstorBoot", ARRAY_SIZE(sceUsbstorBoot), sceUsbstorBoot); RegisterHLEModule("sceUsbstorBoot", ARRAY_SIZE(sceUsbstorBoot), sceUsbstorBoot);
RegisterModule("sceUsb", ARRAY_SIZE(sceUsb), sceUsb); RegisterHLEModule("sceUsb", ARRAY_SIZE(sceUsb), sceUsb);
} }

2
Core/HLE/sceUsbAcc.cpp
View file

@ -42,5 +42,5 @@ const HLEFunction sceUsbAcc[] =
void Register_sceUsbAcc() void Register_sceUsbAcc()
{ {
RegisterModule("sceUsbAcc", ARRAY_SIZE(sceUsbAcc), sceUsbAcc); RegisterHLEModule("sceUsbAcc", ARRAY_SIZE(sceUsbAcc), sceUsbAcc);
} }

2
Core/HLE/sceUsbCam.cpp
View file

@ -324,7 +324,7 @@ const HLEFunction sceUsbCam[] =
void Register_sceUsbCam() void Register_sceUsbCam()
{ {
RegisterModule("sceUsbCam", ARRAY_SIZE(sceUsbCam), sceUsbCam); RegisterHLEModule("sceUsbCam", ARRAY_SIZE(sceUsbCam), sceUsbCam);
} }
std::vector<std::string> Camera::getDeviceList() { std::vector<std::string> Camera::getDeviceList() {

2
Core/HLE/sceUsbGps.cpp
View file

@ -127,7 +127,7 @@ const HLEFunction sceUsbGps[] =
void Register_sceUsbGps() void Register_sceUsbGps()
{ {
RegisterModule("sceUsbGps", ARRAY_SIZE(sceUsbGps), sceUsbGps); RegisterHLEModule("sceUsbGps", ARRAY_SIZE(sceUsbGps), sceUsbGps);
} }
void GPS::init() { void GPS::init() {

2
Core/HLE/sceUsbMic.cpp
View file

@ -454,5 +454,5 @@ const HLEFunction sceUsbMic[] = {
}; };
void Register_sceUsbMic() { void Register_sceUsbMic() {
RegisterModule("sceUsbMic", ARRAY_SIZE(sceUsbMic), sceUsbMic); RegisterHLEModule("sceUsbMic", ARRAY_SIZE(sceUsbMic), sceUsbMic);
} }

2
Core/HLE/sceUtility.cpp
View file

@ -1476,5 +1476,5 @@ const HLEFunction sceUtility[] =
void Register_sceUtility() void Register_sceUtility()
{ {
RegisterModule("sceUtility", ARRAY_SIZE(sceUtility), sceUtility); RegisterHLEModule("sceUtility", ARRAY_SIZE(sceUtility), sceUtility);
} }

2
Core/HLE/sceVaudio.cpp
View file

@ -105,5 +105,5 @@ const HLEFunction sceVaudio[] = {
}; };
void Register_sceVaudio() { void Register_sceVaudio() {
RegisterModule("sceVaudio",ARRAY_SIZE(sceVaudio), sceVaudio ); RegisterHLEModule("sceVaudio",ARRAY_SIZE(sceVaudio), sceVaudio );
} }

2
Core/MIPS/MIPSDis.cpp
View file

@ -123,7 +123,7 @@ namespace MIPSDis
u32 callno = (op>>6) & 0xFFFFF; //20 bits u32 callno = (op>>6) & 0xFFFFF; //20 bits
int funcnum = callno & 0xFFF; int funcnum = callno & 0xFFF;
int modulenum = (callno & 0xFF000) >> 12; int modulenum = (callno & 0xFF000) >> 12;
snprintf(out, outSize, "syscall\t %s", GetFuncName(modulenum, funcnum)); snprintf(out, outSize, "syscall\t %s", GetHLEFuncName(modulenum, funcnum));
} }
void Dis_ToHiloTransfer(MIPSOpcode op, uint32_t pc, char *out, size_t outSize) { void Dis_ToHiloTransfer(MIPSOpcode op, uint32_t pc, char *out, size_t outSize) {

4
UI/ImDebugger/ImDebugger.cpp
View file

@ -1526,11 +1526,11 @@ void DrawHLEModules(ImConfig &config) {
return; return;
} }
const int moduleCount = GetNumRegisteredModules(); const int moduleCount = GetNumRegisteredHLEModules();
std::vector<const HLEModule *> modules; std::vector<const HLEModule *> modules;
modules.reserve(moduleCount); modules.reserve(moduleCount);
for (int i = 0; i < moduleCount; i++) { for (int i = 0; i < moduleCount; i++) {
modules.push_back(GetModuleByIndex(i)); modules.push_back(GetHLEModuleByIndex(i));
} }
std::sort(modules.begin(), modules.end(), [](const HLEModule* a, const HLEModule* b) { std::sort(modules.begin(), modules.end(), [](const HLEModule* a, const HLEModule* b) {

2
unittest/JitHarness.cpp
View file

@ -97,7 +97,7 @@ double ExecCPUTest(bool clearCache = true) {
static void SetupJitHarness() { static void SetupJitHarness() {
// We register a syscall so we have an easy way to finish the test. // We register a syscall so we have an easy way to finish the test.
RegisterModule("UnitTestFakeSyscalls", ARRAY_SIZE(UnitTestFakeSyscalls), UnitTestFakeSyscalls); RegisterHLEModule("UnitTestFakeSyscalls", ARRAY_SIZE(UnitTestFakeSyscalls), UnitTestFakeSyscalls);
// This is pretty much the bare minimum required to setup jit. // This is pretty much the bare minimum required to setup jit.
coreState = CORE_POWERUP; coreState = CORE_POWERUP;