diff --git a/Core/HLE/HLE.cpp b/Core/HLE/HLE.cpp index 229d5c5174..5cb298b5c0 100644 --- a/Core/HLE/HLE.cpp +++ b/Core/HLE/HLE.cpp @@ -572,6 +572,8 @@ size_t hleFormatLogArgs(char *message, size_t sz, const char *argmask) { } \ } while (false) + // TODO: Floats, 64-bit params (with every-other), and > 8 args (stack.) + for (size_t i = 0, n = strlen(argmask); i < n; ++i) { switch (argmask[i]) { case 'p': @@ -638,6 +640,7 @@ u32 hleDoLog(LogTypes::LOG_TYPE t, LogTypes::LOG_LEVELS level, u32 res, const ch hleFormatLogArgs(formatted_args, sizeof(formatted_args), argmask); const char *fmt; + // TODO: Floats and other types... move to another func (for return type?) Hmm. if (retmask == 'x') { fmt = "%08x=%s(%s)%s"; } else if (retmask == 'i') { diff --git a/Core/HLE/HLE.h b/Core/HLE/HLE.h index bd4d6be4b1..8322f4d0c7 100644 --- a/Core/HLE/HLE.h +++ b/Core/HLE/HLE.h @@ -33,15 +33,35 @@ enum { HLE_NOT_IN_INTERRUPT = 1 << 8, // Don't allow the call if dispatch or interrupts are disabled. HLE_NOT_DISPATCH_SUSPENDED = 1 << 9, + // Indicates the call should write zeros to the stack (stackBytesToClear in the table.) HLE_CLEAR_STACK_BYTES = 1 << 10 }; struct HLEFunction { + // This is the id, or nid, of the function (which is how it's linked.) + // Generally, the truncated least significant 32 bits of a SHA-1 hash. u32 ID; + // A pointer to the C++ handler; see FunctionWrappers.h for helpers. HLEFunc func; + // Name of the function. Often the same as func, this should match the PSP func's name and hash. const char *name; + // The return type, see argmask for the possible values. + // An additional value is possible - 'v', which means void (no return type.) + char retmask; + // The argument types, in order. Use the following characters: + // - x: for u32 (shown as hex in log) + // - i: for int/s32 + // - f: for float + // - X: uppercase, for u64 + // - I: uppercase, for s64 + // - F: uppercase, for double + // - s: a string pointer (const char *, utf-8) + // - p: a pointer (e.g. u32 *, shown with value in log) + const char *argmask; + // Flags (see above, e.g. HLE_NOT_IN_INTERRUPT.) u32 flags; + // See HLE_CLEAR_STACK_BYTES. u32 stackBytesToClear; }; diff --git a/Core/HLE/HLETables.cpp b/Core/HLE/HLETables.cpp index b9b5286bf4..604905a310 100644 --- a/Core/HLE/HLETables.cpp +++ b/Core/HLE/HLETables.cpp @@ -95,140 +95,140 @@ const HLEFunction FakeSysCalls[] = { const HLEFunction UtilsForUser[] = { - {0x91E4F6A7, WrapU_V, "sceKernelLibcClock"}, - {0x27CC57F0, WrapU_U, "sceKernelLibcTime"}, - {0x71EC4271, WrapU_UU, "sceKernelLibcGettimeofday"}, - {0xBFA98062, WrapI_UI, "sceKernelDcacheInvalidateRange"}, - {0xC8186A58, WrapI_UIU, "sceKernelUtilsMd5Digest"}, - {0x9E5C5086, WrapI_U, "sceKernelUtilsMd5BlockInit"}, - {0x61E1E525, WrapI_UUI, "sceKernelUtilsMd5BlockUpdate"}, - {0xB8D24E78, WrapI_UU, "sceKernelUtilsMd5BlockResult"}, - {0x840259F1, WrapI_UIU, "sceKernelUtilsSha1Digest"}, - {0xF8FCD5BA, WrapI_U, "sceKernelUtilsSha1BlockInit"}, - {0x346F6DA8, WrapI_UUI, "sceKernelUtilsSha1BlockUpdate"}, - {0x585F1C09, WrapI_UU, "sceKernelUtilsSha1BlockResult"}, - {0xE860E75E, WrapU_UU, "sceKernelUtilsMt19937Init"}, - {0x06FB8A63, WrapU_U, "sceKernelUtilsMt19937UInt"}, - {0x37FB5C42, WrapU_V, "sceKernelGetGPI"}, - {0x6AD345D7, WrapV_U, "sceKernelSetGPO"}, - {0x79D1C3FA, WrapI_V, "sceKernelDcacheWritebackAll"}, - {0xB435DEC5, WrapI_V, "sceKernelDcacheWritebackInvalidateAll"}, - {0x3EE30821, WrapI_UI, "sceKernelDcacheWritebackRange"}, - {0x34B9FA9E, WrapI_UI, "sceKernelDcacheWritebackInvalidateRange"}, - {0xC2DF770E, WrapI_UI, "sceKernelIcacheInvalidateRange"}, - {0x80001C4C, 0, "sceKernelDcacheProbe"}, - {0x16641D70, 0, "sceKernelDcacheReadTag"}, - {0x4FD31C9D, 0, "sceKernelIcacheProbe"}, - {0xFB05FAD0, 0, "sceKernelIcacheReadTag"}, - {0x920f104a, WrapU_V, "sceKernelIcacheInvalidateAll"} + {0X91E4F6A7, &WrapU_V, "sceKernelLibcClock", 'x', "" }, + {0X27CC57F0, &WrapU_U, "sceKernelLibcTime", 'x', "x" }, + {0X71EC4271, &WrapU_UU, "sceKernelLibcGettimeofday", 'x', "xx" }, + {0XBFA98062, &WrapI_UI, "sceKernelDcacheInvalidateRange", 'i', "xi" }, + {0XC8186A58, &WrapI_UIU, "sceKernelUtilsMd5Digest", 'i', "xix"}, + {0X9E5C5086, &WrapI_U, "sceKernelUtilsMd5BlockInit", 'i', "x" }, + {0X61E1E525, &WrapI_UUI, "sceKernelUtilsMd5BlockUpdate", 'i', "xxi"}, + {0XB8D24E78, &WrapI_UU, "sceKernelUtilsMd5BlockResult", 'i', "xx" }, + {0X840259F1, &WrapI_UIU, "sceKernelUtilsSha1Digest", 'i', "xix"}, + {0XF8FCD5BA, &WrapI_U, "sceKernelUtilsSha1BlockInit", 'i', "x" }, + {0X346F6DA8, &WrapI_UUI, "sceKernelUtilsSha1BlockUpdate", 'i', "xxi"}, + {0X585F1C09, &WrapI_UU, "sceKernelUtilsSha1BlockResult", 'i', "xx" }, + {0XE860E75E, &WrapU_UU, "sceKernelUtilsMt19937Init", 'x', "xx" }, + {0X06FB8A63, &WrapU_U, "sceKernelUtilsMt19937UInt", 'x', "x" }, + {0X37FB5C42, &WrapU_V, "sceKernelGetGPI", 'x', "" }, + {0X6AD345D7, &WrapV_U, "sceKernelSetGPO", 'v', "x" }, + {0X79D1C3FA, &WrapI_V, "sceKernelDcacheWritebackAll", 'i', "" }, + {0XB435DEC5, &WrapI_V, "sceKernelDcacheWritebackInvalidateAll", 'i', "" }, + {0X3EE30821, &WrapI_UI, "sceKernelDcacheWritebackRange", 'i', "xi" }, + {0X34B9FA9E, &WrapI_UI, "sceKernelDcacheWritebackInvalidateRange", 'i', "xi" }, + {0XC2DF770E, &WrapI_UI, "sceKernelIcacheInvalidateRange", 'i', "xi" }, + {0X80001C4C, nullptr, "sceKernelDcacheProbe", '?', "" }, + {0X16641D70, nullptr, "sceKernelDcacheReadTag", '?', "" }, + {0X4FD31C9D, nullptr, "sceKernelIcacheProbe", '?', "" }, + {0XFB05FAD0, nullptr, "sceKernelIcacheReadTag", '?', "" }, + {0X920F104A, &WrapU_V, "sceKernelIcacheInvalidateAll", 'x', "" } }; const HLEFunction IoFileMgrForKernel[] = { - {0xa905b705, 0, "sceIoCloseAll"}, - {0x411106BA, 0, "sceIoGetThreadCwd"}, - {0xCB0A151F, 0, "sceIoChangeThreadCwd"}, - {0x8E982A74, 0, "sceIoAddDrv"}, - {0xC7F35804, 0, "sceIoDelDrv"}, - {0x3C54E908, 0, "sceIoReopen"}, - {0xb29ddf9c, 0, "sceIoDopen"}, - {0xe3eb004c, 0, "sceIoDread"}, - {0xeb092469, 0, "sceIoDclose"}, - {0x109f50bc, 0, "sceIoOpen"}, - {0x6a638d83, 0, "sceIoRead"}, - {0x42ec03ac, 0, "sceIoWrite"}, - {0x68963324, 0, "sceIoLseek32"}, - {0x27eb27b8, 0, "sceIoLseek"}, - {0x810c4bc3, 0, "sceIoClose"}, - {0x779103a0, 0, "sceIoRename"}, - {0xf27a9c51, 0, "sceIoRemove"}, - {0x55f4717d, 0, "sceIoChdir"}, - {0x06a70004, 0, "sceIoMkdir"}, - {0x1117c65f, 0, "sceIoRmdir"}, - {0x54f5fb11, 0, "sceIoDevctl"}, - {0x63632449, 0, "sceIoIoctl"}, - {0xab96437f, 0, "sceIoSync"}, - {0xb2a628c1, 0, "sceIoAssign"}, - {0x6d08a871, 0, "sceIoUnassign"}, - {0xace946e8, 0, "sceIoGetstat"}, - {0xb8a740f4, 0, "sceIoChstat"}, - {0xa0b5a7c2, 0, "sceIoReadAsync"}, - {0x3251ea56, 0, "sceIoPollAsync"}, - {0xe23eec33, 0, "sceIoWaitAsync"}, - {0x35dbd746, 0, "sceIoWaitAsyncCB"}, - {0xbd17474f, 0, "IoFileMgrForKernel_BD17474F"}, - {0x76da16e3, 0, "IoFileMgrForKernel_76DA16E3"}, + {0XA905B705, nullptr, "sceIoCloseAll", '?', "" }, + {0X411106BA, nullptr, "sceIoGetThreadCwd", '?', "" }, + {0XCB0A151F, nullptr, "sceIoChangeThreadCwd", '?', "" }, + {0X8E982A74, nullptr, "sceIoAddDrv", '?', "" }, + {0XC7F35804, nullptr, "sceIoDelDrv", '?', "" }, + {0X3C54E908, nullptr, "sceIoReopen", '?', "" }, + {0XB29DDF9C, nullptr, "sceIoDopen", '?', "" }, + {0XE3EB004C, nullptr, "sceIoDread", '?', "" }, + {0XEB092469, nullptr, "sceIoDclose", '?', "" }, + {0X109F50BC, nullptr, "sceIoOpen", '?', "" }, + {0X6A638D83, nullptr, "sceIoRead", '?', "" }, + {0X42EC03AC, nullptr, "sceIoWrite", '?', "" }, + {0X68963324, nullptr, "sceIoLseek32", '?', "" }, + {0X27EB27B8, nullptr, "sceIoLseek", '?', "" }, + {0X810C4BC3, nullptr, "sceIoClose", '?', "" }, + {0X779103A0, nullptr, "sceIoRename", '?', "" }, + {0XF27A9C51, nullptr, "sceIoRemove", '?', "" }, + {0X55F4717D, nullptr, "sceIoChdir", '?', "" }, + {0X06A70004, nullptr, "sceIoMkdir", '?', "" }, + {0X1117C65F, nullptr, "sceIoRmdir", '?', "" }, + {0X54F5FB11, nullptr, "sceIoDevctl", '?', "" }, + {0X63632449, nullptr, "sceIoIoctl", '?', "" }, + {0XAB96437F, nullptr, "sceIoSync", '?', "" }, + {0XB2A628C1, nullptr, "sceIoAssign", '?', "" }, + {0X6D08A871, nullptr, "sceIoUnassign", '?', "" }, + {0XACE946E8, nullptr, "sceIoGetstat", '?', "" }, + {0XB8A740F4, nullptr, "sceIoChstat", '?', "" }, + {0XA0B5A7C2, nullptr, "sceIoReadAsync", '?', "" }, + {0X3251EA56, nullptr, "sceIoPollAsync", '?', "" }, + {0XE23EEC33, nullptr, "sceIoWaitAsync", '?', "" }, + {0X35DBD746, nullptr, "sceIoWaitAsyncCB", '?', "" }, + {0XBD17474F, nullptr, "IoFileMgrForKernel_BD17474F", '?', "" }, + {0X76DA16E3, nullptr, "IoFileMgrForKernel_76DA16E3", '?', "" }, }; const HLEFunction StdioForKernel[] = { - {0x98220F3E, 0, "sceKernelStdoutReopen"}, - {0xFB5380C5, 0, "sceKernelStderrReopen"}, - {0xcab439df, 0, "printf"}, - {0x2CCF071A, 0, "fdprintf"}, - {0xd97c8cb9, 0, "puts"}, - {0x172D316E, 0, "sceKernelStdin"}, - {0xA6BAB2E9, 0, "sceKernelStdout"}, - {0xF78BA90A, 0, "sceKernelStderr"}, + {0X98220F3E, nullptr, "sceKernelStdoutReopen", '?', "" }, + {0XFB5380C5, nullptr, "sceKernelStderrReopen", '?', "" }, + {0XCAB439DF, nullptr, "printf", '?', "" }, + {0X2CCF071A, nullptr, "fdprintf", '?', "" }, + {0XD97C8CB9, nullptr, "puts", '?', "" }, + {0X172D316E, nullptr, "sceKernelStdin", '?', "" }, + {0XA6BAB2E9, nullptr, "sceKernelStdout", '?', "" }, + {0XF78BA90A, nullptr, "sceKernelStderr", '?', "" }, }; const HLEFunction LoadCoreForKernel[] = { - {0xACE23476, 0, "sceKernelCheckPspConfig"}, - {0x7BE1421C, 0, "sceKernelCheckExecFile"}, - {0xBF983EF2, 0, "sceKernelProbeExecutableObject"}, - {0x7068E6BA, 0, "sceKernelLoadExecutableObject"}, - {0xB4D6FECC, 0, "sceKernelApplyElfRelSection"}, - {0x54AB2675, 0, "sceKernelApplyPspRelSection"}, - {0x2952F5AC, 0, "sceKernelDcacheWBinvAll"}, - {0xD8779AC6, WrapU_V, "sceKernelIcacheClearAll"}, - {0x99A695F0, 0, "sceKernelRegisterLibrary"}, - {0x5873A31F, 0, "sceKernelRegisterLibraryForUser"}, - {0x0B464512, 0, "sceKernelReleaseLibrary"}, - {0x9BAF90F6, 0, "sceKernelCanReleaseLibrary"}, - {0x0E760DBA, 0, "sceKernelLinkLibraryEntries"}, - {0x0DE1F600, 0, "sceKernelLinkLibraryEntriesForUser"}, - {0xDA1B09AA, 0, "sceKernelUnLinkLibraryEntries"}, - {0xC99DD47A, 0, "sceKernelQueryLoadCoreCB"}, - {0x616FCCCD, 0, "sceKernelSetBootCallbackLevel"}, - {0xF32A2940, 0, "sceKernelModuleFromUID"}, - {0xCD0F3BAC, 0, "sceKernelCreateModule"}, - {0x6B2371C2, 0, "sceKernelDeleteModule"}, - {0x7320D964, 0, "sceKernelModuleAssign"}, - {0x44B292AB, 0, "sceKernelAllocModule"}, - {0xBD61D4D5, 0, "sceKernelFreeModule"}, - {0xAE7C6E76, 0, "sceKernelRegisterModule"}, - {0x74CF001A, 0, "sceKernelReleaseModule"}, - {0xFB8AE27D, 0, "sceKernelFindModuleByAddress"}, - {0xCCE4A157, 0, "sceKernelFindModuleByUID"}, - {0x82CE54ED, 0, "sceKernelModuleCount"}, - {0xC0584F0C, 0, "sceKernelGetModuleList"}, - {0xCF8A41B1, WrapU_C,"sceKernelFindModuleByName"}, - {0xb95fa50d, 0, "LoadCoreForKernel_B95FA50D"}, + {0XACE23476, nullptr, "sceKernelCheckPspConfig", '?', "" }, + {0X7BE1421C, nullptr, "sceKernelCheckExecFile", '?', "" }, + {0XBF983EF2, nullptr, "sceKernelProbeExecutableObject", '?', "" }, + {0X7068E6BA, nullptr, "sceKernelLoadExecutableObject", '?', "" }, + {0XB4D6FECC, nullptr, "sceKernelApplyElfRelSection", '?', "" }, + {0X54AB2675, nullptr, "sceKernelApplyPspRelSection", '?', "" }, + {0X2952F5AC, nullptr, "sceKernelDcacheWBinvAll", '?', "" }, + {0XD8779AC6, &WrapU_V, "sceKernelIcacheClearAll", 'x', "" }, + {0X99A695F0, nullptr, "sceKernelRegisterLibrary", '?', "" }, + {0X5873A31F, nullptr, "sceKernelRegisterLibraryForUser", '?', "" }, + {0X0B464512, nullptr, "sceKernelReleaseLibrary", '?', "" }, + {0X9BAF90F6, nullptr, "sceKernelCanReleaseLibrary", '?', "" }, + {0X0E760DBA, nullptr, "sceKernelLinkLibraryEntries", '?', "" }, + {0X0DE1F600, nullptr, "sceKernelLinkLibraryEntriesForUser", '?', "" }, + {0XDA1B09AA, nullptr, "sceKernelUnLinkLibraryEntries", '?', "" }, + {0XC99DD47A, nullptr, "sceKernelQueryLoadCoreCB", '?', "" }, + {0X616FCCCD, nullptr, "sceKernelSetBootCallbackLevel", '?', "" }, + {0XF32A2940, nullptr, "sceKernelModuleFromUID", '?', "" }, + {0XCD0F3BAC, nullptr, "sceKernelCreateModule", '?', "" }, + {0X6B2371C2, nullptr, "sceKernelDeleteModule", '?', "" }, + {0X7320D964, nullptr, "sceKernelModuleAssign", '?', "" }, + {0X44B292AB, nullptr, "sceKernelAllocModule", '?', "" }, + {0XBD61D4D5, nullptr, "sceKernelFreeModule", '?', "" }, + {0XAE7C6E76, nullptr, "sceKernelRegisterModule", '?', "" }, + {0X74CF001A, nullptr, "sceKernelReleaseModule", '?', "" }, + {0XFB8AE27D, nullptr, "sceKernelFindModuleByAddress", '?', "" }, + {0XCCE4A157, nullptr, "sceKernelFindModuleByUID", '?', "" }, + {0X82CE54ED, nullptr, "sceKernelModuleCount", '?', "" }, + {0XC0584F0C, nullptr, "sceKernelGetModuleList", '?', "" }, + {0XCF8A41B1, &WrapU_C, "sceKernelFindModuleByName", 'x', "s" }, + {0XB95FA50D, nullptr, "LoadCoreForKernel_B95FA50D", '?', "" }, }; const HLEFunction KDebugForKernel[] = { - {0xE7A3874D, 0, "sceKernelRegisterAssertHandler"}, - {0x2FF4E9F9, 0, "sceKernelAssert"}, - {0x9B868276, 0, "sceKernelGetDebugPutchar"}, - {0xE146606D, 0, "sceKernelRegisterDebugPutchar"}, - {0x7CEB2C09, WrapU_V, "sceKernelRegisterKprintfHandler"}, - {0x84F370BC, 0, "Kprintf"}, - {0x5CE9838B, 0, "sceKernelDebugWrite"}, - {0x66253C4E, 0, "sceKernelRegisterDebugWrite"}, - {0xDBB5597F, 0, "sceKernelDebugRead"}, - {0xE6554FDA, 0, "sceKernelRegisterDebugRead"}, - {0xB9C643C9, 0, "sceKernelDebugEcho"}, - {0x7D1C74F0, 0, "sceKernelDebugEchoSet"}, - {0x24C32559, 0, "sceKernelDipsw"}, - {0xD636B827, 0, "sceKernelRemoveByDebugSection"}, - {0x5282DD5E, 0, "sceKernelDipswSet"}, - {0x9F8703E4, 0, "KDebugForKernel_9F8703E4"}, - {0x333DCEC7, 0, "KDebugForKernel_333DCEC7"}, - {0xE892D9A1, 0, "KDebugForKernel_E892D9A1"}, - {0xA126F497, 0, "KDebugForKernel_A126F497"}, - {0xB7251823, 0, "sceKernelAcceptMbogoSig"}, + {0XE7A3874D, nullptr, "sceKernelRegisterAssertHandler", '?', "" }, + {0X2FF4E9F9, nullptr, "sceKernelAssert", '?', "" }, + {0X9B868276, nullptr, "sceKernelGetDebugPutchar", '?', "" }, + {0XE146606D, nullptr, "sceKernelRegisterDebugPutchar", '?', "" }, + {0X7CEB2C09, &WrapU_V, "sceKernelRegisterKprintfHandler", 'x', "" }, + {0X84F370BC, nullptr, "Kprintf", '?', "" }, + {0X5CE9838B, nullptr, "sceKernelDebugWrite", '?', "" }, + {0X66253C4E, nullptr, "sceKernelRegisterDebugWrite", '?', "" }, + {0XDBB5597F, nullptr, "sceKernelDebugRead", '?', "" }, + {0XE6554FDA, nullptr, "sceKernelRegisterDebugRead", '?', "" }, + {0XB9C643C9, nullptr, "sceKernelDebugEcho", '?', "" }, + {0X7D1C74F0, nullptr, "sceKernelDebugEchoSet", '?', "" }, + {0X24C32559, nullptr, "sceKernelDipsw", '?', "" }, + {0XD636B827, nullptr, "sceKernelRemoveByDebugSection", '?', "" }, + {0X5282DD5E, nullptr, "sceKernelDipswSet", '?', "" }, + {0X9F8703E4, nullptr, "KDebugForKernel_9F8703E4", '?', "" }, + {0X333DCEC7, nullptr, "KDebugForKernel_333DCEC7", '?', "" }, + {0XE892D9A1, nullptr, "KDebugForKernel_E892D9A1", '?', "" }, + {0XA126F497, nullptr, "KDebugForKernel_A126F497", '?', "" }, + {0XB7251823, nullptr, "sceKernelAcceptMbogoSig", '?', "" }, }; @@ -236,7 +236,7 @@ const HLEFunction KDebugForKernel[] = const HLEFunction pspeDebug[] = { - {0xDEADBEAF, 0, "pspeDebugWrite"}, + {0XDEADBEAF, nullptr, "pspeDebugWrite", '?', "" }, }; diff --git a/Core/HLE/sceAdler.cpp b/Core/HLE/sceAdler.cpp index 67d56dcad6..7bb4794b0f 100644 --- a/Core/HLE/sceAdler.cpp +++ b/Core/HLE/sceAdler.cpp @@ -37,7 +37,7 @@ static u32 sceAdler32(u32 adler, u32 data, u32 datalen) { const HLEFunction sceAdler[] = { - { 0x9702EF11, WrapU_UUU, "sceAdler32" }, + {0X9702EF11, &WrapU_UUU, "sceAdler32", 'x', "xxx"}, }; void Register_sceAdler() diff --git a/Core/HLE/sceAtrac.cpp b/Core/HLE/sceAtrac.cpp index 0396557194..14e6372d4d 100644 --- a/Core/HLE/sceAtrac.cpp +++ b/Core/HLE/sceAtrac.cpp @@ -2218,44 +2218,44 @@ static int sceAtracSetAA3HalfwayBufferAndGetID(u32 halfBuffer, u32 readSize, u32 } const HLEFunction sceAtrac3plus[] = { - {0x7db31251,WrapU_IU,"sceAtracAddStreamData"}, - {0x6a8c3cd5,WrapU_IUUUU,"sceAtracDecodeData"}, - {0xd5c28cc0,WrapU_V,"sceAtracEndEntry"}, - {0x780f88d1,WrapU_I,"sceAtracGetAtracID"}, - {0xca3ca3d2,WrapU_IIU,"sceAtracGetBufferInfoForReseting"}, - {0xa554a158,WrapU_IU,"sceAtracGetBitrate"}, - {0x31668baa,WrapU_IU,"sceAtracGetChannel"}, - {0xfaa4f89b,WrapU_IUU,"sceAtracGetLoopStatus"}, - {0xe88f759b,WrapU_IU,"sceAtracGetInternalErrorInfo"}, - {0xd6a5f2f7,WrapU_IU,"sceAtracGetMaxSample"}, - {0xe23e3a35,WrapU_IU,"sceAtracGetNextDecodePosition"}, - {0x36faabfb,WrapU_IU,"sceAtracGetNextSample"}, - {0x9ae849a7,WrapU_IU,"sceAtracGetRemainFrame"}, - {0x83e85ea0,WrapU_IUU,"sceAtracGetSecondBufferInfo"}, - {0xa2bba8be,WrapU_IUUU,"sceAtracGetSoundSample"}, - {0x5d268707,WrapU_IUUU,"sceAtracGetStreamDataInfo"}, - {0x61eb33f5,WrapU_I,"sceAtracReleaseAtracID"}, - {0x644e5607,WrapU_IIII,"sceAtracResetPlayPosition"}, - {0x3f6e26b5,WrapU_IUUU,"sceAtracSetHalfwayBuffer"}, - {0x83bf7afd,WrapU_IUU,"sceAtracSetSecondBuffer"}, - {0x0E2A73AB,WrapU_IUU,"sceAtracSetData"}, //? - {0x7a20e7af,WrapI_UI,"sceAtracSetDataAndGetID"}, - {0xd1f59fdb,WrapU_V,"sceAtracStartEntry"}, - {0x868120b5,WrapU_II,"sceAtracSetLoopNum"}, - {0x132f1eca,WrapI_II,"sceAtracReinit"}, - {0xeca32a99,WrapI_I,"sceAtracIsSecondBufferNeeded"}, - {0x0fae370e,WrapI_UUU,"sceAtracSetHalfwayBufferAndGetID"}, - {0x2DD3E298,WrapU_IIU,"sceAtracGetBufferInfoForResetting"}, - {0x5CF9D852,WrapI_IUUU,"sceAtracSetMOutHalfwayBuffer"}, - {0xF6837A1A,WrapU_IUU,"sceAtracSetMOutData"}, - {0x472E3825,WrapI_UU,"sceAtracSetMOutDataAndGetID"}, - {0x9CD7DE03,WrapI_UUU,"sceAtracSetMOutHalfwayBufferAndGetID"}, - {0xB3B5D042,WrapI_IU,"sceAtracGetOutputChannel"}, - {0x5622B7C1,WrapI_UUUU,"sceAtracSetAA3DataAndGetID"}, - {0x5DD66588,WrapI_UUUU,"sceAtracSetAA3HalfwayBufferAndGetID"}, - {0x231FC6B7,WrapI_I<_sceAtracGetContextAddress>,"_sceAtracGetContextAddress"}, - {0x1575D64B,WrapI_IU,"sceAtracLowLevelInitDecoder"}, - {0x0C116E1B,WrapI_IUUUU,"sceAtracLowLevelDecode"}, + {0X7DB31251, &WrapU_IU, "sceAtracAddStreamData", 'x', "ix" }, + {0X6A8C3CD5, &WrapU_IUUUU, "sceAtracDecodeData", 'x', "ixxxx"}, + {0XD5C28CC0, &WrapU_V, "sceAtracEndEntry", 'x', "" }, + {0X780F88D1, &WrapU_I, "sceAtracGetAtracID", 'x', "i" }, + {0XCA3CA3D2, &WrapU_IIU, "sceAtracGetBufferInfoForReseting", 'x', "iix" }, + {0XA554A158, &WrapU_IU, "sceAtracGetBitrate", 'x', "ix" }, + {0X31668BAA, &WrapU_IU, "sceAtracGetChannel", 'x', "ix" }, + {0XFAA4F89B, &WrapU_IUU, "sceAtracGetLoopStatus", 'x', "ixx" }, + {0XE88F759B, &WrapU_IU, "sceAtracGetInternalErrorInfo", 'x', "ix" }, + {0XD6A5F2F7, &WrapU_IU, "sceAtracGetMaxSample", 'x', "ix" }, + {0XE23E3A35, &WrapU_IU, "sceAtracGetNextDecodePosition", 'x', "ix" }, + {0X36FAABFB, &WrapU_IU, "sceAtracGetNextSample", 'x', "ix" }, + {0X9AE849A7, &WrapU_IU, "sceAtracGetRemainFrame", 'x', "ix" }, + {0X83E85EA0, &WrapU_IUU, "sceAtracGetSecondBufferInfo", 'x', "ixx" }, + {0XA2BBA8BE, &WrapU_IUUU, "sceAtracGetSoundSample", 'x', "ixxx" }, + {0X5D268707, &WrapU_IUUU, "sceAtracGetStreamDataInfo", 'x', "ixxx" }, + {0X61EB33F5, &WrapU_I, "sceAtracReleaseAtracID", 'x', "i" }, + {0X644E5607, &WrapU_IIII, "sceAtracResetPlayPosition", 'x', "iiii" }, + {0X3F6E26B5, &WrapU_IUUU, "sceAtracSetHalfwayBuffer", 'x', "ixxx" }, + {0X83BF7AFD, &WrapU_IUU, "sceAtracSetSecondBuffer", 'x', "ixx" }, + {0X0E2A73AB, &WrapU_IUU, "sceAtracSetData", 'x', "ixx" }, + {0X7A20E7AF, &WrapI_UI, "sceAtracSetDataAndGetID", 'i', "xi" }, + {0XD1F59FDB, &WrapU_V, "sceAtracStartEntry", 'x', "" }, + {0X868120B5, &WrapU_II, "sceAtracSetLoopNum", 'x', "ii" }, + {0X132F1ECA, &WrapI_II, "sceAtracReinit", 'i', "ii" }, + {0XECA32A99, &WrapI_I, "sceAtracIsSecondBufferNeeded", 'i', "i" }, + {0X0FAE370E, &WrapI_UUU, "sceAtracSetHalfwayBufferAndGetID", 'i', "xxx" }, + {0X2DD3E298, &WrapU_IIU, "sceAtracGetBufferInfoForResetting", 'x', "iix" }, + {0X5CF9D852, &WrapI_IUUU, "sceAtracSetMOutHalfwayBuffer", 'i', "ixxx" }, + {0XF6837A1A, &WrapU_IUU, "sceAtracSetMOutData", 'x', "ixx" }, + {0X472E3825, &WrapI_UU, "sceAtracSetMOutDataAndGetID", 'i', "xx" }, + {0X9CD7DE03, &WrapI_UUU, "sceAtracSetMOutHalfwayBufferAndGetID", 'i', "xxx" }, + {0XB3B5D042, &WrapI_IU, "sceAtracGetOutputChannel", 'i', "ix" }, + {0X5622B7C1, &WrapI_UUUU, "sceAtracSetAA3DataAndGetID", 'i', "xxxx" }, + {0X5DD66588, &WrapI_UUUU, "sceAtracSetAA3HalfwayBufferAndGetID", 'i', "xxxx" }, + {0X231FC6B7, &WrapI_I<_sceAtracGetContextAddress>, "_sceAtracGetContextAddress", 'i', "i" }, + {0X1575D64B, &WrapI_IU, "sceAtracLowLevelInitDecoder", 'i', "ix" }, + {0X0C116E1B, &WrapI_IUUUU, "sceAtracLowLevelDecode", 'i', "ixxxx"}, }; void Register_sceAtrac3plus() { diff --git a/Core/HLE/sceAudio.cpp b/Core/HLE/sceAudio.cpp index c87fcbeefc..93acd0a1f5 100644 --- a/Core/HLE/sceAudio.cpp +++ b/Core/HLE/sceAudio.cpp @@ -461,51 +461,51 @@ const HLEFunction sceAudio[] = { // Newer simplified single channel audio output. Presumably for games that use Atrac3 // directly from Sas instead of playing it on a separate audio channel. - {0x01562ba3, WrapU_U, "sceAudioOutput2Reserve"}, - {0x2d53f36e, WrapU_UU, "sceAudioOutput2OutputBlocking"}, - {0x63f2889c, WrapU_U, "sceAudioOutput2ChangeLength"}, - {0x647cef33, WrapU_V, "sceAudioOutput2GetRestSample"}, - {0x43196845, WrapU_V, "sceAudioOutput2Release"}, + {0X01562BA3, &WrapU_U, "sceAudioOutput2Reserve", 'x', "x" }, + {0X2D53F36E, &WrapU_UU, "sceAudioOutput2OutputBlocking", 'x', "xx" }, + {0X63F2889C, &WrapU_U, "sceAudioOutput2ChangeLength", 'x', "x" }, + {0X647CEF33, &WrapU_V, "sceAudioOutput2GetRestSample", 'x', "" }, + {0X43196845, &WrapU_V, "sceAudioOutput2Release", 'x', "" }, // "Traditional" audio channel interface - {0x80F1F7E0, WrapU_V, "sceAudioInit"}, - {0x210567F7, WrapU_V, "sceAudioEnd"}, - {0xA2BEAA6C, WrapU_U, "sceAudioSetFrequency"}, - {0x927AC32B, WrapU_V, "sceAudioSetVolumeOffset"}, - {0x8c1009b2, WrapU_UIU, "sceAudioOutput"}, - {0x136CAF51, WrapU_UIU, "sceAudioOutputBlocking"}, - {0xE2D56B2D, WrapU_UIIU, "sceAudioOutputPanned"}, - {0x13F592BC, WrapU_UIIU, "sceAudioOutputPannedBlocking"}, - {0x5EC81C55, WrapU_IUU, "sceAudioChReserve"}, - {0x6FC46853, WrapU_U, "sceAudioChRelease"}, - {0xE9D97901, WrapI_U, "sceAudioGetChannelRestLen"}, - {0xB011922F, WrapI_U, "sceAudioGetChannelRestLength"}, - {0xCB2E439E, WrapU_UU, "sceAudioSetChannelDataLen"}, - {0x95FD0C2D, WrapU_UU, "sceAudioChangeChannelConfig"}, - {0xB7E1D8E7, WrapU_UUU, "sceAudioChangeChannelVolume"}, + {0X80F1F7E0, &WrapU_V, "sceAudioInit", 'x', "" }, + {0X210567F7, &WrapU_V, "sceAudioEnd", 'x', "" }, + {0XA2BEAA6C, &WrapU_U, "sceAudioSetFrequency", 'x', "x" }, + {0X927AC32B, &WrapU_V, "sceAudioSetVolumeOffset", 'x', "" }, + {0X8C1009B2, &WrapU_UIU, "sceAudioOutput", 'x', "xix" }, + {0X136CAF51, &WrapU_UIU, "sceAudioOutputBlocking", 'x', "xix" }, + {0XE2D56B2D, &WrapU_UIIU, "sceAudioOutputPanned", 'x', "xiix"}, + {0X13F592BC, &WrapU_UIIU, "sceAudioOutputPannedBlocking", 'x', "xiix"}, + {0X5EC81C55, &WrapU_IUU, "sceAudioChReserve", 'x', "ixx" }, + {0X6FC46853, &WrapU_U, "sceAudioChRelease", 'x', "x" }, + {0XE9D97901, &WrapI_U, "sceAudioGetChannelRestLen", 'i', "x" }, + {0XB011922F, &WrapI_U, "sceAudioGetChannelRestLength", 'i', "x" }, + {0XCB2E439E, &WrapU_UU, "sceAudioSetChannelDataLen", 'x', "xx" }, + {0X95FD0C2D, &WrapU_UU, "sceAudioChangeChannelConfig", 'x', "xx" }, + {0XB7E1D8E7, &WrapU_UUU, "sceAudioChangeChannelVolume", 'x', "xxx" }, // Not sure about the point of these, maybe like traditional but with ability to do sample rate conversion? - {0x38553111, WrapU_UUU, "sceAudioSRCChReserve"}, - {0x5C37C0AE, WrapU_V, "sceAudioSRCChRelease"}, - {0xE0727056, WrapU_UU, "sceAudioSRCOutputBlocking"}, + {0X38553111, &WrapU_UUU, "sceAudioSRCChReserve", 'x', "xxx" }, + {0X5C37C0AE, &WrapU_V, "sceAudioSRCChRelease", 'x', "" }, + {0XE0727056, &WrapU_UU, "sceAudioSRCOutputBlocking", 'x', "xx" }, // Never seen these used - {0x41efade7, 0, "sceAudioOneshotOutput"}, - {0xB61595C0, 0, "sceAudioLoopbackTest"}, + {0X41EFADE7, nullptr, "sceAudioOneshotOutput", '?', "" }, + {0XB61595C0, nullptr, "sceAudioLoopbackTest", '?', "" }, // Microphone interface - {0x7de61688, 0, "sceAudioInputInit"}, - {0xE926D3FB, 0, "sceAudioInputInitEx"}, - {0x6d4bec68, 0, "sceAudioInput"}, - {0x086e5895, 0, "sceAudioInputBlocking"}, - {0xa708c6a6, 0, "sceAudioGetInputLength"}, - {0xA633048E, 0, "sceAudioPollInputEnd"}, - {0x87b2e651, 0, "sceAudioWaitInputEnd"}, + {0X7DE61688, nullptr, "sceAudioInputInit", '?', "" }, + {0XE926D3FB, nullptr, "sceAudioInputInitEx", '?', "" }, + {0X6D4BEC68, nullptr, "sceAudioInput", '?', "" }, + {0X086E5895, nullptr, "sceAudioInputBlocking", '?', "" }, + {0XA708C6A6, nullptr, "sceAudioGetInputLength", '?', "" }, + {0XA633048E, nullptr, "sceAudioPollInputEnd", '?', "" }, + {0X87B2E651, nullptr, "sceAudioWaitInputEnd", '?', "" }, - {0x36FD8AA9, WrapU_U, "sceAudioRoutingSetMode" }, - {0x39240E7D, WrapU_V, "sceAudioRoutingGetMode" }, - {0xBB548475, WrapU_U, "sceAudioRoutingSetVolumeMode" }, - {0x28235C56, WrapU_V, "sceAudioRoutingGetVolumeMode" }, + {0X36FD8AA9, &WrapU_U, "sceAudioRoutingSetMode", 'x', "x" }, + {0X39240E7D, &WrapU_V, "sceAudioRoutingGetMode", 'x', "" }, + {0XBB548475, &WrapU_U, "sceAudioRoutingSetVolumeMode", 'x', "x" }, + {0X28235C56, &WrapU_V, "sceAudioRoutingGetVolumeMode", 'x', "" }, }; diff --git a/Core/HLE/sceAudioRouting.cpp b/Core/HLE/sceAudioRouting.cpp index 17f928aae5..94efa459d3 100644 --- a/Core/HLE/sceAudioRouting.cpp +++ b/Core/HLE/sceAudioRouting.cpp @@ -53,10 +53,10 @@ static int sceAudioRoutingSetMode(int mode) { const HLEFunction sceAudioRouting[] = { - {0x39240E7D, WrapI_V, "sceAudioRoutingGetMode" }, - {0x28235C56, WrapI_V, "sceAudioRoutingGetVolumeMode" }, - {0x36FD8AA9, WrapI_I, "sceAudioRoutingSetMode" }, - {0xBB548475, WrapI_I, "sceAudioRoutingSetVolumeMode" }, + {0X39240E7D, &WrapI_V, "sceAudioRoutingGetMode", 'i', "" }, + {0X28235C56, &WrapI_V, "sceAudioRoutingGetVolumeMode", 'i', "" }, + {0X36FD8AA9, &WrapI_I, "sceAudioRoutingSetMode", 'i', "i"}, + {0XBB548475, &WrapI_I, "sceAudioRoutingSetVolumeMode", 'i', "i"}, }; void Register_sceAudioRouting() diff --git a/Core/HLE/sceAudiocodec.cpp b/Core/HLE/sceAudiocodec.cpp index bac7f29870..76d18df677 100644 --- a/Core/HLE/sceAudiocodec.cpp +++ b/Core/HLE/sceAudiocodec.cpp @@ -149,13 +149,13 @@ static int sceAudiocodecReleaseEDRAM(u32 ctxPtr, int id) { } const HLEFunction sceAudiocodec[] = { - { 0x70A703F8, WrapI_UI, "sceAudiocodecDecode" }, - { 0x5B37EB1D, WrapI_UI, "sceAudiocodecInit" }, - { 0x8ACA11D5, WrapI_UI, "sceAudiocodecGetInfo" }, - { 0x3A20A200, WrapI_UI, "sceAudiocodecGetEDRAM" }, - { 0x29681260, WrapI_UI, "sceAudiocodecReleaseEDRAM" }, - { 0x9D3F790C, WrapI_UI, "sceAudiocodecCheckNeedMem" }, - { 0x59176a0f, 0, "sceAudiocodec_59176A0F" }, + {0X70A703F8, &WrapI_UI, "sceAudiocodecDecode", 'i', "xi"}, + {0X5B37EB1D, &WrapI_UI, "sceAudiocodecInit", 'i', "xi"}, + {0X8ACA11D5, &WrapI_UI, "sceAudiocodecGetInfo", 'i', "xi"}, + {0X3A20A200, &WrapI_UI, "sceAudiocodecGetEDRAM", 'i', "xi"}, + {0X29681260, &WrapI_UI, "sceAudiocodecReleaseEDRAM", 'i', "xi"}, + {0X9D3F790C, &WrapI_UI, "sceAudiocodecCheckNeedMem", 'i', "xi"}, + {0X59176A0F, nullptr, "sceAudiocodec_59176A0F", '?', "" }, }; void Register_sceAudiocodec() diff --git a/Core/HLE/sceCcc.cpp b/Core/HLE/sceCcc.cpp index 6738974527..a0409b0a41 100644 --- a/Core/HLE/sceCcc.cpp +++ b/Core/HLE/sceCcc.cpp @@ -534,34 +534,34 @@ static u32 sceCccJIStoUCS(u32 c, u32 alt) const HLEFunction sceCcc[] = { - {0xB4D1CBBF, WrapV_UU, "sceCccSetTable"}, - {0x00D1378F, WrapI_UUU, "sceCccUTF8toUTF16"}, - {0x6F82EE03, WrapI_UUU, "sceCccUTF8toSJIS"}, - {0x41B724A5, WrapI_UUU, "sceCccUTF16toUTF8"}, - {0xF1B73D12, WrapI_UUU, "sceCccUTF16toSJIS"}, - {0xA62E6E80, WrapI_UUU, "sceCccSJIStoUTF8"}, - {0xBEB47224, WrapI_UUU, "sceCccSJIStoUTF16"}, - {0xb7d3c112, WrapI_U, "sceCccStrlenUTF8"}, - {0x4BDEB2A8, WrapI_U, "sceCccStrlenUTF16"}, - {0xd9392ccb, WrapI_U, "sceCccStrlenSJIS"}, - {0x92C05851, WrapU_UU, "sceCccEncodeUTF8"}, - {0x8406F469, WrapV_UU, "sceCccEncodeUTF16"}, - {0x068c4320, WrapU_UU, "sceCccEncodeSJIS"}, - {0xc6a8bee2, WrapU_U, "sceCccDecodeUTF8"}, - {0xe0cf8091, WrapU_U, "sceCccDecodeUTF16"}, - {0x953e6c10, WrapU_U, "sceCccDecodeSJIS"}, - {0x90521ac5, WrapI_U, "sceCccIsValidUTF8"}, - {0xcc0a8bda, WrapI_U, "sceCccIsValidUTF16"}, - {0x67bf0d19, WrapI_U, "sceCccIsValidSJIS"}, - {0x76e33e9c, WrapI_U, "sceCccIsValidUCS2"}, - {0xd2b18485, WrapI_U, "sceCccIsValidUCS4"}, - {0xa2d5d209, WrapI_U, "sceCccIsValidJIS"}, - {0xbd11eef3, WrapI_U, "sceCccIsValidUnicode"}, - {0x17e1d813, WrapU_U, "sceCccSetErrorCharUTF8"}, - {0xb8476cf4, WrapU_U, "sceCccSetErrorCharUTF16"}, - {0xc56949ad, WrapU_U, "sceCccSetErrorCharSJIS"}, - {0x70ecaa10, WrapU_UU, "sceCccUCStoJIS"}, - {0xfb7846e2, WrapU_UU, "sceCccJIStoUCS"}, + {0XB4D1CBBF, &WrapV_UU, "sceCccSetTable", 'v', "xx" }, + {0X00D1378F, &WrapI_UUU, "sceCccUTF8toUTF16", 'i', "xxx"}, + {0X6F82EE03, &WrapI_UUU, "sceCccUTF8toSJIS", 'i', "xxx"}, + {0X41B724A5, &WrapI_UUU, "sceCccUTF16toUTF8", 'i', "xxx"}, + {0XF1B73D12, &WrapI_UUU, "sceCccUTF16toSJIS", 'i', "xxx"}, + {0XA62E6E80, &WrapI_UUU, "sceCccSJIStoUTF8", 'i', "xxx"}, + {0XBEB47224, &WrapI_UUU, "sceCccSJIStoUTF16", 'i', "xxx"}, + {0XB7D3C112, &WrapI_U, "sceCccStrlenUTF8", 'i', "x" }, + {0X4BDEB2A8, &WrapI_U, "sceCccStrlenUTF16", 'i', "x" }, + {0XD9392CCB, &WrapI_U, "sceCccStrlenSJIS", 'i', "x" }, + {0X92C05851, &WrapU_UU, "sceCccEncodeUTF8", 'x', "xx" }, + {0X8406F469, &WrapV_UU, "sceCccEncodeUTF16", 'v', "xx" }, + {0X068C4320, &WrapU_UU, "sceCccEncodeSJIS", 'x', "xx" }, + {0XC6A8BEE2, &WrapU_U, "sceCccDecodeUTF8", 'x', "x" }, + {0XE0CF8091, &WrapU_U, "sceCccDecodeUTF16", 'x', "x" }, + {0X953E6C10, &WrapU_U, "sceCccDecodeSJIS", 'x', "x" }, + {0X90521AC5, &WrapI_U, "sceCccIsValidUTF8", 'i', "x" }, + {0XCC0A8BDA, &WrapI_U, "sceCccIsValidUTF16", 'i', "x" }, + {0X67BF0D19, &WrapI_U, "sceCccIsValidSJIS", 'i', "x" }, + {0X76E33E9C, &WrapI_U, "sceCccIsValidUCS2", 'i', "x" }, + {0XD2B18485, &WrapI_U, "sceCccIsValidUCS4", 'i', "x" }, + {0XA2D5D209, &WrapI_U, "sceCccIsValidJIS", 'i', "x" }, + {0XBD11EEF3, &WrapI_U, "sceCccIsValidUnicode", 'i', "x" }, + {0X17E1D813, &WrapU_U, "sceCccSetErrorCharUTF8", 'x', "x" }, + {0XB8476CF4, &WrapU_U, "sceCccSetErrorCharUTF16", 'x', "x" }, + {0XC56949AD, &WrapU_U, "sceCccSetErrorCharSJIS", 'x', "x" }, + {0X70ECAA10, &WrapU_UU, "sceCccUCStoJIS", 'x', "xx" }, + {0XFB7846E2, &WrapU_UU, "sceCccJIStoUCS", 'x', "xx" }, }; void Register_sceCcc() diff --git a/Core/HLE/sceChnnlsv.cpp b/Core/HLE/sceChnnlsv.cpp index a02b4be265..e541842a34 100644 --- a/Core/HLE/sceChnnlsv.cpp +++ b/Core/HLE/sceChnnlsv.cpp @@ -533,12 +533,12 @@ int sceChnnlsv_21BE78B4_(pspChnnlsvContext2& ctx) const HLEFunction sceChnnlsv[] = { - {0xE7833020,WrapI_UI,"sceSdSetIndex"}, - {0xF21A1FCA,WrapI_UUI,"sceSdRemoveValue"}, - {0xC4C494F8,WrapI_UUU,"sceSdGetLastIndex"}, - {0xABFDFC8B,WrapI_UIIUU,"sceSdCreateList"}, - {0x850A7FA1,WrapI_UUI,"sceSdSetMember"}, - {0x21BE78B4,WrapI_U,"sceChnnlsv_21BE78B4"}, + {0XE7833020, &WrapI_UI, "sceSdSetIndex", 'i', "xi" }, + {0XF21A1FCA, &WrapI_UUI, "sceSdRemoveValue", 'i', "xxi" }, + {0XC4C494F8, &WrapI_UUU, "sceSdGetLastIndex", 'i', "xxx" }, + {0XABFDFC8B, &WrapI_UIIUU, "sceSdCreateList", 'i', "xiixx"}, + {0X850A7FA1, &WrapI_UUI, "sceSdSetMember", 'i', "xxi" }, + {0X21BE78B4, &WrapI_U, "sceChnnlsv_21BE78B4", 'i', "x" }, }; void Register_sceChnnlsv() diff --git a/Core/HLE/sceCtrl.cpp b/Core/HLE/sceCtrl.cpp index 026f1be8ff..53b0b9c2fb 100644 --- a/Core/HLE/sceCtrl.cpp +++ b/Core/HLE/sceCtrl.cpp @@ -520,23 +520,23 @@ static u32 sceCtrlReadLatch(u32 latchDataPtr) static const HLEFunction sceCtrl[] = { - {0x3E65A0EA, 0, "sceCtrlInit"}, //(int unknown), init with 0 - {0x1f4011e6, WrapU_U, "sceCtrlSetSamplingMode"}, //(int on); - {0x6A2774F3, WrapU_U, "sceCtrlSetSamplingCycle"}, - {0x02BAAD91, WrapI_U,"sceCtrlGetSamplingCycle"}, - {0xDA6B76A1, WrapI_U, "sceCtrlGetSamplingMode"}, - {0x1f803938, WrapV_UU, "sceCtrlReadBufferPositive"}, //(ctrl_data_t* paddata, int unknown) // unknown should be 1 - {0x3A622550, WrapI_UU, "sceCtrlPeekBufferPositive"}, - {0xC152080A, WrapI_UU, "sceCtrlPeekBufferNegative"}, - {0x60B81F86, WrapV_UU, "sceCtrlReadBufferNegative"}, - {0xB1D0E5CD, WrapU_U, "sceCtrlPeekLatch"}, - {0x0B588501, WrapU_U, "sceCtrlReadLatch"}, - {0x348D99D4, 0, "sceCtrlSetSuspendingExtraSamples"}, - {0xAF5960F3, 0, "sceCtrlGetSuspendingExtraSamples"}, - {0xA68FD260, 0, "sceCtrlClearRapidFire"}, - {0x6841BE1A, 0, "sceCtrlSetRapidFire"}, - {0xa7144800, WrapI_II, "sceCtrlSetIdleCancelThreshold"}, - {0x687660fa, WrapI_UU, "sceCtrlGetIdleCancelThreshold"}, + {0X3E65A0EA, nullptr, "sceCtrlInit", '?', "" }, //(int unknown), init with 0 + {0X1F4011E6, &WrapU_U, "sceCtrlSetSamplingMode", 'x', "x" }, + {0X6A2774F3, &WrapU_U, "sceCtrlSetSamplingCycle", 'x', "x" }, + {0X02BAAD91, &WrapI_U, "sceCtrlGetSamplingCycle", 'i', "x" }, + {0XDA6B76A1, &WrapI_U, "sceCtrlGetSamplingMode", 'i', "x" }, + {0X1F803938, &WrapV_UU, "sceCtrlReadBufferPositive", 'v', "xx"}, + {0X3A622550, &WrapI_UU, "sceCtrlPeekBufferPositive", 'i', "xx"}, + {0XC152080A, &WrapI_UU, "sceCtrlPeekBufferNegative", 'i', "xx"}, + {0X60B81F86, &WrapV_UU, "sceCtrlReadBufferNegative", 'v', "xx"}, + {0XB1D0E5CD, &WrapU_U, "sceCtrlPeekLatch", 'x', "x" }, + {0X0B588501, &WrapU_U, "sceCtrlReadLatch", 'x', "x" }, + {0X348D99D4, nullptr, "sceCtrlSetSuspendingExtraSamples", '?', "" }, + {0XAF5960F3, nullptr, "sceCtrlGetSuspendingExtraSamples", '?', "" }, + {0XA68FD260, nullptr, "sceCtrlClearRapidFire", '?', "" }, + {0X6841BE1A, nullptr, "sceCtrlSetRapidFire", '?', "" }, + {0XA7144800, &WrapI_II, "sceCtrlSetIdleCancelThreshold", 'i', "ii"}, + {0X687660FA, &WrapI_UU, "sceCtrlGetIdleCancelThreshold", 'i', "xx"}, }; void Register_sceCtrl() diff --git a/Core/HLE/sceDeflt.cpp b/Core/HLE/sceDeflt.cpp index 3cd0d8630a..5c1f579071 100644 --- a/Core/HLE/sceDeflt.cpp +++ b/Core/HLE/sceDeflt.cpp @@ -162,18 +162,18 @@ static int sceZlibDecompress(u32 OutBuffer, int OutBufferLength, u32 InBuffer, u } const HLEFunction sceDeflt[] = { - {0x0BA3B9CC, 0, "sceGzipGetCompressedData"}, - {0x106A3552, 0, "sceGzipGetName"}, - {0x1B5B82BC, 0, "sceGzipIsValid"}, - {0x2EE39A64, 0, "sceZlibAdler32"}, - {0x44054E03, WrapI_UIUU, "sceDeflateDecompress"}, - {0x6A548477, 0, "sceZlibGetCompressedData"}, - {0x6DBCF897, WrapI_UIUU, "sceGzipDecompress"}, - {0x8AA82C92, 0, "sceGzipGetInfo"}, - {0xA9E4FB28, WrapI_UIUU, "sceZlibDecompress"}, - {0xAFE01FD3, 0, "sceZlibGetInfo"}, - {0xB767F9A0, 0, "sceGzipGetComment"}, - {0xE46EB986, 0, "sceZlibIsValid"}, + {0X0BA3B9CC, nullptr, "sceGzipGetCompressedData", '?', "" }, + {0X106A3552, nullptr, "sceGzipGetName", '?', "" }, + {0X1B5B82BC, nullptr, "sceGzipIsValid", '?', "" }, + {0X2EE39A64, nullptr, "sceZlibAdler32", '?', "" }, + {0X44054E03, &WrapI_UIUU, "sceDeflateDecompress", 'i', "xixx"}, + {0X6A548477, nullptr, "sceZlibGetCompressedData", '?', "" }, + {0X6DBCF897, &WrapI_UIUU, "sceGzipDecompress", 'i', "xixx"}, + {0X8AA82C92, nullptr, "sceGzipGetInfo", '?', "" }, + {0XA9E4FB28, &WrapI_UIUU, "sceZlibDecompress", 'i', "xixx"}, + {0XAFE01FD3, nullptr, "sceZlibGetInfo", '?', "" }, + {0XB767F9A0, nullptr, "sceGzipGetComment", '?', "" }, + {0XE46EB986, nullptr, "sceZlibIsValid", '?', "" }, }; void Register_sceDeflt() { diff --git a/Core/HLE/sceDisplay.cpp b/Core/HLE/sceDisplay.cpp index 3d8e354c9a..4563ab2232 100644 --- a/Core/HLE/sceDisplay.cpp +++ b/Core/HLE/sceDisplay.cpp @@ -1067,29 +1067,29 @@ static u32 sceDisplaySetHoldMode(u32 hMode) { } const HLEFunction sceDisplay[] = { - {0x0E20F177,WrapU_III, "sceDisplaySetMode"}, - {0x289D82FE,WrapU_UIII, "sceDisplaySetFrameBuf"}, - {0xEEDA2E54,WrapU_UUUI,"sceDisplayGetFrameBuf"}, - {0x36CDFADE,WrapU_V, "sceDisplayWaitVblank", HLE_NOT_DISPATCH_SUSPENDED}, - {0x984C27E7,WrapU_V, "sceDisplayWaitVblankStart", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x40f1469c,WrapU_I, "sceDisplayWaitVblankStartMulti"}, - {0x8EB9EC49,WrapU_V, "sceDisplayWaitVblankCB", HLE_NOT_DISPATCH_SUSPENDED}, - {0x46F186C3,WrapU_V, "sceDisplayWaitVblankStartCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x77ed8b3a,WrapU_I,"sceDisplayWaitVblankStartMultiCB"}, - {0xdba6c4c4,WrapF_V,"sceDisplayGetFramePerSec"}, - {0x773dd3a3,WrapU_V,"sceDisplayGetCurrentHcount"}, - {0x210eab3a,WrapI_V,"sceDisplayGetAccumulatedHcount"}, - {0xA83EF139,WrapI_I,"sceDisplayAdjustAccumulatedHcount"}, - {0x9C6EAAD7,WrapU_V,"sceDisplayGetVcount"}, - {0xDEA197D4,WrapU_UUU,"sceDisplayGetMode"}, - {0x7ED59BC4,WrapU_U,"sceDisplaySetHoldMode"}, - {0xA544C486,WrapU_U,"sceDisplaySetResumeMode"}, - {0xBF79F646,WrapU_U,"sceDisplayGetResumeMode"}, - {0xB4F378FA,WrapU_V,"sceDisplayIsForeground"}, - {0x31C4BAA8,WrapU_U,"sceDisplayGetBrightness"}, - {0x9E3C6DC6,WrapU_U,"sceDisplaySetBrightness"}, - {0x4D4E10EC,WrapU_V,"sceDisplayIsVblank"}, - {0x21038913,WrapU_V,"sceDisplayIsVsync"}, + {0X0E20F177, &WrapU_III, "sceDisplaySetMode", 'x', "iii" }, + {0X289D82FE, &WrapU_UIII, "sceDisplaySetFrameBuf", 'x', "xiii"}, + {0XEEDA2E54, &WrapU_UUUI, "sceDisplayGetFrameBuf", 'x', "xxxi"}, + {0X36CDFADE, &WrapU_V, "sceDisplayWaitVblank", 'x', "", HLE_NOT_DISPATCH_SUSPENDED }, + {0X984C27E7, &WrapU_V, "sceDisplayWaitVblankStart", 'x', "", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X40F1469C, &WrapU_I, "sceDisplayWaitVblankStartMulti", 'x', "i" }, + {0X8EB9EC49, &WrapU_V, "sceDisplayWaitVblankCB", 'x', "", HLE_NOT_DISPATCH_SUSPENDED }, + {0X46F186C3, &WrapU_V, "sceDisplayWaitVblankStartCB", 'x', "", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X77ED8B3A, &WrapU_I, "sceDisplayWaitVblankStartMultiCB", 'x', "i" }, + {0XDBA6C4C4, &WrapF_V, "sceDisplayGetFramePerSec", 'f', "" }, + {0X773DD3A3, &WrapU_V, "sceDisplayGetCurrentHcount", 'x', "" }, + {0X210EAB3A, &WrapI_V, "sceDisplayGetAccumulatedHcount", 'i', "" }, + {0XA83EF139, &WrapI_I, "sceDisplayAdjustAccumulatedHcount", 'i', "i" }, + {0X9C6EAAD7, &WrapU_V, "sceDisplayGetVcount", 'x', "" }, + {0XDEA197D4, &WrapU_UUU, "sceDisplayGetMode", 'x', "xxx" }, + {0X7ED59BC4, &WrapU_U, "sceDisplaySetHoldMode", 'x', "x" }, + {0XA544C486, &WrapU_U, "sceDisplaySetResumeMode", 'x', "x" }, + {0XBF79F646, &WrapU_U, "sceDisplayGetResumeMode", 'x', "x" }, + {0XB4F378FA, &WrapU_V, "sceDisplayIsForeground", 'x', "" }, + {0X31C4BAA8, &WrapU_U, "sceDisplayGetBrightness", 'x', "x" }, + {0X9E3C6DC6, &WrapU_U, "sceDisplaySetBrightness", 'x', "x" }, + {0X4D4E10EC, &WrapU_V, "sceDisplayIsVblank", 'x', "" }, + {0X21038913, &WrapU_V, "sceDisplayIsVsync", 'x', "" }, }; void Register_sceDisplay() { diff --git a/Core/HLE/sceDmac.cpp b/Core/HLE/sceDmac.cpp index 42aa35cb6e..d3170a8ba4 100644 --- a/Core/HLE/sceDmac.cpp +++ b/Core/HLE/sceDmac.cpp @@ -118,8 +118,8 @@ static u32 sceDmacTryMemcpy(u32 dst, u32 src, u32 size) { } const HLEFunction sceDmac[] = { - {0x617f3fe6, &WrapU_UUU, "sceDmacMemcpy"}, - {0xd97f94d8, &WrapU_UUU, "sceDmacTryMemcpy"}, + {0X617F3FE6, &WrapU_UUU, "sceDmacMemcpy", 'x', "xxx"}, + {0XD97F94D8, &WrapU_UUU, "sceDmacTryMemcpy", 'x', "xxx"}, }; void Register_sceDmac() { diff --git a/Core/HLE/sceFont.cpp b/Core/HLE/sceFont.cpp index 8a70c09ce8..3216f0bea8 100644 --- a/Core/HLE/sceFont.cpp +++ b/Core/HLE/sceFont.cpp @@ -1357,34 +1357,34 @@ static int sceFontGetShadowGlyphImage_Clip(u32 fontHandle, u32 charCode, u32 gly // sceLibFont is a user level library so it can touch the stack. Some games appear to rely a bit of stack // being wiped - although in reality, it won't be wiped with just zeroes.. const HLEFunction sceLibFont[] = { - { 0x67f17ed7, WrapU_UU, "sceFontNewLib", HLE_CLEAR_STACK_BYTES, 0x5A0 }, - { 0x574b6fbc, WrapI_U, "sceFontDoneLib", HLE_CLEAR_STACK_BYTES, 0x2C }, - { 0x48293280, WrapI_UFF, "sceFontSetResolution" }, - { 0x27f6e642, WrapI_UU, "sceFontGetNumFontList" }, - { 0xbc75d85b, WrapI_UUI, "sceFontGetFontList", HLE_CLEAR_STACK_BYTES, 0x31C }, - { 0x099ef33c, WrapI_UUU, "sceFontFindOptimumFont", HLE_CLEAR_STACK_BYTES, 0xF0 }, - { 0x681e61a7, WrapI_UUU, "sceFontFindFont", HLE_CLEAR_STACK_BYTES, 0x40 }, - { 0x2f67356a, WrapI_V, "sceFontCalcMemorySize" }, - { 0x5333322d, WrapI_UUU, "sceFontGetFontInfoByIndexNumber", HLE_CLEAR_STACK_BYTES, 0x20 }, - { 0xa834319d, WrapU_UUUU, "sceFontOpen", HLE_CLEAR_STACK_BYTES, 0x460 }, - { 0x57fcb733, WrapU_UCUU, "sceFontOpenUserFile" }, - { 0xbb8e7fe6, WrapU_UUUU, "sceFontOpenUserMemory", HLE_CLEAR_STACK_BYTES, 0x440 /*from JPCSP*/ }, - { 0x3aea8cb6, WrapI_U, "sceFontClose", HLE_CLEAR_STACK_BYTES, 0x54 }, - { 0x0da7535e, WrapI_UU, "sceFontGetFontInfo" }, - { 0xdcc80c2f, WrapI_UUU, "sceFontGetCharInfo", HLE_CLEAR_STACK_BYTES, 0x110 }, - { 0xaa3de7b5, WrapI_UUU, "sceFontGetShadowInfo", HLE_CLEAR_STACK_BYTES, 0x150 }, - { 0x5c3e4a9e, WrapI_UUU, "sceFontGetCharImageRect", HLE_CLEAR_STACK_BYTES, 0x120 }, - { 0x48b06520, WrapI_UUU, "sceFontGetShadowImageRect", HLE_CLEAR_STACK_BYTES, 0x150 }, - { 0x980f4895, WrapI_UUU, "sceFontGetCharGlyphImage", HLE_CLEAR_STACK_BYTES, 0x120 }, - { 0xca1e6945, WrapI_UUUIIII, "sceFontGetCharGlyphImage_Clip", HLE_CLEAR_STACK_BYTES, 0x130 }, - { 0x74b21701, WrapF_IFU, "sceFontPixelToPointH", HLE_CLEAR_STACK_BYTES, 0x10 }, - { 0xf8f0752e, WrapF_IFU, "sceFontPixelToPointV", HLE_CLEAR_STACK_BYTES, 0x10 }, - { 0x472694cd, WrapF_IFU, "sceFontPointToPixelH" }, - { 0x3c4b7e82, WrapF_IFU, "sceFontPointToPixelV" }, - { 0xee232411, WrapI_UU, "sceFontSetAltCharacterCode" }, - { 0x568be516, WrapI_UUU, "sceFontGetShadowGlyphImage", HLE_CLEAR_STACK_BYTES, 0x160 }, - { 0x5dcf6858, WrapI_UUUIIII, "sceFontGetShadowGlyphImage_Clip", HLE_CLEAR_STACK_BYTES, 0x170 }, - { 0x02d7f94b, WrapI_U, "sceFontFlush" }, + {0X67F17ED7, &WrapU_UU, "sceFontNewLib", 'x', "xx", HLE_CLEAR_STACK_BYTES, 0x5A0 }, + {0X574B6FBC, &WrapI_U, "sceFontDoneLib", 'i', "x", HLE_CLEAR_STACK_BYTES, 0x2C }, + {0X48293280, &WrapI_UFF, "sceFontSetResolution", 'i', "xff" }, + {0X27F6E642, &WrapI_UU, "sceFontGetNumFontList", 'i', "xx" }, + {0XBC75D85B, &WrapI_UUI, "sceFontGetFontList", 'i', "xxi", HLE_CLEAR_STACK_BYTES, 0x31C }, + {0X099EF33C, &WrapI_UUU, "sceFontFindOptimumFont", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0xF0 }, + {0X681E61A7, &WrapI_UUU, "sceFontFindFont", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x40 }, + {0X2F67356A, &WrapI_V, "sceFontCalcMemorySize", 'i', "" }, + {0X5333322D, &WrapI_UUU, "sceFontGetFontInfoByIndexNumber", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x20 }, + {0XA834319D, &WrapU_UUUU, "sceFontOpen", 'x', "xxxx", HLE_CLEAR_STACK_BYTES, 0x460 }, + {0X57FCB733, &WrapU_UCUU, "sceFontOpenUserFile", 'x', "xsxx" }, + {0XBB8E7FE6, &WrapU_UUUU, "sceFontOpenUserMemory", 'x', "xxxx", HLE_CLEAR_STACK_BYTES, 0x440 /*from JPCSP*/ }, + {0X3AEA8CB6, &WrapI_U, "sceFontClose", 'i', "x", HLE_CLEAR_STACK_BYTES, 0x54 }, + {0X0DA7535E, &WrapI_UU, "sceFontGetFontInfo", 'i', "xx" }, + {0XDCC80C2F, &WrapI_UUU, "sceFontGetCharInfo", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x110 }, + {0XAA3DE7B5, &WrapI_UUU, "sceFontGetShadowInfo", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x150 }, + {0X5C3E4A9E, &WrapI_UUU, "sceFontGetCharImageRect", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x120 }, + {0X48B06520, &WrapI_UUU, "sceFontGetShadowImageRect", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x150 }, + {0X980F4895, &WrapI_UUU, "sceFontGetCharGlyphImage", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x120 }, + {0XCA1E6945, &WrapI_UUUIIII, "sceFontGetCharGlyphImage_Clip", 'i', "xxxiiii", HLE_CLEAR_STACK_BYTES, 0x130 }, + {0X74B21701, &WrapF_IFU, "sceFontPixelToPointH", 'f', "ifx", HLE_CLEAR_STACK_BYTES, 0x10 }, + {0XF8F0752E, &WrapF_IFU, "sceFontPixelToPointV", 'f', "ifx", HLE_CLEAR_STACK_BYTES, 0x10 }, + {0X472694CD, &WrapF_IFU, "sceFontPointToPixelH", 'f', "ifx" }, + {0X3C4B7E82, &WrapF_IFU, "sceFontPointToPixelV", 'f', "ifx" }, + {0XEE232411, &WrapI_UU, "sceFontSetAltCharacterCode", 'i', "xx" }, + {0X568BE516, &WrapI_UUU, "sceFontGetShadowGlyphImage", 'i', "xxx", HLE_CLEAR_STACK_BYTES, 0x160 }, + {0X5DCF6858, &WrapI_UUUIIII, "sceFontGetShadowGlyphImage_Clip", 'i', "xxxiiii", HLE_CLEAR_STACK_BYTES, 0x170 }, + {0X02D7F94B, &WrapI_U, "sceFontFlush", 'i', "x" }, }; void Register_sceFont() { diff --git a/Core/HLE/sceG729.cpp b/Core/HLE/sceG729.cpp index 264bcc6efb..9030eca9ba 100644 --- a/Core/HLE/sceG729.cpp +++ b/Core/HLE/sceG729.cpp @@ -20,18 +20,18 @@ const HLEFunction sceG729[] = { - { 0x13F1028A, 0, "sceG729DecodeExit" }, - { 0x17C11696, 0, "sceG729DecodeInitResource" }, - { 0x3489D1F3, 0, "sceG729DecodeCore" }, - { 0x55E14F75, 0, "sceG729DecodeInit" }, - { 0x5A409D1B, 0, "sceG729EncodeExit" }, - { 0x74804D93, 0, "sceG729DecodeReset" }, - { 0x890B86AE, 0, "sceG729DecodeTermResource" }, - { 0x8C87A2CA, 0, "sceG729EncodeReset" }, - { 0x94714D50, 0, "sceG729EncodeTermResource" }, - { 0xAA1E5462, 0, "sceG729EncodeInitResource" }, - { 0xCFCD367C, 0, "sceG729EncodeInit" }, - { 0xDB7259D5, 0, "sceG729EncodeCore" }, + {0X13F1028A, nullptr, "sceG729DecodeExit", '?', ""}, + {0X17C11696, nullptr, "sceG729DecodeInitResource", '?', ""}, + {0X3489D1F3, nullptr, "sceG729DecodeCore", '?', ""}, + {0X55E14F75, nullptr, "sceG729DecodeInit", '?', ""}, + {0X5A409D1B, nullptr, "sceG729EncodeExit", '?', ""}, + {0X74804D93, nullptr, "sceG729DecodeReset", '?', ""}, + {0X890B86AE, nullptr, "sceG729DecodeTermResource", '?', ""}, + {0X8C87A2CA, nullptr, "sceG729EncodeReset", '?', ""}, + {0X94714D50, nullptr, "sceG729EncodeTermResource", '?', ""}, + {0XAA1E5462, nullptr, "sceG729EncodeInitResource", '?', ""}, + {0XCFCD367C, nullptr, "sceG729EncodeInit", '?', ""}, + {0XDB7259D5, nullptr, "sceG729EncodeCore", '?', ""}, }; void Register_sceG729() diff --git a/Core/HLE/sceGameUpdate.cpp b/Core/HLE/sceGameUpdate.cpp index 8084e63496..d4c0775c23 100644 --- a/Core/HLE/sceGameUpdate.cpp +++ b/Core/HLE/sceGameUpdate.cpp @@ -45,10 +45,10 @@ static u32 sceGameUpdateAbort() const HLEFunction sceGameUpdate[] = { - {0xCBE69FB3, WrapU_V, "sceGameUpdateInit"}, - {0xBB4B68DE, WrapU_V, "sceGameUpdateTerm"}, - {0x596AD78C, WrapU_V, "sceGameUpdateRun"}, - {0x5F5D98A6, WrapU_V, "sceGameUpdateAbort"}, + {0XCBE69FB3, &WrapU_V, "sceGameUpdateInit", 'x', ""}, + {0XBB4B68DE, &WrapU_V, "sceGameUpdateTerm", 'x', ""}, + {0X596AD78C, &WrapU_V, "sceGameUpdateRun", 'x', ""}, + {0X5F5D98A6, &WrapU_V, "sceGameUpdateAbort", 'x', ""}, }; void Register_sceGameUpdate() diff --git a/Core/HLE/sceGe.cpp b/Core/HLE/sceGe.cpp index 65857854ca..e20b8b7d0e 100644 --- a/Core/HLE/sceGe.cpp +++ b/Core/HLE/sceGe.cpp @@ -717,24 +717,24 @@ static u32 sceGeEdramSetAddrTranslation(int new_size) { const HLEFunction sceGe_user[] = { - {0xE47E40E4, WrapU_V, "sceGeEdramGetAddr"}, - {0xAB49E76A, WrapU_UUIU, "sceGeListEnQueue"}, - {0x1C0D95A6, WrapU_UUIU, "sceGeListEnQueueHead"}, - {0xE0D68148, WrapI_UU, "sceGeListUpdateStallAddr"}, - {0x03444EB4, WrapI_UU, "sceGeListSync"}, - {0xB287BD61, WrapU_U, "sceGeDrawSync"}, - {0xB448EC0D, WrapI_UU, "sceGeBreak"}, - {0x4C06E472, WrapI_V, "sceGeContinue"}, - {0xA4FC06A4, WrapU_U, "sceGeSetCallback"}, - {0x05DB22CE, WrapI_U, "sceGeUnsetCallback"}, - {0x1F6752AD, WrapU_V, "sceGeEdramGetSize"}, - {0xB77905EA, WrapU_I, "sceGeEdramSetAddrTranslation"}, - {0xDC93CFEF, WrapU_I, "sceGeGetCmd"}, - {0x57C8945B, WrapI_IU, "sceGeGetMtx"}, - {0x438A385A, WrapU_U, "sceGeSaveContext"}, - {0x0BF608FB, WrapU_U, "sceGeRestoreContext"}, - {0x5FB86AB0, WrapI_U, "sceGeListDeQueue"}, - {0xE66CB92E, WrapI_IU, "sceGeGetStack"}, + {0XE47E40E4, &WrapU_V, "sceGeEdramGetAddr", 'x', "" }, + {0XAB49E76A, &WrapU_UUIU, "sceGeListEnQueue", 'x', "xxix"}, + {0X1C0D95A6, &WrapU_UUIU, "sceGeListEnQueueHead", 'x', "xxix"}, + {0XE0D68148, &WrapI_UU, "sceGeListUpdateStallAddr", 'i', "xx" }, + {0X03444EB4, &WrapI_UU, "sceGeListSync", 'i', "xx" }, + {0XB287BD61, &WrapU_U, "sceGeDrawSync", 'x', "x" }, + {0XB448EC0D, &WrapI_UU, "sceGeBreak", 'i', "xx" }, + {0X4C06E472, &WrapI_V, "sceGeContinue", 'i', "" }, + {0XA4FC06A4, &WrapU_U, "sceGeSetCallback", 'x', "x" }, + {0X05DB22CE, &WrapI_U, "sceGeUnsetCallback", 'i', "x" }, + {0X1F6752AD, &WrapU_V, "sceGeEdramGetSize", 'x', "" }, + {0XB77905EA, &WrapU_I, "sceGeEdramSetAddrTranslation", 'x', "i" }, + {0XDC93CFEF, &WrapU_I, "sceGeGetCmd", 'x', "i" }, + {0X57C8945B, &WrapI_IU, "sceGeGetMtx", 'i', "ix" }, + {0X438A385A, &WrapU_U, "sceGeSaveContext", 'x', "x" }, + {0X0BF608FB, &WrapU_U, "sceGeRestoreContext", 'x', "x" }, + {0X5FB86AB0, &WrapI_U, "sceGeListDeQueue", 'i', "x" }, + {0XE66CB92E, &WrapI_IU, "sceGeGetStack", 'i', "ix" }, }; void Register_sceGe_user() diff --git a/Core/HLE/sceHeap.cpp b/Core/HLE/sceHeap.cpp index 54f99d5ab8..2667645c3e 100644 --- a/Core/HLE/sceHeap.cpp +++ b/Core/HLE/sceHeap.cpp @@ -225,16 +225,16 @@ static u32 sceHeapAllocHeapMemory(u32 heapAddr, u32 memSize) { static const HLEFunction sceHeap[] = { - {0x0E875980,WrapI_UUI,"sceHeapReallocHeapMemory"}, - {0x1C84B58D,WrapI_UUIU,"sceHeapReallocHeapMemoryWithOption"}, - {0x2ABADC63,WrapI_UU,"sceHeapFreeHeapMemory"}, - {0x2A0C2009,WrapI_UU,"sceHeapGetMallinfo"}, - {0x2B7299D8,WrapU_UUU,"sceHeapAllocHeapMemoryWithOption"}, - {0x4929B40D,WrapI_U,"sceHeapGetTotalFreeSize"}, - {0x7012BBDD,WrapI_UU,"sceHeapIsAllocatedHeapMemory"}, - {0x70210B73,WrapI_U,"sceHeapDeleteHeap"}, - {0x7DE281C2,WrapI_CUIU,"sceHeapCreateHeap"}, - {0xA8E102A0,WrapU_UU,"sceHeapAllocHeapMemory"}, + {0X0E875980, &WrapI_UUI, "sceHeapReallocHeapMemory", 'i', "xxi" }, + {0X1C84B58D, &WrapI_UUIU, "sceHeapReallocHeapMemoryWithOption", 'i', "xxix"}, + {0X2ABADC63, &WrapI_UU, "sceHeapFreeHeapMemory", 'i', "xx" }, + {0X2A0C2009, &WrapI_UU, "sceHeapGetMallinfo", 'i', "xx" }, + {0X2B7299D8, &WrapU_UUU, "sceHeapAllocHeapMemoryWithOption", 'x', "xxx" }, + {0X4929B40D, &WrapI_U, "sceHeapGetTotalFreeSize", 'i', "x" }, + {0X7012BBDD, &WrapI_UU, "sceHeapIsAllocatedHeapMemory", 'i', "xx" }, + {0X70210B73, &WrapI_U, "sceHeapDeleteHeap", 'i', "x" }, + {0X7DE281C2, &WrapI_CUIU, "sceHeapCreateHeap", 'i', "sxix"}, + {0XA8E102A0, &WrapU_UU, "sceHeapAllocHeapMemory", 'x', "xx" }, }; void Register_sceHeap() diff --git a/Core/HLE/sceHprm.cpp b/Core/HLE/sceHprm.cpp index 2093c4c769..75cca09aec 100644 --- a/Core/HLE/sceHprm.cpp +++ b/Core/HLE/sceHprm.cpp @@ -56,15 +56,15 @@ static u32 sceHprmReadLatch(u32 latchAddr) { const HLEFunction sceHprm[] = { - {0x089fdfa4, 0, "sceHprm_089fdfa4"}, - {0x1910B327, &WrapU_U, "sceHprmPeekCurrentKey"}, - {0x208DB1BD, WrapU_V, "sceHprmIsRemoteExist"}, - {0x7E69EDA4, WrapU_V, "sceHprmIsHeadphoneExist"}, - {0x219C58F1, WrapU_V, "sceHprmIsMicrophoneExist"}, - {0xC7154136, 0, "sceHprmRegisterCallback"}, - {0x444ED0B7, 0, "sceHprmUnregitserCallback"}, // Typo. - {0x2BCEC83E, &WrapU_U, "sceHprmPeekLatch"}, - {0x40D2F9F0, &WrapU_U, "sceHprmReadLatch"}, + {0X089FDFA4, nullptr, "sceHprm_089fdfa4", '?', "" }, + {0X1910B327, &WrapU_U, "sceHprmPeekCurrentKey", 'x', "x"}, + {0X208DB1BD, &WrapU_V, "sceHprmIsRemoteExist", 'x', "" }, + {0X7E69EDA4, &WrapU_V, "sceHprmIsHeadphoneExist", 'x', "" }, + {0X219C58F1, &WrapU_V, "sceHprmIsMicrophoneExist", 'x', "" }, + {0XC7154136, nullptr, "sceHprmRegisterCallback", '?', "" }, + {0X444ED0B7, nullptr, "sceHprmUnregitserCallback", '?', "" }, // Typo. + {0X2BCEC83E, &WrapU_U, "sceHprmPeekLatch", 'x', "x"}, + {0X40D2F9F0, &WrapU_U, "sceHprmReadLatch", 'x', "x"}, }; void Register_sceHprm() diff --git a/Core/HLE/sceHttp.cpp b/Core/HLE/sceHttp.cpp index ba9fafe0df..e592ef6178 100644 --- a/Core/HLE/sceHttp.cpp +++ b/Core/HLE/sceHttp.cpp @@ -278,60 +278,60 @@ static int sceHttpGetContentLength(int requestID, u64 contentLengthPtr) { 0x71eef62d sceSircsSend */ const HLEFunction sceHttp[] = { - {0xab1abe07,WrapI_I,"sceHttpInit"}, - {0xd1c8945e,WrapI_V,"sceHttpEnd"}, - {0xa6800c34,WrapI_I,"sceHttpInitCache"}, - {0x78b54c09,WrapI_V,"sceHttpEndCache"}, - {0x59e6d16f,WrapI_I,"sceHttpEnableCache"}, - {0xccbd167a,WrapI_I,"sceHttpDisableCache"}, - {0xd70d4847,WrapU_UUUUUU,"sceHttpGetProxy"}, - {0x4cc7d78f,WrapI_IU,"sceHttpGetStatusCode"}, - {0xedeeb999,WrapI_IUU,"sceHttpReadData"}, - {0xbb70706f,WrapI_IUU,"sceHttpSendRequest"}, - {0xa5512e01,WrapI_I,"sceHttpDeleteRequest"}, - {0x15540184,WrapI_IC,"sceHttpDeleteHeader"}, - {0x5152773b,WrapI_I,"sceHttpDeleteConnection"}, - {0x8acd1f73,WrapI_IU,"sceHttpSetConnectTimeOut"}, - {0x9988172d,WrapI_IU,"sceHttpSetSendTimeOut"}, - {0xf0f46c62,WrapU_UUUUU,"sceHttpSetProxy"}, - {0x0dafa58f,WrapI_I,"sceHttpEnableCookie"}, - {0x78a0d3ec,WrapI_I,"sceHttpEnableKeepAlive"}, - {0x0b12abfb,WrapI_I,"sceHttpDisableCookie"}, - {0xc7ef2559,WrapI_I,"sceHttpDisableKeepAlive"}, - {0xe4d21302,WrapI_IIII,"sceHttpsInit"}, - {0xf9d8eb63,WrapI_V,"sceHttpsEnd"}, - {0x47347b50,WrapI_IICU64,"sceHttpCreateRequest"}, - {0x8eefd953,WrapI_ICCUI,"sceHttpCreateConnection"}, - {0xd081ec8f,WrapI_IU,"sceHttpGetNetworkErrno"}, - {0x3eaba285,WrapI_ICCI,"sceHttpAddExtraHeader"}, - {0xc10b6bd9,WrapI_I,"sceHttpAbortRequest"}, - {0xfcf8c055,WrapI_I,"sceHttpDeleteTemplate"}, - {0xf49934f6,WrapI_UUU,"sceHttpSetMallocFunction"}, - {0x03D9526F,&WrapI_II, "sceHttpSetResolveRetry"}, - {0x47940436,WrapI_IU,"sceHttpSetResolveTimeOut"}, - {0x2a6c3296,WrapI_IU,"sceHttpSetAuthInfoCB"}, - {0x0809c831,WrapI_I,"sceHttpEnableRedirect"}, - {0x9fc5f10d,WrapI_I,"sceHttpEnableAuth"}, - {0x1a0ebb69,WrapI_I,"sceHttpDisableRedirect"}, - {0xae948fee,WrapI_I,"sceHttpDisableAuth"}, - {0x76d1363b,WrapI_V,"sceHttpSaveSystemCookie"}, - {0x87797bdd,WrapI_II,"sceHttpsLoadDefaultCert"}, - {0xf1657b22,WrapI_V,"sceHttpLoadSystemCookie"}, - {0x9B1F1F36,WrapI_CII,"sceHttpCreateTemplate"}, - {0xB509B09E,WrapI_IICU64,"sceHttpCreateRequestWithURL"}, - {0xCDF8ECB9,WrapI_ICI,"sceHttpCreateConnectionWithURL"}, - {0x1F0FC3E3,WrapI_IU,"sceHttpSetRecvTimeOut"}, - {0xDB266CCF,WrapI_IUU,"sceHttpGetAllHeader"}, - {0x0282A3BD,WrapI_IU64,"sceHttpGetContentLength"}, - {0x7774bf4c,0,"sceHttpAddCookie"}, - {0x68AB0F86,0,"sceHttpsInitWithPath"}, - {0xB3FAF831,0,"sceHttpsDisableOption"}, - {0x2255551E,0,"sceHttpGetNetworkPspError"}, - {0xAB1540D5,0,"sceHttpsGetSslError"}, - {0xA4496DE5,0,"sceHttpSetRedirectCallback"}, - {0x267618f4,0,"sceHttpSetAuthInfoCallback"}, - {0x569a1481,0,"sceHttpsSetSslCallback"}, - {0xbac31bf1,0,"sceHttpsEnableOption"}, + {0XAB1ABE07, &WrapI_I, "sceHttpInit", 'i', "i" }, + {0XD1C8945E, &WrapI_V, "sceHttpEnd", 'i', "" }, + {0XA6800C34, &WrapI_I, "sceHttpInitCache", 'i', "i" }, + {0X78B54C09, &WrapI_V, "sceHttpEndCache", 'i', "" }, + {0X59E6D16F, &WrapI_I, "sceHttpEnableCache", 'i', "i" }, + {0XCCBD167A, &WrapI_I, "sceHttpDisableCache", 'i', "i" }, + {0XD70D4847, &WrapU_UUUUUU, "sceHttpGetProxy", 'x', "xxxxxx"}, + {0X4CC7D78F, &WrapI_IU, "sceHttpGetStatusCode", 'i', "ix" }, + {0XEDEEB999, &WrapI_IUU, "sceHttpReadData", 'i', "ixx" }, + {0XBB70706F, &WrapI_IUU, "sceHttpSendRequest", 'i', "ixx" }, + {0XA5512E01, &WrapI_I, "sceHttpDeleteRequest", 'i', "i" }, + {0X15540184, &WrapI_IC, "sceHttpDeleteHeader", 'i', "is" }, + {0X5152773B, &WrapI_I, "sceHttpDeleteConnection", 'i', "i" }, + {0X8ACD1F73, &WrapI_IU, "sceHttpSetConnectTimeOut", 'i', "ix" }, + {0X9988172D, &WrapI_IU, "sceHttpSetSendTimeOut", 'i', "ix" }, + {0XF0F46C62, &WrapU_UUUUU, "sceHttpSetProxy", 'x', "xxxxx" }, + {0X0DAFA58F, &WrapI_I, "sceHttpEnableCookie", 'i', "i" }, + {0X78A0D3EC, &WrapI_I, "sceHttpEnableKeepAlive", 'i', "i" }, + {0X0B12ABFB, &WrapI_I, "sceHttpDisableCookie", 'i', "i" }, + {0XC7EF2559, &WrapI_I, "sceHttpDisableKeepAlive", 'i', "i" }, + {0XE4D21302, &WrapI_IIII, "sceHttpsInit", 'i', "iiii" }, + {0XF9D8EB63, &WrapI_V, "sceHttpsEnd", 'i', "" }, + {0X47347B50, &WrapI_IICU64, "sceHttpCreateRequest", 'i', "iisX" }, + {0X8EEFD953, &WrapI_ICCUI, "sceHttpCreateConnection", 'i', "issxi" }, + {0XD081EC8F, &WrapI_IU, "sceHttpGetNetworkErrno", 'i', "ix" }, + {0X3EABA285, &WrapI_ICCI, "sceHttpAddExtraHeader", 'i', "issi" }, + {0XC10B6BD9, &WrapI_I, "sceHttpAbortRequest", 'i', "i" }, + {0XFCF8C055, &WrapI_I, "sceHttpDeleteTemplate", 'i', "i" }, + {0XF49934F6, &WrapI_UUU, "sceHttpSetMallocFunction", 'i', "xxx" }, + {0X03D9526F, &WrapI_II, "sceHttpSetResolveRetry", 'i', "ii" }, + {0X47940436, &WrapI_IU, "sceHttpSetResolveTimeOut", 'i', "ix" }, + {0X2A6C3296, &WrapI_IU, "sceHttpSetAuthInfoCB", 'i', "ix" }, + {0X0809C831, &WrapI_I, "sceHttpEnableRedirect", 'i', "i" }, + {0X9FC5F10D, &WrapI_I, "sceHttpEnableAuth", 'i', "i" }, + {0X1A0EBB69, &WrapI_I, "sceHttpDisableRedirect", 'i', "i" }, + {0XAE948FEE, &WrapI_I, "sceHttpDisableAuth", 'i', "i" }, + {0X76D1363B, &WrapI_V, "sceHttpSaveSystemCookie", 'i', "" }, + {0X87797BDD, &WrapI_II, "sceHttpsLoadDefaultCert", 'i', "ii" }, + {0XF1657B22, &WrapI_V, "sceHttpLoadSystemCookie", 'i', "" }, + {0X9B1F1F36, &WrapI_CII, "sceHttpCreateTemplate", 'i', "sii" }, + {0XB509B09E, &WrapI_IICU64, "sceHttpCreateRequestWithURL", 'i', "iisX" }, + {0XCDF8ECB9, &WrapI_ICI, "sceHttpCreateConnectionWithURL", 'i', "isi" }, + {0X1F0FC3E3, &WrapI_IU, "sceHttpSetRecvTimeOut", 'i', "ix" }, + {0XDB266CCF, &WrapI_IUU, "sceHttpGetAllHeader", 'i', "ixx" }, + {0X0282A3BD, &WrapI_IU64, "sceHttpGetContentLength", 'i', "iX" }, + {0X7774BF4C, nullptr, "sceHttpAddCookie", '?', "" }, + {0X68AB0F86, nullptr, "sceHttpsInitWithPath", '?', "" }, + {0XB3FAF831, nullptr, "sceHttpsDisableOption", '?', "" }, + {0X2255551E, nullptr, "sceHttpGetNetworkPspError", '?', "" }, + {0XAB1540D5, nullptr, "sceHttpsGetSslError", '?', "" }, + {0XA4496DE5, nullptr, "sceHttpSetRedirectCallback", '?', "" }, + {0X267618F4, nullptr, "sceHttpSetAuthInfoCallback", '?', "" }, + {0X569A1481, nullptr, "sceHttpsSetSslCallback", '?', "" }, + {0XBAC31BF1, nullptr, "sceHttpsEnableOption", '?', "" }, }; void Register_sceHttp() diff --git a/Core/HLE/sceImpose.cpp b/Core/HLE/sceImpose.cpp index 0c98f94130..9ef9af254a 100644 --- a/Core/HLE/sceImpose.cpp +++ b/Core/HLE/sceImpose.cpp @@ -109,21 +109,21 @@ static u32 sceImposeGetBacklightOffTime() { //OSD stuff? home button? const HLEFunction sceImpose[] = { - {0x36aa6e91, WrapU_UU, "sceImposeSetLanguageMode"}, // Seen - {0x381bd9e7, 0, "sceImposeHomeButton"}, - {0x0F341BE4, 0, "sceImposeGetHomePopup"}, - {0x5595A71A, 0, "sceImposeSetHomePopup"}, - {0x24fd7bcf, WrapU_UU, "sceImposeGetLanguageMode"}, - {0x8c943191, WrapU_UU, "sceImposeGetBatteryIconStatus"}, - {0x72189C48, WrapU_I, "sceImposeSetUMDPopup"}, - {0xE0887BC8, WrapU_V, "sceImposeGetUMDPopup"}, - {0x8F6E3518, WrapU_V, "sceImposeGetBacklightOffTime"}, - {0x967F6D4A, WrapU_I, "sceImposeSetBacklightOffTime"}, - {0xfcd44963, 0, "sceImpose_FCD44963"}, - {0xa9884b00, 0, "sceImpose_A9884B00"}, - {0xbb3f5dec, 0, "sceImpose_BB3F5DEC"}, - {0x9ba61b49, 0, "sceImpose_9BA61B49"}, - {0xff1a2f07, 0, "sceImpose_FF1A2F07"}, + {0X36AA6E91, &WrapU_UU, "sceImposeSetLanguageMode", 'x', "xx"}, // Seen + {0X381BD9E7, nullptr, "sceImposeHomeButton", '?', "" }, + {0X0F341BE4, nullptr, "sceImposeGetHomePopup", '?', "" }, + {0X5595A71A, nullptr, "sceImposeSetHomePopup", '?', "" }, + {0X24FD7BCF, &WrapU_UU, "sceImposeGetLanguageMode", 'x', "xx"}, + {0X8C943191, &WrapU_UU, "sceImposeGetBatteryIconStatus", 'x', "xx"}, + {0X72189C48, &WrapU_I, "sceImposeSetUMDPopup", 'x', "i" }, + {0XE0887BC8, &WrapU_V, "sceImposeGetUMDPopup", 'x', "" }, + {0X8F6E3518, &WrapU_V, "sceImposeGetBacklightOffTime", 'x', "" }, + {0X967F6D4A, &WrapU_I, "sceImposeSetBacklightOffTime", 'x', "i" }, + {0XFCD44963, nullptr, "sceImpose_FCD44963", '?', "" }, + {0XA9884B00, nullptr, "sceImpose_A9884B00", '?', "" }, + {0XBB3F5DEC, nullptr, "sceImpose_BB3F5DEC", '?', "" }, + {0X9BA61B49, nullptr, "sceImpose_9BA61B49", '?', "" }, + {0XFF1A2F07, nullptr, "sceImpose_FF1A2F07", '?', "" }, }; void Register_sceImpose() diff --git a/Core/HLE/sceIo.cpp b/Core/HLE/sceIo.cpp index 9d234ae407..61c0a9636f 100644 --- a/Core/HLE/sceIo.cpp +++ b/Core/HLE/sceIo.cpp @@ -2383,43 +2383,43 @@ KernelObject *__KernelDirListingObject() { } const HLEFunction IoFileMgrForUser[] = { - { 0xb29ddf9c, &WrapU_C, "sceIoDopen" }, - { 0xe3eb004c, &WrapU_IU, "sceIoDread" }, - { 0xeb092469, &WrapU_I, "sceIoDclose" }, - { 0xe95a012b, &WrapU_UUUUUU, "sceIoIoctlAsync" }, - { 0x63632449, &WrapU_UUUUUU, "sceIoIoctl" }, - { 0xace946e8, &WrapU_CU, "sceIoGetstat" }, - { 0xb8a740f4, &WrapU_CUU, "sceIoChstat" }, - { 0x55f4717d, &WrapU_C, "sceIoChdir" }, - { 0x08bd7374, &WrapU_I, "sceIoGetDevType" }, - { 0xB2A628C1, &WrapU_UUUIUI, "sceIoAssign" }, - { 0xe8bc6571, &WrapU_I, "sceIoCancel" }, - { 0xb293727f, &WrapI_II, "sceIoChangeAsyncPriority" }, - { 0x810C4BC3, &WrapU_I, "sceIoClose" }, //(int fd); - { 0xff5940b6, &WrapI_I, "sceIoCloseAsync" }, - { 0x54F5FB11, &WrapU_CIUIUI, "sceIoDevctl" }, //(const char *name int cmd, void *arg, size_t arglen, void *buf, size_t *buflen); - { 0xcb05f8d6, &WrapU_IUU, "sceIoGetAsyncStat" }, - { 0x27EB27B8, &WrapI64_II64I, "sceIoLseek" }, //(int fd, int offset, int whence); - { 0x68963324, &WrapU_III, "sceIoLseek32" }, - { 0x1b385d8f, &WrapU_III, "sceIoLseek32Async" }, - { 0x71b19e77, &WrapU_II64I, "sceIoLseekAsync" }, - { 0x109F50BC, &WrapU_CII, "sceIoOpen" }, //(const char* file, int mode); - { 0x89AA9906, &WrapU_CII, "sceIoOpenAsync" }, - { 0x06A70004, &WrapU_CI, "sceIoMkdir" }, //(const char *dir, int mode); - { 0x3251ea56, &WrapU_IU, "sceIoPollAsync" }, - { 0x6A638D83, &WrapU_IUI, "sceIoRead" }, //(int fd, void *data, int size); - { 0xa0b5a7c2, &WrapU_IUI, "sceIoReadAsync" }, - { 0xF27A9C51, &WrapU_C, "sceIoRemove" }, //(const char *file); - { 0x779103A0, &WrapU_CC, "sceIoRename" }, //(const char *oldname, const char *newname); - { 0x1117C65F, &WrapU_C, "sceIoRmdir" }, //(const char *dir); - { 0xA12A0514, &WrapU_IUU, "sceIoSetAsyncCallback" }, - { 0xab96437f, &WrapU_CI, "sceIoSync" }, - { 0x6d08a871, &WrapU_C, "sceIoUnassign" }, - { 0x42EC03AC, &WrapU_IUI, "sceIoWrite" }, //(int fd, void *data, int size); - { 0x0facab19, &WrapU_IUI, "sceIoWriteAsync" }, - { 0x35dbd746, &WrapI_IU, "sceIoWaitAsyncCB" }, - { 0xe23eec33, &WrapI_IU, "sceIoWaitAsync" }, - { 0x5C2BE2CC, &WrapU_UIU, "sceIoGetFdList"}, + {0XB29DDF9C, &WrapU_C, "sceIoDopen", 'x', "s" }, + {0XE3EB004C, &WrapU_IU, "sceIoDread", 'x', "ix" }, + {0XEB092469, &WrapU_I, "sceIoDclose", 'x', "i" }, + {0XE95A012B, &WrapU_UUUUUU, "sceIoIoctlAsync", 'x', "xxxxxx"}, + {0X63632449, &WrapU_UUUUUU, "sceIoIoctl", 'x', "xxxxxx"}, + {0XACE946E8, &WrapU_CU, "sceIoGetstat", 'x', "sx" }, + {0XB8A740F4, &WrapU_CUU, "sceIoChstat", 'x', "sxx" }, + {0X55F4717D, &WrapU_C, "sceIoChdir", 'x', "s" }, + {0X08BD7374, &WrapU_I, "sceIoGetDevType", 'x', "i" }, + {0XB2A628C1, &WrapU_UUUIUI, "sceIoAssign", 'x', "xxxixi"}, + {0XE8BC6571, &WrapU_I, "sceIoCancel", 'x', "i" }, + {0XB293727F, &WrapI_II, "sceIoChangeAsyncPriority", 'i', "ii" }, + {0X810C4BC3, &WrapU_I, "sceIoClose", 'x', "i" }, + {0XFF5940B6, &WrapI_I, "sceIoCloseAsync", 'i', "i" }, + {0X54F5FB11, &WrapU_CIUIUI, "sceIoDevctl", 'x', "sixixi"}, + {0XCB05F8D6, &WrapU_IUU, "sceIoGetAsyncStat", 'x', "ixx" }, + {0X27EB27B8, &WrapI64_II64I, "sceIoLseek", 'I', "iIi" }, + {0X68963324, &WrapU_III, "sceIoLseek32", 'x', "iii" }, + {0X1B385D8F, &WrapU_III, "sceIoLseek32Async", 'x', "iii" }, + {0X71B19E77, &WrapU_II64I, "sceIoLseekAsync", 'x', "iIi" }, + {0X109F50BC, &WrapU_CII, "sceIoOpen", 'x', "sii" }, + {0X89AA9906, &WrapU_CII, "sceIoOpenAsync", 'x', "sii" }, + {0X06A70004, &WrapU_CI, "sceIoMkdir", 'x', "si" }, + {0X3251EA56, &WrapU_IU, "sceIoPollAsync", 'x', "ix" }, + {0X6A638D83, &WrapU_IUI, "sceIoRead", 'x', "ixi" }, + {0XA0B5A7C2, &WrapU_IUI, "sceIoReadAsync", 'x', "ixi" }, + {0XF27A9C51, &WrapU_C, "sceIoRemove", 'x', "s" }, + {0X779103A0, &WrapU_CC, "sceIoRename", 'x', "ss" }, + {0X1117C65F, &WrapU_C, "sceIoRmdir", 'x', "s" }, + {0XA12A0514, &WrapU_IUU, "sceIoSetAsyncCallback", 'x', "ixx" }, + {0XAB96437F, &WrapU_CI, "sceIoSync", 'x', "si" }, + {0X6D08A871, &WrapU_C, "sceIoUnassign", 'x', "s" }, + {0X42EC03AC, &WrapU_IUI, "sceIoWrite", 'x', "ixi" }, + {0X0FACAB19, &WrapU_IUI, "sceIoWriteAsync", 'x', "ixi" }, + {0X35DBD746, &WrapI_IU, "sceIoWaitAsyncCB", 'i', "ix" }, + {0XE23EEC33, &WrapI_IU, "sceIoWaitAsync", 'i', "ix" }, + {0X5C2BE2CC, &WrapU_UIU, "sceIoGetFdList", 'x', "xix" }, }; void Register_IoFileMgrForUser() { @@ -2428,17 +2428,17 @@ void Register_IoFileMgrForUser() { const HLEFunction StdioForUser[] = { - { 0x172D316E, &WrapU_V, "sceKernelStdin" }, - { 0xA6BAB2E9, &WrapU_V, "sceKernelStdout" }, - { 0xF78BA90A, &WrapU_V, "sceKernelStderr" }, - { 0x432D8F5C, &WrapU_U, "sceKernelRegisterStdoutPipe" }, - { 0x6F797E03, &WrapU_U, "sceKernelRegisterStderrPipe" }, - { 0xa46785c9, 0, "sceKernelStdioSendChar" }, - { 0x0cbb0571, 0, "sceKernelStdioLseek" }, - { 0x3054d478, 0, "sceKernelStdioRead" }, - { 0xa3b931db, 0, "sceKernelStdioWrite" }, - { 0x924aba61, 0, "sceKernelStdioOpen" }, - { 0x9d061c19, 0, "sceKernelStdioClose" }, + {0X172D316E, &WrapU_V, "sceKernelStdin", 'x', "" }, + {0XA6BAB2E9, &WrapU_V, "sceKernelStdout", 'x', "" }, + {0XF78BA90A, &WrapU_V, "sceKernelStderr", 'x', "" }, + {0X432D8F5C, &WrapU_U, "sceKernelRegisterStdoutPipe", 'x', "x" }, + {0X6F797E03, &WrapU_U, "sceKernelRegisterStderrPipe", 'x', "x" }, + {0XA46785C9, nullptr, "sceKernelStdioSendChar", '?', "" }, + {0X0CBB0571, nullptr, "sceKernelStdioLseek", '?', "" }, + {0X3054D478, nullptr, "sceKernelStdioRead", '?', "" }, + {0XA3B931DB, nullptr, "sceKernelStdioWrite", '?', "" }, + {0X924ABA61, nullptr, "sceKernelStdioOpen", '?', "" }, + {0X9D061C19, nullptr, "sceKernelStdioClose", '?', "" }, }; void Register_StdioForUser() { diff --git a/Core/HLE/sceJpeg.cpp b/Core/HLE/sceJpeg.cpp index f1372a493d..48f2967e63 100644 --- a/Core/HLE/sceJpeg.cpp +++ b/Core/HLE/sceJpeg.cpp @@ -350,20 +350,20 @@ static int sceJpegDecompressAllImage() const HLEFunction sceJpeg[] = { - {0x0425B986, WrapI_V, "sceJpegDecompressAllImage"}, - {0x04B5AE02, WrapI_UUII, "sceJpegMJpegCsc"}, - {0x04B93CEF, WrapI_UIUI, "sceJpegDecodeMJpeg"}, - {0x227662D7, WrapI_UIUII, "sceJpegDecodeMJpegYCbCrSuccessively"}, - {0x48B602B7, WrapI_V, "sceJpegDeleteMJpeg"}, - {0x64B6F978, WrapI_UIUI, "sceJpegDecodeMJpegSuccessively"}, - {0x67F0ED84, WrapI_UUIII, "sceJpegCsc"}, - {0x7D2F3D7F, WrapI_V, "sceJpegFinishMJpeg"}, - {0x8F2BB012, WrapI_UIUI, "sceJpegGetOutputInfo"}, - {0x91EED83C, WrapI_UIUII, "sceJpegDecodeMJpegYCbCr"}, - {0x9B36444C, WrapI_V, "sceJpeg_9B36444C"}, - {0x9D47469C, WrapI_II, "sceJpegCreateMJpeg"}, - {0xAC9E70E6, WrapI_V, "sceJpegInitMJpeg"}, - {0xa06a75c4, WrapI_V, "sceJpegMJpegCscWithColorOption"}, + {0X0425B986, &WrapI_V, "sceJpegDecompressAllImage", 'i', "" }, + {0X04B5AE02, &WrapI_UUII, "sceJpegMJpegCsc", 'i', "xxii" }, + {0X04B93CEF, &WrapI_UIUI, "sceJpegDecodeMJpeg", 'i', "xixi" }, + {0X227662D7, &WrapI_UIUII, "sceJpegDecodeMJpegYCbCrSuccessively", 'i', "xixii"}, + {0X48B602B7, &WrapI_V, "sceJpegDeleteMJpeg", 'i', "" }, + {0X64B6F978, &WrapI_UIUI, "sceJpegDecodeMJpegSuccessively", 'i', "xixi" }, + {0X67F0ED84, &WrapI_UUIII, "sceJpegCsc", 'i', "xxiii"}, + {0X7D2F3D7F, &WrapI_V, "sceJpegFinishMJpeg", 'i', "" }, + {0X8F2BB012, &WrapI_UIUI, "sceJpegGetOutputInfo", 'i', "xixi" }, + {0X91EED83C, &WrapI_UIUII, "sceJpegDecodeMJpegYCbCr", 'i', "xixii"}, + {0X9B36444C, &WrapI_V, "sceJpeg_9B36444C", 'i', "" }, + {0X9D47469C, &WrapI_II, "sceJpegCreateMJpeg", 'i', "ii" }, + {0XAC9E70E6, &WrapI_V, "sceJpegInitMJpeg", 'i', "" }, + {0XA06A75C4, &WrapI_V, "sceJpegMJpegCscWithColorOption", 'i', "" }, }; void Register_sceJpeg() diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index e822a03f25..f23dbcd1fa 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -315,10 +315,10 @@ u32 sceKernelRegisterKprintfHandler() return 0; } -void sceKernelRegisterDefaultExceptionHandler() +int sceKernelRegisterDefaultExceptionHandler() { ERROR_LOG(SCEKERNEL, "UNIMPL sceKernelRegisterDefaultExceptionHandler()"); - RETURN(0); + return 0; } void sceKernelSetGPO(u32 ledAddr) @@ -715,181 +715,181 @@ static int ThreadManForKernel_ceadeb47(u32 usec) const HLEFunction ThreadManForUser[] = { - {0x55C20A00,&WrapI_CUUU, "sceKernelCreateEventFlag"}, - {0x812346E4,&WrapU_IU, "sceKernelClearEventFlag"}, - {0xEF9E4C70,&WrapU_I, "sceKernelDeleteEventFlag"}, - {0x1fb15a32,&WrapU_IU, "sceKernelSetEventFlag"}, - {0x402FCF22,&WrapI_IUUUU, "sceKernelWaitEventFlag", HLE_NOT_IN_INTERRUPT}, - {0x328C546A,&WrapI_IUUUU, "sceKernelWaitEventFlagCB", HLE_NOT_IN_INTERRUPT}, - {0x30FD48F0,&WrapI_IUUU, "sceKernelPollEventFlag"}, - {0xCD203292,&WrapU_IUU, "sceKernelCancelEventFlag"}, - {0xA66B0120,&WrapU_IU, "sceKernelReferEventFlagStatus"}, + {0X55C20A00, &WrapI_CUUU, "sceKernelCreateEventFlag", 'i', "sxxx" }, + {0X812346E4, &WrapU_IU, "sceKernelClearEventFlag", 'x', "ix" }, + {0XEF9E4C70, &WrapU_I, "sceKernelDeleteEventFlag", 'x', "i" }, + {0X1FB15A32, &WrapU_IU, "sceKernelSetEventFlag", 'x', "ix" }, + {0X402FCF22, &WrapI_IUUUU, "sceKernelWaitEventFlag", 'i', "ixxxx", HLE_NOT_IN_INTERRUPT }, + {0X328C546A, &WrapI_IUUUU, "sceKernelWaitEventFlagCB", 'i', "ixxxx", HLE_NOT_IN_INTERRUPT }, + {0X30FD48F0, &WrapI_IUUU, "sceKernelPollEventFlag", 'i', "ixxx" }, + {0XCD203292, &WrapU_IUU, "sceKernelCancelEventFlag", 'x', "ixx" }, + {0XA66B0120, &WrapU_IU, "sceKernelReferEventFlagStatus", 'x', "ix" }, - {0x8FFDF9A2,&WrapI_IIU, "sceKernelCancelSema"}, - {0xD6DA4BA1,&WrapI_CUIIU, "sceKernelCreateSema"}, - {0x28b6489c,&WrapI_I, "sceKernelDeleteSema"}, - {0x58b1f937,&WrapI_II, "sceKernelPollSema"}, - {0xBC6FEBC5,&WrapI_IU, "sceKernelReferSemaStatus"}, - {0x3F53E640,&WrapI_II, "sceKernelSignalSema"}, - {0x4E3A1105,&WrapI_IIU, "sceKernelWaitSema", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x6d212bac,&WrapI_IIU, "sceKernelWaitSemaCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, + {0X8FFDF9A2, &WrapI_IIU, "sceKernelCancelSema", 'i', "iix" }, + {0XD6DA4BA1, &WrapI_CUIIU, "sceKernelCreateSema", 'i', "sxiix" }, + {0X28B6489C, &WrapI_I, "sceKernelDeleteSema", 'i', "i" }, + {0X58B1F937, &WrapI_II, "sceKernelPollSema", 'i', "ii" }, + {0XBC6FEBC5, &WrapI_IU, "sceKernelReferSemaStatus", 'i', "ix" }, + {0X3F53E640, &WrapI_II, "sceKernelSignalSema", 'i', "ii" }, + {0X4E3A1105, &WrapI_IIU, "sceKernelWaitSema", 'i', "iix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X6D212BAC, &WrapI_IIU, "sceKernelWaitSemaCB", 'i', "iix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, - {0x60107536,&WrapI_U, "sceKernelDeleteLwMutex"}, - {0x19CFF145,&WrapI_UCUIU, "sceKernelCreateLwMutex"}, - {0x4C145944,&WrapI_IU, "sceKernelReferLwMutexStatusByID"}, + {0X60107536, &WrapI_U, "sceKernelDeleteLwMutex", 'i', "x" }, + {0X19CFF145, &WrapI_UCUIU, "sceKernelCreateLwMutex", 'i', "xsxix" }, + {0X4C145944, &WrapI_IU, "sceKernelReferLwMutexStatusByID", 'i', "ix" }, // NOTE: LockLwMutex, UnlockLwMutex, and ReferLwMutexStatus are in Kernel_Library, see sceKernelInterrupt.cpp. // The below should not be called directly. - //{0x71040D5C,0, "_sceKernelTryLockLwMutex"}, - //{0x7CFF8CF3,0, "_sceKernelLockLwMutex"}, - //{0x31327F19,0, "_sceKernelLockLwMutexCB"}, - //{0xBEED3A47,0, "_sceKernelUnlockLwMutex"}, + //{0x71040D5C, nullptr, "_sceKernelTryLockLwMutex", '?', "" }, + //{0x7CFF8CF3, nullptr, "_sceKernelLockLwMutex", '?', "" }, + //{0x31327F19, nullptr, "_sceKernelLockLwMutexCB", '?', "" }, + //{0xBEED3A47, nullptr, "_sceKernelUnlockLwMutex", '?', "" }, - {0xf8170fbe,WrapI_I, "sceKernelDeleteMutex"}, - {0xB011B11F,WrapI_IIU, "sceKernelLockMutex", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x5bf4dd27,WrapI_IIU, "sceKernelLockMutexCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x6b30100f,WrapI_II, "sceKernelUnlockMutex"}, - {0xb7d098c6,WrapI_CUIU, "sceKernelCreateMutex"}, - {0x0DDCD2C9,WrapI_II, "sceKernelTryLockMutex"}, - {0xA9C2CB9A,WrapI_IU, "sceKernelReferMutexStatus"}, - {0x87D9223C,WrapI_IIU, "sceKernelCancelMutex"}, + {0XF8170FBE, &WrapI_I, "sceKernelDeleteMutex", 'i', "i" }, + {0XB011B11F, &WrapI_IIU, "sceKernelLockMutex", 'i', "iix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X5BF4DD27, &WrapI_IIU, "sceKernelLockMutexCB", 'i', "iix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X6B30100F, &WrapI_II, "sceKernelUnlockMutex", 'i', "ii" }, + {0XB7D098C6, &WrapI_CUIU, "sceKernelCreateMutex", 'i', "sxix" }, + {0X0DDCD2C9, &WrapI_II, "sceKernelTryLockMutex", 'i', "ii" }, + {0XA9C2CB9A, &WrapI_IU, "sceKernelReferMutexStatus", 'i', "ix" }, + {0X87D9223C, &WrapI_IIU, "sceKernelCancelMutex", 'i', "iix" }, - {0xFCCFAD26,WrapI_I,"sceKernelCancelWakeupThread"}, - {0x1AF94D03,0,"sceKernelDonateWakeupThread"}, - {0xea748e31,WrapI_UU,"sceKernelChangeCurrentThreadAttr"}, - {0x71bc9871,WrapI_II,"sceKernelChangeThreadPriority"}, - {0x446D8DE6,WrapI_CUUIUU, "sceKernelCreateThread", HLE_NOT_IN_INTERRUPT}, - {0x9fa03cd3,WrapI_I,"sceKernelDeleteThread"}, - {0xBD123D9E,WrapI_U, "sceKernelDelaySysClockThread", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x1181E963,WrapI_U, "sceKernelDelaySysClockThreadCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xceadeb47,WrapI_U, "sceKernelDelayThread", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x68da9e36,WrapI_U, "sceKernelDelayThreadCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xaa73c935,WrapV_I,"sceKernelExitThread"}, - {0x809ce29b,WrapV_I,"sceKernelExitDeleteThread"}, - {0x94aa61ee,sceKernelGetThreadCurrentPriority,"sceKernelGetThreadCurrentPriority"}, - {0x293b45b8,WrapI_V, "sceKernelGetThreadId", HLE_NOT_IN_INTERRUPT}, - {0x3B183E26,WrapI_I,"sceKernelGetThreadExitStatus"}, - {0x52089CA1,WrapI_I, "sceKernelGetThreadStackFreeSize"}, - {0xFFC36A14,WrapU_UU,"sceKernelReferThreadRunStatus"}, - {0x17c1684e,WrapU_UU,"sceKernelReferThreadStatus"}, - {0x2C34E053,WrapI_I,"sceKernelReleaseWaitThread"}, - {0x75156e8f,WrapI_I,"sceKernelResumeThread"}, - {0x3ad58b8c,&WrapU_V, "sceKernelSuspendDispatchThread", HLE_NOT_IN_INTERRUPT}, - {0x27e22ec2,&WrapU_U, "sceKernelResumeDispatchThread", HLE_NOT_IN_INTERRUPT}, - {0x912354a7,&WrapI_I,"sceKernelRotateThreadReadyQueue"}, - {0x9ACE131E,WrapI_V, "sceKernelSleepThread", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x82826f70,WrapI_V, "sceKernelSleepThreadCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xF475845D,&WrapI_IIU, "sceKernelStartThread", HLE_NOT_IN_INTERRUPT}, - {0x9944f31f,WrapI_I,"sceKernelSuspendThread"}, - {0x616403ba,WrapI_I,"sceKernelTerminateThread"}, - {0x383f7bcc,WrapI_I,"sceKernelTerminateDeleteThread"}, - {0x840E8133,WrapI_IU,"sceKernelWaitThreadEndCB"}, - {0xd13bde95,WrapI_V,"sceKernelCheckThreadStack"}, + {0XFCCFAD26, &WrapI_I, "sceKernelCancelWakeupThread", 'i', "i" }, + {0X1AF94D03, nullptr, "sceKernelDonateWakeupThread", '?', "" }, + {0XEA748E31, &WrapI_UU, "sceKernelChangeCurrentThreadAttr", 'i', "xx" }, + {0X71BC9871, &WrapI_II, "sceKernelChangeThreadPriority", 'i', "ii" }, + {0X446D8DE6, &WrapI_CUUIUU, "sceKernelCreateThread", 'i', "sxxixx", HLE_NOT_IN_INTERRUPT }, + {0X9FA03CD3, &WrapI_I, "sceKernelDeleteThread", 'i', "i" }, + {0XBD123D9E, &WrapI_U, "sceKernelDelaySysClockThread", 'i', "x", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X1181E963, &WrapI_U, "sceKernelDelaySysClockThreadCB", 'i', "x", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XCEADEB47, &WrapI_U, "sceKernelDelayThread", 'i', "x", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X68DA9E36, &WrapI_U, "sceKernelDelayThreadCB", 'i', "x", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XAA73C935, &WrapV_I, "sceKernelExitThread", 'v', "i" }, + {0X809CE29B, &WrapV_I, "sceKernelExitDeleteThread", 'v', "i" }, + {0x94aa61ee, &WrapI_V, "sceKernelGetThreadCurrentPriority", 'i', "" }, + {0X293B45B8, &WrapI_V, "sceKernelGetThreadId", 'i', "", HLE_NOT_IN_INTERRUPT }, + {0X3B183E26, &WrapI_I, "sceKernelGetThreadExitStatus", 'i', "i" }, + {0X52089CA1, &WrapI_I, "sceKernelGetThreadStackFreeSize", 'i', "i" }, + {0XFFC36A14, &WrapU_UU, "sceKernelReferThreadRunStatus", 'x', "xx" }, + {0X17C1684E, &WrapU_UU, "sceKernelReferThreadStatus", 'x', "xx" }, + {0X2C34E053, &WrapI_I, "sceKernelReleaseWaitThread", 'i', "i" }, + {0X75156E8F, &WrapI_I, "sceKernelResumeThread", 'i', "i" }, + {0X3AD58B8C, &WrapU_V, "sceKernelSuspendDispatchThread", 'x', "", HLE_NOT_IN_INTERRUPT }, + {0X27E22EC2, &WrapU_U, "sceKernelResumeDispatchThread", 'x', "x", HLE_NOT_IN_INTERRUPT }, + {0X912354A7, &WrapI_I, "sceKernelRotateThreadReadyQueue", 'i', "i" }, + {0X9ACE131E, &WrapI_V, "sceKernelSleepThread", 'i', "", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X82826F70, &WrapI_V, "sceKernelSleepThreadCB", 'i', "", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XF475845D, &WrapI_IIU, "sceKernelStartThread", 'i', "iix", HLE_NOT_IN_INTERRUPT }, + {0X9944F31F, &WrapI_I, "sceKernelSuspendThread", 'i', "i" }, + {0X616403BA, &WrapI_I, "sceKernelTerminateThread", 'i', "i" }, + {0X383F7BCC, &WrapI_I, "sceKernelTerminateDeleteThread", 'i', "i" }, + {0X840E8133, &WrapI_IU, "sceKernelWaitThreadEndCB", 'i', "ix" }, + {0XD13BDE95, &WrapI_V, "sceKernelCheckThreadStack", 'i', "" }, - {0x94416130,WrapU_UUUU,"sceKernelGetThreadmanIdList"}, - {0x57CF62DD,WrapU_U,"sceKernelGetThreadmanIdType"}, - {0xBC80EC7C,WrapU_UUU, "sceKernelExtendThreadStack"}, + {0X94416130, &WrapU_UUUU, "sceKernelGetThreadmanIdList", 'x', "xxxx" }, + {0X57CF62DD, &WrapU_U, "sceKernelGetThreadmanIdType", 'x', "x" }, + {0XBC80EC7C, &WrapU_UUU, "sceKernelExtendThreadStack", 'x', "xxx" }, // NOTE: Takes a UID from sceKernelMemory's AllocMemoryBlock and seems thread stack related. - //{0x28BFD974,0,"ThreadManForUser_28BFD974"}, + //{0x28BFD974, nullptr, "ThreadManForUser_28BFD974", '?', "" }, - {0x82BC5777,WrapU64_V,"sceKernelGetSystemTimeWide"}, - {0xdb738f35,WrapI_U,"sceKernelGetSystemTime"}, - {0x369ed59d,WrapU_V,"sceKernelGetSystemTimeLow"}, + {0X82BC5777, &WrapU64_V, "sceKernelGetSystemTimeWide", 'X', "" }, + {0XDB738F35, &WrapI_U, "sceKernelGetSystemTime", 'i', "x" }, + {0X369ED59D, &WrapU_V, "sceKernelGetSystemTimeLow", 'x', "" }, - {0x8218B4DD,WrapI_U,"sceKernelReferGlobalProfiler"}, - {0x627E6F3A,WrapI_U,"sceKernelReferSystemStatus"}, - {0x64D4540E,WrapU_U,"sceKernelReferThreadProfiler"}, + {0X8218B4DD, &WrapI_U, "sceKernelReferGlobalProfiler", 'i', "x" }, + {0X627E6F3A, &WrapI_U, "sceKernelReferSystemStatus", 'i', "x" }, + {0X64D4540E, &WrapU_U, "sceKernelReferThreadProfiler", 'x', "x" }, //Fifa Street 2 uses alarms - {0x6652b8ca,WrapI_UUU,"sceKernelSetAlarm"}, - {0xB2C25152,WrapI_UUU,"sceKernelSetSysClockAlarm"}, - {0x7e65b999,WrapI_I,"sceKernelCancelAlarm"}, - {0xDAA3F564,WrapI_IU,"sceKernelReferAlarmStatus"}, + {0X6652B8CA, &WrapI_UUU, "sceKernelSetAlarm", 'i', "xxx" }, + {0XB2C25152, &WrapI_UUU, "sceKernelSetSysClockAlarm", 'i', "xxx" }, + {0X7E65B999, &WrapI_I, "sceKernelCancelAlarm", 'i', "i" }, + {0XDAA3F564, &WrapI_IU, "sceKernelReferAlarmStatus", 'i', "ix" }, - {0xba6b92e2,WrapI_UUU,"sceKernelSysClock2USec"}, - {0x110dec9a,WrapI_UU,"sceKernelUSec2SysClock"}, - {0xC8CD158C,WrapU64_U,"sceKernelUSec2SysClockWide"}, - {0xE1619D7C,WrapI_UUUU,"sceKernelSysClock2USecWide"}, + {0XBA6B92E2, &WrapI_UUU, "sceKernelSysClock2USec", 'i', "xxx" }, + {0X110DEC9A, &WrapI_UU, "sceKernelUSec2SysClock", 'i', "xx" }, + {0XC8CD158C, &WrapU64_U, "sceKernelUSec2SysClockWide", 'X', "x" }, + {0XE1619D7C, &WrapI_UUUU, "sceKernelSysClock2USecWide", 'i', "xxxx" }, - {0x278C0DF5,WrapI_IU,"sceKernelWaitThreadEnd"}, - {0xd59ead2f,WrapI_I,"sceKernelWakeupThread"}, //AI Go, audio? + {0X278C0DF5, &WrapI_IU, "sceKernelWaitThreadEnd", 'i', "ix" }, + {0XD59EAD2F, &WrapI_I, "sceKernelWakeupThread", 'i', "i" }, //AI Go, audio? - {0x0C106E53,0,"sceKernelRegisterThreadEventHandler"}, - {0x72F3C145,0,"sceKernelReleaseThreadEventHandler"}, - {0x369EEB6B,0,"sceKernelReferThreadEventHandlerStatus"}, + {0X0C106E53, nullptr, "sceKernelRegisterThreadEventHandler", '?', "" }, + {0X72F3C145, nullptr, "sceKernelReleaseThreadEventHandler", '?', "" }, + {0X369EEB6B, nullptr, "sceKernelReferThreadEventHandlerStatus", '?', "" }, - {0x349d6d6c,sceKernelCheckCallback, "sceKernelCheckCallback"}, - {0xE81CAF8F,WrapI_CUU, "sceKernelCreateCallback"}, - {0xEDBA5844,WrapI_I, "sceKernelDeleteCallback"}, - {0xC11BA8C4,WrapI_II, "sceKernelNotifyCallback"}, - {0xBA4051D6,WrapI_I, "sceKernelCancelCallback"}, - {0x2A3D44FF,WrapI_I, "sceKernelGetCallbackCount"}, - {0x730ED8BC,WrapI_IU, "sceKernelReferCallbackStatus"}, + {0x349d6d6c, &sceKernelCheckCallback, "sceKernelCheckCallback", 'i', "" }, + {0XE81CAF8F, &WrapI_CUU, "sceKernelCreateCallback", 'i', "sxx" }, + {0XEDBA5844, &WrapI_I, "sceKernelDeleteCallback", 'i', "i" }, + {0XC11BA8C4, &WrapI_II, "sceKernelNotifyCallback", 'i', "ii" }, + {0XBA4051D6, &WrapI_I, "sceKernelCancelCallback", 'i', "i" }, + {0X2A3D44FF, &WrapI_I, "sceKernelGetCallbackCount", 'i', "i" }, + {0X730ED8BC, &WrapI_IU, "sceKernelReferCallbackStatus", 'i', "ix" }, - {0x8125221D,WrapI_CUU, "sceKernelCreateMbx"}, - {0x86255ADA,WrapI_I, "sceKernelDeleteMbx"}, - {0xE9B3061E,WrapI_IU, "sceKernelSendMbx"}, - {0x18260574,WrapI_IUU, "sceKernelReceiveMbx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xF3986382,WrapI_IUU, "sceKernelReceiveMbxCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x0D81716A,WrapI_IU, "sceKernelPollMbx"}, - {0x87D4DD36,WrapI_IU, "sceKernelCancelReceiveMbx"}, - {0xA8E8C846,WrapI_IU, "sceKernelReferMbxStatus"}, + {0X8125221D, &WrapI_CUU, "sceKernelCreateMbx", 'i', "sxx" }, + {0X86255ADA, &WrapI_I, "sceKernelDeleteMbx", 'i', "i" }, + {0XE9B3061E, &WrapI_IU, "sceKernelSendMbx", 'i', "ix" }, + {0X18260574, &WrapI_IUU, "sceKernelReceiveMbx", 'i', "ixx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XF3986382, &WrapI_IUU, "sceKernelReceiveMbxCB", 'i', "ixx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X0D81716A, &WrapI_IU, "sceKernelPollMbx", 'i', "ix" }, + {0X87D4DD36, &WrapI_IU, "sceKernelCancelReceiveMbx", 'i', "ix" }, + {0XA8E8C846, &WrapI_IU, "sceKernelReferMbxStatus", 'i', "ix" }, - {0x7C0DC2A0,WrapI_CIUUU, "sceKernelCreateMsgPipe"}, - {0xF0B7DA1C,WrapI_I, "sceKernelDeleteMsgPipe"}, - {0x876DBFAD,WrapI_IUUUUU, "sceKernelSendMsgPipe"}, - {0x7C41F2C2,WrapI_IUUUUU, "sceKernelSendMsgPipeCB"}, - {0x884C9F90,WrapI_IUUUU, "sceKernelTrySendMsgPipe"}, - {0x74829B76,WrapI_IUUUUU, "sceKernelReceiveMsgPipe"}, - {0xFBFA697D,WrapI_IUUUUU, "sceKernelReceiveMsgPipeCB"}, - {0xDF52098F,WrapI_IUUUU, "sceKernelTryReceiveMsgPipe"}, - {0x349B864D,WrapI_IUU, "sceKernelCancelMsgPipe"}, - {0x33BE4024,WrapI_IU, "sceKernelReferMsgPipeStatus"}, + {0X7C0DC2A0, &WrapI_CIUUU, "sceKernelCreateMsgPipe", 'i', "sixxx" }, + {0XF0B7DA1C, &WrapI_I, "sceKernelDeleteMsgPipe", 'i', "i" }, + {0X876DBFAD, &WrapI_IUUUUU, "sceKernelSendMsgPipe", 'i', "ixxxxx" }, + {0X7C41F2C2, &WrapI_IUUUUU, "sceKernelSendMsgPipeCB", 'i', "ixxxxx" }, + {0X884C9F90, &WrapI_IUUUU, "sceKernelTrySendMsgPipe", 'i', "ixxxx" }, + {0X74829B76, &WrapI_IUUUUU, "sceKernelReceiveMsgPipe", 'i', "ixxxxx" }, + {0XFBFA697D, &WrapI_IUUUUU, "sceKernelReceiveMsgPipeCB", 'i', "ixxxxx" }, + {0XDF52098F, &WrapI_IUUUU, "sceKernelTryReceiveMsgPipe", 'i', "ixxxx" }, + {0X349B864D, &WrapI_IUU, "sceKernelCancelMsgPipe", 'i', "ixx" }, + {0X33BE4024, &WrapI_IU, "sceKernelReferMsgPipeStatus", 'i', "ix" }, - {0x56C039B5,WrapI_CIUUU, "sceKernelCreateVpl"}, - {0x89B3D48C,WrapI_I, "sceKernelDeleteVpl"}, - {0xBED27435,WrapI_IUUU, "sceKernelAllocateVpl", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xEC0A693F,WrapI_IUUU, "sceKernelAllocateVplCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xAF36D708,WrapI_IUU, "sceKernelTryAllocateVpl"}, - {0xB736E9FF,WrapI_IU, "sceKernelFreeVpl"}, - {0x1D371B8A,WrapI_IU, "sceKernelCancelVpl"}, - {0x39810265,WrapI_IU, "sceKernelReferVplStatus"}, + {0X56C039B5, &WrapI_CIUUU, "sceKernelCreateVpl", 'i', "sixxx" }, + {0X89B3D48C, &WrapI_I, "sceKernelDeleteVpl", 'i', "i" }, + {0XBED27435, &WrapI_IUUU, "sceKernelAllocateVpl", 'i', "ixxx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XEC0A693F, &WrapI_IUUU, "sceKernelAllocateVplCB", 'i', "ixxx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XAF36D708, &WrapI_IUU, "sceKernelTryAllocateVpl", 'i', "ixx" }, + {0XB736E9FF, &WrapI_IU, "sceKernelFreeVpl", 'i', "ix" }, + {0X1D371B8A, &WrapI_IU, "sceKernelCancelVpl", 'i', "ix" }, + {0X39810265, &WrapI_IU, "sceKernelReferVplStatus", 'i', "ix" }, - {0xC07BB470,WrapI_CUUUUU, "sceKernelCreateFpl"}, - {0xED1410E0,WrapI_I, "sceKernelDeleteFpl"}, - {0xD979E9BF,WrapI_IUU, "sceKernelAllocateFpl", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xE7282CB6,WrapI_IUU, "sceKernelAllocateFplCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x623AE665,WrapI_IU, "sceKernelTryAllocateFpl"}, - {0xF6414A71,WrapI_IU, "sceKernelFreeFpl"}, - {0xA8AA591F,WrapI_IU, "sceKernelCancelFpl"}, - {0xD8199E4C,WrapI_IU, "sceKernelReferFplStatus"}, + {0XC07BB470, &WrapI_CUUUUU, "sceKernelCreateFpl", 'i', "sxxxxx" }, + {0XED1410E0, &WrapI_I, "sceKernelDeleteFpl", 'i', "i" }, + {0XD979E9BF, &WrapI_IUU, "sceKernelAllocateFpl", 'i', "ixx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XE7282CB6, &WrapI_IUU, "sceKernelAllocateFplCB", 'i', "ixx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X623AE665, &WrapI_IU, "sceKernelTryAllocateFpl", 'i', "ix" }, + {0XF6414A71, &WrapI_IU, "sceKernelFreeFpl", 'i', "ix" }, + {0XA8AA591F, &WrapI_IU, "sceKernelCancelFpl", 'i', "ix" }, + {0XD8199E4C, &WrapI_IU, "sceKernelReferFplStatus", 'i', "ix" }, - {0x20fff560,WrapU_CU, "sceKernelCreateVTimer", HLE_NOT_IN_INTERRUPT}, - {0x328F9E52,WrapU_I, "sceKernelDeleteVTimer", HLE_NOT_IN_INTERRUPT}, - {0xc68d9437,WrapU_I, "sceKernelStartVTimer"}, - {0xD0AEEE87,WrapU_I, "sceKernelStopVTimer"}, - {0xD2D615EF,WrapU_I, "sceKernelCancelVTimerHandler"}, - {0xB3A59970,WrapU_IU, "sceKernelGetVTimerBase"}, - {0xB7C18B77,WrapU64_I, "sceKernelGetVTimerBaseWide"}, - {0x034A921F,WrapU_IU, "sceKernelGetVTimerTime"}, - {0xC0B3FFD2,WrapU64_I, "sceKernelGetVTimerTimeWide"}, - {0x5F32BEAA,WrapU_IU, "sceKernelReferVTimerStatus"}, - {0x542AD630,WrapU_IU, "sceKernelSetVTimerTime"}, - {0xFB6425C3,WrapU64_IU64, "sceKernelSetVTimerTimeWide"}, - {0xd8b299ae,WrapU_IUUU, "sceKernelSetVTimerHandler"}, - {0x53B00E9A,WrapU_IU64UU, "sceKernelSetVTimerHandlerWide"}, + {0X20FFF560, &WrapU_CU, "sceKernelCreateVTimer", 'x', "sx", HLE_NOT_IN_INTERRUPT }, + {0X328F9E52, &WrapU_I, "sceKernelDeleteVTimer", 'x', "i", HLE_NOT_IN_INTERRUPT }, + {0XC68D9437, &WrapU_I, "sceKernelStartVTimer", 'x', "i" }, + {0XD0AEEE87, &WrapU_I, "sceKernelStopVTimer", 'x', "i" }, + {0XD2D615EF, &WrapU_I, "sceKernelCancelVTimerHandler", 'x', "i" }, + {0XB3A59970, &WrapU_IU, "sceKernelGetVTimerBase", 'x', "ix" }, + {0XB7C18B77, &WrapU64_I, "sceKernelGetVTimerBaseWide", 'X', "i" }, + {0X034A921F, &WrapU_IU, "sceKernelGetVTimerTime", 'x', "ix" }, + {0XC0B3FFD2, &WrapU64_I, "sceKernelGetVTimerTimeWide", 'X', "i" }, + {0X5F32BEAA, &WrapU_IU, "sceKernelReferVTimerStatus", 'x', "ix" }, + {0X542AD630, &WrapU_IU, "sceKernelSetVTimerTime", 'x', "ix" }, + {0XFB6425C3, &WrapU64_IU64, "sceKernelSetVTimerTimeWide", 'X', "iX" }, + {0XD8B299AE, &WrapU_IUUU, "sceKernelSetVTimerHandler", 'x', "ixxx" }, + {0X53B00E9A, &WrapU_IU64UU, "sceKernelSetVTimerHandlerWide", 'x', "iXxx" }, - {0x8daff657,WrapI_CUUUUU, "sceKernelCreateTlspl"}, - {0x32bf938e,WrapI_I, "sceKernelDeleteTlspl"}, - {0x721067F3,WrapI_IU, "sceKernelReferTlsplStatus"}, + {0X8DAFF657, &WrapI_CUUUUU, "sceKernelCreateTlspl", 'i', "sxxxxx" }, + {0X32BF938E, &WrapI_I, "sceKernelDeleteTlspl", 'i', "i" }, + {0X721067F3, &WrapI_IU, "sceKernelReferTlsplStatus", 'i', "ix" }, // Not completely certain about args. - {0x4A719FB2,WrapI_I, "sceKernelFreeTlspl"}, + {0X4A719FB2, &WrapI_I, "sceKernelFreeTlspl", 'i', "i" }, // Internal. Takes (uid, &addr) as parameters... probably. - //{0x65F54FFB,0, "_sceKernelAllocateTlspl"}, + //{0x65F54FFB, nullptr, "_sceKernelAllocateTlspl", 'v', "" }, // NOTE: sceKernelGetTlsAddr is in Kernel_Library, see sceKernelInterrupt.cpp. // Not sure if these should be hooked up. See below. - {0x0E927AED, _sceKernelReturnFromTimerHandler, "_sceKernelReturnFromTimerHandler"}, - {0x532A522E, WrapV_I<_sceKernelExitThread>,"_sceKernelExitThread"}, + {0x0E927AED, &_sceKernelReturnFromTimerHandler, "_sceKernelReturnFromTimerHandler", 'v', "" }, + {0X532A522E, &WrapV_I<_sceKernelExitThread>, "_sceKernelExitThread", 'v', "i" }, // Shouldn't hook this up. No games should import this function manually and call it. @@ -898,9 +898,9 @@ const HLEFunction ThreadManForUser[] = const HLEFunction ThreadManForKernel[] = { - {0xceadeb47, WrapI_U, "ThreadManForKernel_ceadeb47"}, - {0x446d8de6, WrapI_CUUIUU, "ThreadManForKernel_446d8de6"},//Not sure right - {0xf475845d, &WrapI_IIU, "ThreadManForKernel_f475845d"},//Not sure right + {0XCEADEB47, &WrapI_U, "ThreadManForKernel_ceadeb47", 'i', "x" }, + {0X446D8DE6, &WrapI_CUUIUU, "ThreadManForKernel_446d8de6", 'i', "sxxixx" },//Not sure right + {0XF475845D, &WrapI_IIU, "ThreadManForKernel_f475845d", 'i', "iix" },//Not sure right }; void Register_ThreadManForUser() @@ -911,12 +911,12 @@ void Register_ThreadManForUser() const HLEFunction LoadExecForUser[] = { - {0x05572A5F,&WrapV_V, "sceKernelExitGame"}, //() - {0x4AC57943,&WrapI_I,"sceKernelRegisterExitCallback"}, - {0xBD2F1094,&WrapI_CU,"sceKernelLoadExec"}, - {0x2AC9954B,&WrapV_V,"sceKernelExitGameWithStatus"}, - {0x362A956B,&WrapI_V, "LoadExecForUser_362A956B"}, - {0x8ada38d3,0, "LoadExecForUser_8ADA38D3"}, + {0X05572A5F, &WrapV_V, "sceKernelExitGame", 'v', "" }, + {0X4AC57943, &WrapI_I, "sceKernelRegisterExitCallback", 'i', "i" }, + {0XBD2F1094, &WrapI_CU, "sceKernelLoadExec", 'i', "sx" }, + {0X2AC9954B, &WrapV_V, "sceKernelExitGameWithStatus", 'v', "" }, + {0X362A956B, &WrapI_V, "LoadExecForUser_362A956B", 'i', "" }, + {0X8ADA38D3, nullptr, "LoadExecForUser_8ADA38D3", '?', "" }, }; void Register_LoadExecForUser() @@ -932,8 +932,8 @@ static int LoadExecForKernel_4AC57943(SceUID cbId) const HLEFunction LoadExecForKernel[] = { - {0x4AC57943,&WrapI_I,"LoadExecForKernel_4AC57943"}, - {0xa3d5e142,0, "LoadExecForKernel_a3d5e142"}, + {0X4AC57943, &WrapI_I, "LoadExecForKernel_4AC57943", 'i', "i" }, + {0XA3D5E142, nullptr, "LoadExecForKernel_a3d5e142", '?', "" }, }; void Register_LoadExecForKernel() @@ -943,21 +943,21 @@ void Register_LoadExecForKernel() const HLEFunction SysMemForKernel[] = { - {0x636c953b,0, "SysMemForKernel_636c953b"}, - {0xc9805775,0, "SysMemForKernel_c9805775"}, - {0x1c1fbfe7,0, "SysMemForKernel_1c1fbfe7"}, + {0X636C953B, nullptr, "SysMemForKernel_636c953b", '?', "" }, + {0XC9805775, nullptr, "SysMemForKernel_c9805775", '?', "" }, + {0X1C1FBFE7, nullptr, "SysMemForKernel_1c1fbfe7", '?', "" }, }; const HLEFunction ExceptionManagerForKernel[] = { - {0x3FB264FC, 0, "sceKernelRegisterExceptionHandler"}, - {0x5A837AD4, 0, "sceKernelRegisterPriorityExceptionHandler"}, - {0x565C0B0E, sceKernelRegisterDefaultExceptionHandler, "sceKernelRegisterDefaultExceptionHandler"}, - {0x1AA6CFFA, 0, "sceKernelReleaseExceptionHandler"}, - {0xDF83875E, 0, "sceKernelGetActiveDefaultExceptionHandler"}, - {0x291FF031, 0, "sceKernelReleaseDefaultExceptionHandler"}, - {0x15ADC862, 0, "sceKernelRegisterNmiHandler"}, - {0xB15357C9, 0, "sceKernelReleaseNmiHandler"}, + {0X3FB264FC, nullptr, "sceKernelRegisterExceptionHandler", '?', "" }, + {0X5A837AD4, nullptr, "sceKernelRegisterPriorityExceptionHandler", '?', "" }, + {0x565C0B0E, &WrapI_V, "sceKernelRegisterDefaultExceptionHandler", 'i', "" }, + {0X1AA6CFFA, nullptr, "sceKernelReleaseExceptionHandler", '?', "" }, + {0XDF83875E, nullptr, "sceKernelGetActiveDefaultExceptionHandler", '?', "" }, + {0X291FF031, nullptr, "sceKernelReleaseDefaultExceptionHandler", '?', "" }, + {0X15ADC862, nullptr, "sceKernelRegisterNmiHandler", '?', "" }, + {0XB15357C9, nullptr, "sceKernelReleaseNmiHandler", '?', "" }, }; void Register_SysMemForKernel() @@ -972,25 +972,25 @@ void Register_ExceptionManagerForKernel() // Seen in some homebrew const HLEFunction UtilsForKernel[] = { - {0xC2DF770E, 0, "sceKernelIcacheInvalidateRange"}, - {0x78934841, 0, "sceKernelGzipDecompress"}, - {0xe8db3ce6, 0, "sceKernelDeflateDecompress"}, - {0x840259f1, 0, "sceKernelUtilsSha1Digest"}, - {0x9e5c5086, 0, "sceKernelUtilsMd5BlockInit"}, - {0x61e1e525, 0, "sceKernelUtilsMd5BlockUpdate"}, - {0xb8d24e78, 0, "sceKernelUtilsMd5BlockResult"}, - {0xc8186a58, 0, "sceKernelUtilsMd5Digest"}, - {0x6c6887ee, 0, "UtilsForKernel_6C6887EE"}, - {0x91e4f6a7, 0, "sceKernelLibcClock"}, - {0x27cc57f0, 0, "sceKernelLibcTime"}, - {0x79d1c3fa, 0, "sceKernelDcacheWritebackAll"}, - {0x3ee30821, 0, "sceKernelDcacheWritebackRange"}, - {0x34b9fa9e, 0, "sceKernelDcacheWritebackInvalidateRange"}, - {0xb435dec5, 0, "sceKernelDcacheWritebackInvalidateAll"}, - {0xbfa98062, 0, "sceKernelDcacheInvalidateRange"}, - {0x920f104a, 0, "sceKernelIcacheInvalidateAll"}, - {0xe860e75e, 0, "sceKernelUtilsMt19937Init"}, - {0x06fb8a63, 0, "sceKernelUtilsMt19937UInt"}, + {0XC2DF770E, nullptr, "sceKernelIcacheInvalidateRange", '?', "" }, + {0X78934841, nullptr, "sceKernelGzipDecompress", '?', "" }, + {0XE8DB3CE6, nullptr, "sceKernelDeflateDecompress", '?', "" }, + {0X840259F1, nullptr, "sceKernelUtilsSha1Digest", '?', "" }, + {0X9E5C5086, nullptr, "sceKernelUtilsMd5BlockInit", '?', "" }, + {0X61E1E525, nullptr, "sceKernelUtilsMd5BlockUpdate", '?', "" }, + {0XB8D24E78, nullptr, "sceKernelUtilsMd5BlockResult", '?', "" }, + {0XC8186A58, nullptr, "sceKernelUtilsMd5Digest", '?', "" }, + {0X6C6887EE, nullptr, "UtilsForKernel_6C6887EE", '?', "" }, + {0X91E4F6A7, nullptr, "sceKernelLibcClock", '?', "" }, + {0X27CC57F0, nullptr, "sceKernelLibcTime", '?', "" }, + {0X79D1C3FA, nullptr, "sceKernelDcacheWritebackAll", '?', "" }, + {0X3EE30821, nullptr, "sceKernelDcacheWritebackRange", '?', "" }, + {0X34B9FA9E, nullptr, "sceKernelDcacheWritebackInvalidateRange", '?', "" }, + {0XB435DEC5, nullptr, "sceKernelDcacheWritebackInvalidateAll", '?', "" }, + {0XBFA98062, nullptr, "sceKernelDcacheInvalidateRange", '?', "" }, + {0X920F104A, nullptr, "sceKernelIcacheInvalidateAll", '?', "" }, + {0XE860E75E, nullptr, "sceKernelUtilsMt19937Init", '?', "" }, + {0X06FB8A63, nullptr, "sceKernelUtilsMt19937UInt", '?', "" }, }; diff --git a/Core/HLE/sceKernel.h b/Core/HLE/sceKernel.h index fc2a820903..03a3b724c7 100644 --- a/Core/HLE/sceKernel.h +++ b/Core/HLE/sceKernel.h @@ -381,7 +381,7 @@ void sceKernelExitGameWithStatus(); u32 sceKernelDevkitVersion(); u32 sceKernelRegisterKprintfHandler(); -void sceKernelRegisterDefaultExceptionHandler(); +int sceKernelRegisterDefaultExceptionHandler(); u32 sceKernelFindModuleByName(const char *name); diff --git a/Core/HLE/sceKernelInterrupt.cpp b/Core/HLE/sceKernelInterrupt.cpp index 58513b6f7c..5d533aba19 100644 --- a/Core/HLE/sceKernelInterrupt.cpp +++ b/Core/HLE/sceKernelInterrupt.cpp @@ -76,7 +76,7 @@ static bool inInterrupt; static SceUID threadBeforeInterrupt; -static void sceKernelCpuSuspendIntr() +static int sceKernelCpuSuspendIntr() { VERBOSE_LOG(SCEINTC, "sceKernelCpuSuspendIntr"); int returnValue; @@ -90,7 +90,7 @@ static void sceKernelCpuSuspendIntr() returnValue = 0; } hleEatCycles(15); - RETURN(returnValue); + return returnValue; } static void sceKernelCpuResumeIntr(u32 enable) @@ -109,11 +109,11 @@ static void sceKernelCpuResumeIntr(u32 enable) hleEatCycles(15); } -static void sceKernelIsCpuIntrEnable() +static int sceKernelIsCpuIntrEnable() { u32 retVal = __InterruptsEnabled(); DEBUG_LOG(SCEINTC, "%i=sceKernelIsCpuIntrEnable()", retVal); - RETURN(retVal); + return retVal; } static int sceKernelIsCpuIntrSuspended(int flag) @@ -594,10 +594,10 @@ struct PspIntrHandlerOptionParam { u32 max_clock_hi; //+34 }; //=38 -static void QueryIntrHandlerInfo() +static int QueryIntrHandlerInfo() { ERROR_LOG_REPORT(SCEINTC, "QueryIntrHandlerInfo()"); - RETURN(0); + return 0; } static u32 sceKernelMemset(u32 addr, u32 fillc, u32 n) @@ -660,22 +660,22 @@ static u32 sceKernelMemcpy(u32 dst, u32 src, u32 size) const HLEFunction Kernel_Library[] = { - {0x092968F4,sceKernelCpuSuspendIntr, "sceKernelCpuSuspendIntr"}, - {0x5F10D406,WrapV_U, "sceKernelCpuResumeIntr"}, //int oldstat - {0x3b84732d,WrapV_U, "sceKernelCpuResumeIntrWithSync"}, - {0x47a0b729,WrapI_I, "sceKernelIsCpuIntrSuspended"}, //flags - {0xb55249d2,sceKernelIsCpuIntrEnable, "sceKernelIsCpuIntrEnable"}, - {0xa089eca4,WrapU_UUU, "sceKernelMemset"}, - {0xDC692EE3,WrapI_UI, "sceKernelTryLockLwMutex"}, - {0x37431849,WrapI_UI, "sceKernelTryLockLwMutex_600"}, - {0xbea46419,WrapI_UIU, "sceKernelLockLwMutex", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x1FC64E09,WrapI_UIU, "sceKernelLockLwMutexCB", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x15b6446b,WrapI_UI, "sceKernelUnlockLwMutex"}, - {0xc1734599,WrapI_UU, "sceKernelReferLwMutexStatus"}, - {0x293b45b8,WrapI_V, "sceKernelGetThreadId"}, - {0xD13BDE95,WrapI_V, "sceKernelCheckThreadStack"}, - {0x1839852A,WrapU_UUU, "sceKernelMemcpy"}, - {0xfa835cde,WrapI_I, "sceKernelGetTlsAddr"}, + {0x092968F4, &WrapI_V, "sceKernelCpuSuspendIntr", 'i', "" }, + {0X5F10D406, &WrapV_U, "sceKernelCpuResumeIntr", 'v', "x" }, + {0X3B84732D, &WrapV_U, "sceKernelCpuResumeIntrWithSync", 'v', "x" }, + {0X47A0B729, &WrapI_I, "sceKernelIsCpuIntrSuspended", 'i', "i" }, + {0xb55249d2, &WrapI_V, "sceKernelIsCpuIntrEnable", 'i', "", }, + {0XA089ECA4, &WrapU_UUU, "sceKernelMemset", 'x', "xxx" }, + {0XDC692EE3, &WrapI_UI, "sceKernelTryLockLwMutex", 'i', "xi" }, + {0X37431849, &WrapI_UI, "sceKernelTryLockLwMutex_600", 'i', "xi" }, + {0XBEA46419, &WrapI_UIU, "sceKernelLockLwMutex", 'i', "xix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X1FC64E09, &WrapI_UIU, "sceKernelLockLwMutexCB", 'i', "xix", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X15B6446B, &WrapI_UI, "sceKernelUnlockLwMutex", 'i', "xi" }, + {0XC1734599, &WrapI_UU, "sceKernelReferLwMutexStatus", 'i', "xx" }, + {0X293B45B8, &WrapI_V, "sceKernelGetThreadId", 'i', "" }, + {0XD13BDE95, &WrapI_V, "sceKernelCheckThreadStack", 'i', "" }, + {0X1839852A, &WrapU_UUU, "sceKernelMemcpy", 'x', "xxx" }, + {0XFA835CDE, &WrapI_I, "sceKernelGetTlsAddr", 'i', "i" }, }; static u32 sysclib_memcpy(u32 dst, u32 src, u32 size) { @@ -726,14 +726,14 @@ static u32 sysclib_memset(u32 destAddr, int data, int size) { const HLEFunction SysclibForKernel[] = { - {0xAB7592FF, WrapU_UUU, "memcpy"}, - {0x476FD94A, WrapU_UU, "strcat"}, - {0xC0AB8932, WrapI_UU, "strcmp"}, - {0xEC6F1CF2, WrapU_UU, "strcpy"}, - {0x52DF196C, WrapU_U, "strlen"}, - {0x81D0D1F7, WrapI_UUU, "memcmp"}, - {0x7661e728, WrapI_UU, "sprintf"}, - {0x10F3BB61, WrapU_UII, "memset" }, + {0XAB7592FF, &WrapU_UUU, "memcpy", 'x', "xxx" }, + {0X476FD94A, &WrapU_UU, "strcat", 'x', "xx" }, + {0XC0AB8932, &WrapI_UU, "strcmp", 'i', "xx" }, + {0XEC6F1CF2, &WrapU_UU, "strcpy", 'x', "xx" }, + {0X52DF196C, &WrapU_U, "strlen", 'x', "x" }, + {0X81D0D1F7, &WrapI_UUU, "memcmp", 'i', "xxx" }, + {0X7661E728, &WrapI_UU, "sprintf", 'i', "xx" }, + {0X10F3BB61, &WrapU_UII, "memset", 'x', "xii" }, }; void Register_Kernel_Library() @@ -748,15 +748,15 @@ void Register_SysclibForKernel() const HLEFunction InterruptManager[] = { - {0xCA04A2B9, WrapU_UUUU, "sceKernelRegisterSubIntrHandler"}, - {0xD61E6961, WrapU_UU, "sceKernelReleaseSubIntrHandler"}, - {0xFB8E22EC, WrapU_UU, "sceKernelEnableSubIntr"}, - {0x8A389411, WrapU_UU, "sceKernelDisableSubIntr"}, - {0x5CB5A78B, 0, "sceKernelSuspendSubIntr"}, - {0x7860E0DC, 0, "sceKernelResumeSubIntr"}, - {0xFC4374B8, 0, "sceKernelIsSubInterruptOccurred"}, - {0xD2E8363F, QueryIntrHandlerInfo, "QueryIntrHandlerInfo"}, // No sce prefix for some reason - {0xEEE43F47, 0, "sceKernelRegisterUserSpaceIntrStack"}, + {0XCA04A2B9, &WrapU_UUUU, "sceKernelRegisterSubIntrHandler", 'x', "xxxx" }, + {0XD61E6961, &WrapU_UU, "sceKernelReleaseSubIntrHandler", 'x', "xx" }, + {0XFB8E22EC, &WrapU_UU, "sceKernelEnableSubIntr", 'x', "xx" }, + {0X8A389411, &WrapU_UU, "sceKernelDisableSubIntr", 'x', "xx" }, + {0X5CB5A78B, nullptr, "sceKernelSuspendSubIntr", '?', "" }, + {0X7860E0DC, nullptr, "sceKernelResumeSubIntr", '?', "" }, + {0XFC4374B8, nullptr, "sceKernelIsSubInterruptOccurred", '?', "" }, + {0xD2E8363F, &WrapI_V, "QueryIntrHandlerInfo", 'i', "" }, // No sce prefix for some reason + {0XEEE43F47, nullptr, "sceKernelRegisterUserSpaceIntrStack", '?', "" }, }; diff --git a/Core/HLE/sceKernelMemory.cpp b/Core/HLE/sceKernelMemory.cpp index c11ee11489..80aca8aa5a 100644 --- a/Core/HLE/sceKernelMemory.cpp +++ b/Core/HLE/sceKernelMemory.cpp @@ -2264,36 +2264,36 @@ int sceKernelReferTlsplStatus(SceUID uid, u32 infoPtr) } const HLEFunction SysMemUserForUser[] = { - {0xA291F107,WrapU_V,"sceKernelMaxFreeMemSize"}, - {0xF919F628,WrapU_V,"sceKernelTotalFreeMemSize"}, - {0x3FC9AE6A,WrapU_V,"sceKernelDevkitVersion"}, - {0x237DBD4F,WrapI_ICIUU,"sceKernelAllocPartitionMemory"}, //(int size) ? - {0xB6D61D02,WrapI_I,"sceKernelFreePartitionMemory"}, //(void *ptr) ? - {0x9D9A5BA1,WrapU_I,"sceKernelGetBlockHeadAddr"}, //(void *ptr) ? - {0x13a5abef,WrapI_C,"sceKernelPrintf"}, - {0x7591c7db,&WrapI_I,"sceKernelSetCompiledSdkVersion"}, - {0x342061E5,&WrapI_I,"sceKernelSetCompiledSdkVersion370"}, - {0x315AD3A0,&WrapI_I,"sceKernelSetCompiledSdkVersion380_390"}, - {0xEBD5C3E6,&WrapI_I,"sceKernelSetCompiledSdkVersion395"}, - {0x057E7380,&WrapI_I,"sceKernelSetCompiledSdkVersion401_402"}, - {0xf77d77cb,&WrapI_I,"sceKernelSetCompilerVersion"}, - {0x91de343c,&WrapI_I,"sceKernelSetCompiledSdkVersion500_505"}, - {0x7893f79a,&WrapI_I,"sceKernelSetCompiledSdkVersion507"}, - {0x35669d4c,&WrapI_I,"sceKernelSetCompiledSdkVersion600_602"}, //?? - {0x1b4217bc,&WrapI_I,"sceKernelSetCompiledSdkVersion603_605"}, - {0x358ca1bb,&WrapI_I,"sceKernelSetCompiledSdkVersion606"}, - {0xfc114573,&WrapI_V,"sceKernelGetCompiledSdkVersion"}, - {0x2a3e5280,0,"sceKernelQueryMemoryInfo"}, - {0xacbd88ca,WrapU_V,"SysMemUserForUser_ACBD88CA"}, - {0x945e45da,WrapU_V,"SysMemUserForUser_945E45DA"}, - {0xa6848df8,0,"sceKernelSetUsersystemLibWork"}, - {0x6231a71d,0,"sceKernelSetPTRIG"}, - {0x39f49610,0,"sceKernelGetPTRIG"}, + {0XA291F107, &WrapU_V, "sceKernelMaxFreeMemSize", 'x', "" }, + {0XF919F628, &WrapU_V, "sceKernelTotalFreeMemSize", 'x', "" }, + {0X3FC9AE6A, &WrapU_V, "sceKernelDevkitVersion", 'x', "" }, + {0X237DBD4F, &WrapI_ICIUU, "sceKernelAllocPartitionMemory", 'i', "isixx"}, + {0XB6D61D02, &WrapI_I, "sceKernelFreePartitionMemory", 'i', "i" }, + {0X9D9A5BA1, &WrapU_I, "sceKernelGetBlockHeadAddr", 'x', "i" }, + {0X13A5ABEF, &WrapI_C, "sceKernelPrintf", 'i', "s" }, + {0X7591C7DB, &WrapI_I, "sceKernelSetCompiledSdkVersion", 'i', "i" }, + {0X342061E5, &WrapI_I, "sceKernelSetCompiledSdkVersion370", 'i', "i" }, + {0X315AD3A0, &WrapI_I, "sceKernelSetCompiledSdkVersion380_390", 'i', "i" }, + {0XEBD5C3E6, &WrapI_I, "sceKernelSetCompiledSdkVersion395", 'i', "i" }, + {0X057E7380, &WrapI_I, "sceKernelSetCompiledSdkVersion401_402", 'i', "i" }, + {0XF77D77CB, &WrapI_I, "sceKernelSetCompilerVersion", 'i', "i" }, + {0X91DE343C, &WrapI_I, "sceKernelSetCompiledSdkVersion500_505", 'i', "i" }, + {0X7893F79A, &WrapI_I, "sceKernelSetCompiledSdkVersion507", 'i', "i" }, + {0X35669D4C, &WrapI_I, "sceKernelSetCompiledSdkVersion600_602", 'i', "i" }, //?? + {0X1B4217BC, &WrapI_I, "sceKernelSetCompiledSdkVersion603_605", 'i', "i" }, + {0X358CA1BB, &WrapI_I, "sceKernelSetCompiledSdkVersion606", 'i', "i" }, + {0XFC114573, &WrapI_V, "sceKernelGetCompiledSdkVersion", 'i', "" }, + {0X2A3E5280, nullptr, "sceKernelQueryMemoryInfo", '?', "" }, + {0XACBD88CA, &WrapU_V, "SysMemUserForUser_ACBD88CA", 'x', "" }, + {0X945E45DA, &WrapU_V, "SysMemUserForUser_945E45DA", 'x', "" }, + {0XA6848DF8, nullptr, "sceKernelSetUsersystemLibWork", '?', "" }, + {0X6231A71D, nullptr, "sceKernelSetPTRIG", '?', "" }, + {0X39F49610, nullptr, "sceKernelGetPTRIG", '?', "" }, // Obscure raw block API - {0xDB83A952,WrapU_UU,"SysMemUserForUser_DB83A952"}, // GetMemoryBlockAddr - {0x50F61D8A,WrapU_U,"SysMemUserForUser_50F61D8A"}, // FreeMemoryBlock - {0xFE707FDF,WrapU_CUUU,"SysMemUserForUser_FE707FDF"}, // AllocMemoryBlock - {0xD8DE5C1E,WrapU_V,"SysMemUserForUser_D8DE5C1E"}, + {0XDB83A952, &WrapU_UU, "SysMemUserForUser_DB83A952", 'x', "xx" }, // GetMemoryBlockAddr + {0X50F61D8A, &WrapU_U, "SysMemUserForUser_50F61D8A", 'x', "x" }, // FreeMemoryBlock + {0XFE707FDF, &WrapU_CUUU, "SysMemUserForUser_FE707FDF", 'x', "sxxx" }, // AllocMemoryBlock + {0XD8DE5C1E, &WrapU_V, "SysMemUserForUser_D8DE5C1E", 'x', "" }, }; diff --git a/Core/HLE/sceKernelModule.cpp b/Core/HLE/sceKernelModule.cpp index a64361183e..7ecc3102b0 100644 --- a/Core/HLE/sceKernelModule.cpp +++ b/Core/HLE/sceKernelModule.cpp @@ -2316,34 +2316,34 @@ static u32 ModuleMgrForKernel_a1a78c58(const char *name, u32 flags, u32 optionAd const HLEFunction ModuleMgrForUser[] = { - {0x977DE386,&WrapU_CUU,"sceKernelLoadModule"}, - {0xb7f46618,&WrapU_UUU,"sceKernelLoadModuleByID"}, - {0x50F0C1EC,&WrapV_UUUUU,"sceKernelStartModule", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0xD675EBB8,WrapU_UUU, "sceKernelSelfStopUnloadModule"}, - {0xd1ff982a,&WrapU_UUUUU,"sceKernelStopModule", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED}, - {0x2e0911aa,WrapU_U,"sceKernelUnloadModule"}, - {0x710F61B5,0,"sceKernelLoadModuleMs"}, - {0xF9275D98,WrapI_UUUU,"sceKernelLoadModuleBufferUsbWlan"}, ///??? - {0xCC1D3699,0,"sceKernelStopUnloadSelfModule"}, - {0x748CBED9,WrapU_UU,"sceKernelQueryModuleInfo"}, - {0xd8b73127,&WrapU_U, "sceKernelGetModuleIdByAddress"}, - {0xf0a26395,WrapU_V, "sceKernelGetModuleId"}, - {0x8f2df740,WrapU_UUUUU,"sceKernelStopUnloadSelfModuleWithStatus"}, - {0xfef27dc1,&WrapU_CU , "sceKernelLoadModuleDNAS"}, - {0x644395e2,WrapU_UUU,"sceKernelGetModuleIdList"}, - {0xf2d8d1b4,&WrapU_CUU,"sceKernelLoadModuleNpDrm"}, - {0xe4c4211c,0,"ModuleMgrForUser_E4C4211C"}, - {0xfbe27467,0,"ModuleMgrForUser_FBE27467"}, + {0X977DE386, &WrapU_CUU, "sceKernelLoadModule", 'x', "sxx" }, + {0XB7F46618, &WrapU_UUU, "sceKernelLoadModuleByID", 'x', "xxx" }, + {0X50F0C1EC, &WrapV_UUUUU, "sceKernelStartModule", 'v', "xxxxx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0XD675EBB8, &WrapU_UUU, "sceKernelSelfStopUnloadModule", 'x', "xxx" }, + {0XD1FF982A, &WrapU_UUUUU, "sceKernelStopModule", 'x', "xxxxx", HLE_NOT_IN_INTERRUPT | HLE_NOT_DISPATCH_SUSPENDED }, + {0X2E0911AA, &WrapU_U, "sceKernelUnloadModule", 'x', "x" }, + {0X710F61B5, nullptr, "sceKernelLoadModuleMs", '?', "" }, + {0XF9275D98, &WrapI_UUUU, "sceKernelLoadModuleBufferUsbWlan", 'i', "xxxx" }, /// ?? + {0XCC1D3699, nullptr, "sceKernelStopUnloadSelfModule", '?', "" }, + {0X748CBED9, &WrapU_UU, "sceKernelQueryModuleInfo", 'x', "xx" }, + {0XD8B73127, &WrapU_U, "sceKernelGetModuleIdByAddress", 'x', "x" }, + {0XF0A26395, &WrapU_V, "sceKernelGetModuleId", 'x', "" }, + {0X8F2DF740, &WrapU_UUUUU, "sceKernelStopUnloadSelfModuleWithStatus", 'x', "xxxxx" }, + {0XFEF27DC1, &WrapU_CU, "sceKernelLoadModuleDNAS", 'x', "sx" }, + {0X644395E2, &WrapU_UUU, "sceKernelGetModuleIdList", 'x', "xxx" }, + {0XF2D8D1B4, &WrapU_CUU, "sceKernelLoadModuleNpDrm", 'x', "sxx" }, + {0XE4C4211C, nullptr, "ModuleMgrForUser_E4C4211C", '?', "" }, + {0XFBE27467, nullptr, "ModuleMgrForUser_FBE27467", '?', "" }, }; const HLEFunction ModuleMgrForKernel[] = { - {0x50f0c1ec,&WrapV_UUUUU, "ModuleMgrForKernel_50f0c1ec"},//Not sure right - {0x977de386, &WrapU_CUU, "ModuleMgrForKernel_977de386"},//Not sure right - {0xa1a78c58, &WrapU_CUU, "ModuleMgrForKernel_a1a78c58"}, //fix for tiger x dragon - {0x748CBED9, WrapU_UU, "sceKernelQueryModuleInfo" },//Bugz Homebrew - {0x644395e2, WrapU_UUU, "sceKernelGetModuleIdList" },//Bugz Homebrew + {0X50F0C1EC, &WrapV_UUUUU, "ModuleMgrForKernel_50f0c1ec", 'v', "xxxxx" },//Not sure right + {0X977DE386, &WrapU_CUU, "ModuleMgrForKernel_977de386", 'x', "sxx" },//Not sure right + {0XA1A78C58, &WrapU_CUU, "ModuleMgrForKernel_a1a78c58", 'x', "sxx" }, //fix for tiger x dragon + {0X748CBED9, &WrapU_UU, "sceKernelQueryModuleInfo", 'x', "xx" },//Bugz Homebrew + {0X644395E2, &WrapU_UUU, "sceKernelGetModuleIdList", 'x', "xxx" },//Bugz Homebrew }; void Register_ModuleMgrForUser() diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 8096841f96..e901488772 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -2553,11 +2553,11 @@ SceUID sceKernelGetThreadId() return currentThread; } -void sceKernelGetThreadCurrentPriority() +int sceKernelGetThreadCurrentPriority() { u32 retVal = __GetCurrentThread()->nt.currentPriority; DEBUG_LOG(SCEKERNEL,"%i = sceKernelGetThreadCurrentPriority()", retVal); - RETURN(retVal); + return retVal; } int sceKernelChangeCurrentThreadAttr(u32 clearAttr, u32 setAttr) diff --git a/Core/HLE/sceKernelThread.h b/Core/HLE/sceKernelThread.h index 8376de43a7..df7adbc5d1 100644 --- a/Core/HLE/sceKernelThread.h +++ b/Core/HLE/sceKernelThread.h @@ -43,7 +43,7 @@ void sceKernelExitDeleteThread(int exitStatus); void sceKernelExitThread(int exitStatus); void _sceKernelExitThread(int exitStatus); SceUID sceKernelGetThreadId(); -void sceKernelGetThreadCurrentPriority(); +int sceKernelGetThreadCurrentPriority(); int __KernelStartThread(SceUID threadToStartID, int argSize, u32 argBlockPtr, bool forceArgs = false); int sceKernelStartThread(SceUID threadToStartID, int argSize, u32 argBlockPtr); u32 sceKernelSuspendDispatchThread(); diff --git a/Core/HLE/sceMd5.cpp b/Core/HLE/sceMd5.cpp index 0b85c1f6af..7df8c50ac4 100644 --- a/Core/HLE/sceMd5.cpp +++ b/Core/HLE/sceMd5.cpp @@ -173,10 +173,10 @@ int sceKernelUtilsSha1BlockResult(u32 ctxAddr, u32 digestAddr) { const HLEFunction sceMd5[] = { - {0x19884A15, WrapI_U, "sceMd5BlockInit"}, - {0xA30206C2, WrapI_UUU, "sceMd5BlockUpdate"}, - {0x4876AFFF, WrapI_UU, "sceMd5BlockResult"}, - {0x98E31A9E, WrapI_UUU, "sceMd5Digest"}, + {0X19884A15, &WrapI_U, "sceMd5BlockInit", 'i', "x" }, + {0XA30206C2, &WrapI_UUU, "sceMd5BlockUpdate", 'i', "xxx"}, + {0X4876AFFF, &WrapI_UU, "sceMd5BlockResult", 'i', "xx" }, + {0X98E31A9E, &WrapI_UUU, "sceMd5Digest", 'i', "xxx"}, }; void Register_sceMd5() { diff --git a/Core/HLE/sceMp3.cpp b/Core/HLE/sceMp3.cpp index 432fb929af..f6ff940636 100644 --- a/Core/HLE/sceMp3.cpp +++ b/Core/HLE/sceMp3.cpp @@ -563,30 +563,30 @@ static u32 sceMp3LowLevelDecode(u32 mp3, u32 sourceAddr, u32 sourceBytesConsumed } const HLEFunction sceMp3[] = { - {0x07EC321A,WrapU_U,"sceMp3ReserveMp3Handle"}, - {0x0DB149F4,WrapI_UI,"sceMp3NotifyAddStreamData"}, - {0x2A368661,WrapI_U,"sceMp3ResetPlayPosition"}, - {0x354D27EA,WrapI_U,"sceMp3GetSumDecodedSample"}, - {0x35750070,WrapI_V,"sceMp3InitResource"}, - {0x3C2FA058,WrapI_V,"sceMp3TermResource"}, - {0x3CEF484F,WrapI_UI,"sceMp3SetLoopNum"}, - {0x44E07129,WrapI_U,"sceMp3Init"}, - {0x732B042A,WrapU_V,"sceMp3EndEntry"}, - {0x7F696782,WrapI_U,"sceMp3GetMp3ChannelNum"}, - {0x87677E40,WrapI_U,"sceMp3GetBitRate"}, - {0x87C263D1,WrapI_U,"sceMp3GetMaxOutputSample"}, - {0x8AB81558,WrapU_V,"sceMp3StartEntry"}, - {0x8F450998,WrapI_U,"sceMp3GetSamplingRate"}, - {0xA703FE0F,WrapI_UUUU,"sceMp3GetInfoToAddStreamData"}, - {0xD021C0FB,WrapI_UU,"sceMp3Decode"}, - {0xD0A56296,WrapI_U,"sceMp3CheckStreamDataNeeded"}, - {0xD8F54A51,WrapI_U,"sceMp3GetLoopNum"}, - {0xF5478233,WrapI_U,"sceMp3ReleaseMp3Handle"}, - {0xAE6D2027,WrapU_U,"sceMp3GetMPEGVersion"}, - {0x3548AEC8,WrapU_U,"sceMp3GetFrameNum"}, - {0x0840e808,WrapU_UI,"sceMp3ResetPlayPositionByFrame"}, - {0x1b839b83,WrapU_U,"sceMp3LowLevelInit"}, - {0xe3ee2c81,WrapU_UUUUU,"sceMp3LowLevelDecode"} + {0X07EC321A, &WrapU_U, "sceMp3ReserveMp3Handle", 'x', "x" }, + {0X0DB149F4, &WrapI_UI, "sceMp3NotifyAddStreamData", 'i', "xi" }, + {0X2A368661, &WrapI_U, "sceMp3ResetPlayPosition", 'i', "x" }, + {0X354D27EA, &WrapI_U, "sceMp3GetSumDecodedSample", 'i', "x" }, + {0X35750070, &WrapI_V, "sceMp3InitResource", 'i', "" }, + {0X3C2FA058, &WrapI_V, "sceMp3TermResource", 'i', "" }, + {0X3CEF484F, &WrapI_UI, "sceMp3SetLoopNum", 'i', "xi" }, + {0X44E07129, &WrapI_U, "sceMp3Init", 'i', "x" }, + {0X732B042A, &WrapU_V, "sceMp3EndEntry", 'x', "" }, + {0X7F696782, &WrapI_U, "sceMp3GetMp3ChannelNum", 'i', "x" }, + {0X87677E40, &WrapI_U, "sceMp3GetBitRate", 'i', "x" }, + {0X87C263D1, &WrapI_U, "sceMp3GetMaxOutputSample", 'i', "x" }, + {0X8AB81558, &WrapU_V, "sceMp3StartEntry", 'x', "" }, + {0X8F450998, &WrapI_U, "sceMp3GetSamplingRate", 'i', "x" }, + {0XA703FE0F, &WrapI_UUUU, "sceMp3GetInfoToAddStreamData", 'i', "xxxx" }, + {0XD021C0FB, &WrapI_UU, "sceMp3Decode", 'i', "xx" }, + {0XD0A56296, &WrapI_U, "sceMp3CheckStreamDataNeeded", 'i', "x" }, + {0XD8F54A51, &WrapI_U, "sceMp3GetLoopNum", 'i', "x" }, + {0XF5478233, &WrapI_U, "sceMp3ReleaseMp3Handle", 'i', "x" }, + {0XAE6D2027, &WrapU_U, "sceMp3GetMPEGVersion", 'x', "x" }, + {0X3548AEC8, &WrapU_U, "sceMp3GetFrameNum", 'x', "x" }, + {0X0840E808, &WrapU_UI, "sceMp3ResetPlayPositionByFrame", 'x', "xi" }, + {0X1B839B83, &WrapU_U, "sceMp3LowLevelInit", 'x', "x" }, + {0XE3EE2C81, &WrapU_UUUUU, "sceMp3LowLevelDecode", 'x', "xxxxx"} }; void Register_sceMp3() { diff --git a/Core/HLE/sceMp4.cpp b/Core/HLE/sceMp4.cpp index ac3c4ca86a..99dd7ac4c7 100644 --- a/Core/HLE/sceMp4.cpp +++ b/Core/HLE/sceMp4.cpp @@ -399,62 +399,62 @@ static u32 sceAacResetPlayPosition(u32 id) const HLEFunction sceMp4[] = { - {0x68651CBC, WrapU_V, "sceMp4Init"}, - {0x9042B257, WrapU_V, "sceMp4Finish"}, - {0xB1221EE7, WrapU_UUUU, "sceMp4Create"}, - {0x538C2057, WrapU_V, "sceMp4Delete"}, - {0x113E9E7B, WrapU_V, "sceMp4GetNumberOfMetaData"}, - {0x7443AF1D, WrapU_UU, "sceMp4GetMovieInfo"}, - {0x5EB65F26, WrapU_V, "sceMp4GetNumberOfSpecificTrack"}, - {0x7ADFD01C, WrapU_UUUUU, "sceMp4RegistTrack"}, - {0xBCA9389C, WrapU_UUUUU, "sceMp4TrackSampleBufQueryMemSize"}, - {0x9C8F4FC1, WrapU_UUUUUUU, "sceMp4TrackSampleBufConstruct"}, - {0x0F0187D2, WrapU_V, "sceMp4GetAvcTrackInfoData"}, - {0x9CE6F5CF, WrapU_V, "sceMp4GetAacTrackInfoData"}, - {0x4ED4AB1E, WrapU_I, "sceMp4AacDecodeInitResource"}, - {0x10EE0D2C, WrapU_I, "sceMp4AacDecodeInit"}, - {0x496E8A65, WrapU_V, "sceMp4TrackSampleBufFlush"}, - {0xB4B400D1, WrapU_V, "sceMp4GetSampleNumWithTimeStamp"}, - {0xF7C51EC1, WrapU_V, "sceMp4GetSampleInfo"}, - {0x74A1CA3E, WrapU_V, "sceMp4SearchSyncSampleNum"}, - {0xD8250B75, 0, "sceMp4PutSampleNum"}, - {0x8754ECB8, WrapU_UU, "sceMp4TrackSampleBufAvailableSize"}, - {0x31BCD7E0, 0, "sceMp4TrackSampleBufPut"}, - {0x5601A6F0, WrapU_UUUU, "sceMp4GetAacAu"}, - {0x7663CB5C, WrapU_UUUUU, "sceMp4AacDecode"}, - {0x503A3CBA, WrapU_UUUU, "sceMp4GetAvcAu"}, - {0x01C76489, 0, "sceMp4TrackSampleBufDestruct"}, - {0x6710FE77, 0, "sceMp4UnregistTrack"}, - {0x5D72B333, 0, "sceMp4AacDecodeExit"}, - {0x7D332394, 0, "sceMp4AacDecodeTermResource"}, - {0x131BDE57, WrapU_UUU, "sceMp4InitAu"}, - {0x17EAA97D, 0, "sceMp4GetAvcAuWithoutSampleBuf"}, - {0x28CCB940, 0, "sceMp4GetTrackEditList"}, - {0x3069C2B5, 0, "sceMp4GetAvcParamSet"}, - {0xD2AC9A7E, 0, "sceMp4GetMetaData"}, - {0x4FB5B756, 0, "sceMp4GetMetaDataInfo"}, - {0x427BEF7F, 0, "sceMp4GetTrackNumOfEditList"}, - {0x532029B8, 0, "sceMp4GetAacAuWithoutSampleBuf"}, - {0xA6C724DC, 0, "sceMp4GetSampleNum"}, - {0x3C2183C7, 0, "mp4msv_3C2183C7"}, - {0x9CA13D1A, 0, "mp4msv_9CA13D1A"}, + {0X68651CBC, &WrapU_V, "sceMp4Init", 'x', "" }, + {0X9042B257, &WrapU_V, "sceMp4Finish", 'x', "" }, + {0XB1221EE7, &WrapU_UUUU, "sceMp4Create", 'x', "xxxx" }, + {0X538C2057, &WrapU_V, "sceMp4Delete", 'x', "" }, + {0X113E9E7B, &WrapU_V, "sceMp4GetNumberOfMetaData", 'x', "" }, + {0X7443AF1D, &WrapU_UU, "sceMp4GetMovieInfo", 'x', "xx" }, + {0X5EB65F26, &WrapU_V, "sceMp4GetNumberOfSpecificTrack", 'x', "" }, + {0X7ADFD01C, &WrapU_UUUUU, "sceMp4RegistTrack", 'x', "xxxxx" }, + {0XBCA9389C, &WrapU_UUUUU, "sceMp4TrackSampleBufQueryMemSize", 'x', "xxxxx" }, + {0X9C8F4FC1, &WrapU_UUUUUUU, "sceMp4TrackSampleBufConstruct", 'x', "xxxxxxx"}, + {0X0F0187D2, &WrapU_V, "sceMp4GetAvcTrackInfoData", 'x', "" }, + {0X9CE6F5CF, &WrapU_V, "sceMp4GetAacTrackInfoData", 'x', "" }, + {0X4ED4AB1E, &WrapU_I, "sceMp4AacDecodeInitResource", 'x', "i" }, + {0X10EE0D2C, &WrapU_I, "sceMp4AacDecodeInit", 'x', "i" }, + {0X496E8A65, &WrapU_V, "sceMp4TrackSampleBufFlush", 'x', "" }, + {0XB4B400D1, &WrapU_V, "sceMp4GetSampleNumWithTimeStamp", 'x', "" }, + {0XF7C51EC1, &WrapU_V, "sceMp4GetSampleInfo", 'x', "" }, + {0X74A1CA3E, &WrapU_V, "sceMp4SearchSyncSampleNum", 'x', "" }, + {0XD8250B75, nullptr, "sceMp4PutSampleNum", '?', "" }, + {0X8754ECB8, &WrapU_UU, "sceMp4TrackSampleBufAvailableSize", 'x', "xx" }, + {0X31BCD7E0, nullptr, "sceMp4TrackSampleBufPut", '?', "" }, + {0X5601A6F0, &WrapU_UUUU, "sceMp4GetAacAu", 'x', "xxxx" }, + {0X7663CB5C, &WrapU_UUUUU, "sceMp4AacDecode", 'x', "xxxxx" }, + {0X503A3CBA, &WrapU_UUUU, "sceMp4GetAvcAu", 'x', "xxxx" }, + {0X01C76489, nullptr, "sceMp4TrackSampleBufDestruct", '?', "" }, + {0X6710FE77, nullptr, "sceMp4UnregistTrack", '?', "" }, + {0X5D72B333, nullptr, "sceMp4AacDecodeExit", '?', "" }, + {0X7D332394, nullptr, "sceMp4AacDecodeTermResource", '?', "" }, + {0X131BDE57, &WrapU_UUU, "sceMp4InitAu", 'x', "xxx" }, + {0X17EAA97D, nullptr, "sceMp4GetAvcAuWithoutSampleBuf", '?', "" }, + {0X28CCB940, nullptr, "sceMp4GetTrackEditList", '?', "" }, + {0X3069C2B5, nullptr, "sceMp4GetAvcParamSet", '?', "" }, + {0XD2AC9A7E, nullptr, "sceMp4GetMetaData", '?', "" }, + {0X4FB5B756, nullptr, "sceMp4GetMetaDataInfo", '?', "" }, + {0X427BEF7F, nullptr, "sceMp4GetTrackNumOfEditList", '?', "" }, + {0X532029B8, nullptr, "sceMp4GetAacAuWithoutSampleBuf", '?', "" }, + {0XA6C724DC, nullptr, "sceMp4GetSampleNum", '?', "" }, + {0X3C2183C7, nullptr, "mp4msv_3C2183C7", '?', "" }, + {0X9CA13D1A, nullptr, "mp4msv_9CA13D1A", '?', "" }, }; // 395 const HLEFunction sceAac[] = { - {0xE0C89ACA, WrapU_U, "sceAacInit"}, - {0x33B8C009, WrapU_U, "sceAacExit"}, - {0x5CFFC57C, WrapU_U, "sceAacInitResource"}, - {0x23D35CAE, WrapU_V, "sceAacTermResource"}, - {0x7E4CFEE4, WrapU_UU, "sceAacDecode"}, - {0x523347D9, WrapU_U, "sceAacGetLoopNum"}, - {0xBBDD6403, WrapU_UI, "sceAacSetLoopNum"}, - {0xD7C51541, WrapI_U, "sceAacCheckStreamDataNeeded"}, - {0xAC6DCBE3, WrapU_UI, "sceAacNotifyAddStreamData"}, - {0x02098C69, WrapU_UUUU, "sceAacGetInfoToAddStreamData"}, - {0x6DC7758A, WrapU_U, "sceAacGetMaxOutputSample"}, - {0x506BF66C, WrapU_U, "sceAacGetSumDecodedSample"}, - {0xD2DA2BBA, WrapU_U, "sceAacResetPlayPosition"}, + {0XE0C89ACA, &WrapU_U, "sceAacInit", 'x', "x" }, + {0X33B8C009, &WrapU_U, "sceAacExit", 'x', "x" }, + {0X5CFFC57C, &WrapU_U, "sceAacInitResource", 'x', "x" }, + {0X23D35CAE, &WrapU_V, "sceAacTermResource", 'x', "" }, + {0X7E4CFEE4, &WrapU_UU, "sceAacDecode", 'x', "xx" }, + {0X523347D9, &WrapU_U, "sceAacGetLoopNum", 'x', "x" }, + {0XBBDD6403, &WrapU_UI, "sceAacSetLoopNum", 'x', "xi" }, + {0XD7C51541, &WrapI_U, "sceAacCheckStreamDataNeeded", 'i', "x" }, + {0XAC6DCBE3, &WrapU_UI, "sceAacNotifyAddStreamData", 'x', "xi" }, + {0X02098C69, &WrapU_UUUU, "sceAacGetInfoToAddStreamData", 'x', "xxxx" }, + {0X6DC7758A, &WrapU_U, "sceAacGetMaxOutputSample", 'x', "x" }, + {0X506BF66C, &WrapU_U, "sceAacGetSumDecodedSample", 'x', "x" }, + {0XD2DA2BBA, &WrapU_U, "sceAacResetPlayPosition", 'x', "x" }, }; void Register_sceMp4() diff --git a/Core/HLE/sceMpeg.cpp b/Core/HLE/sceMpeg.cpp index ff2ec5158f..c22fa87243 100644 --- a/Core/HLE/sceMpeg.cpp +++ b/Core/HLE/sceMpeg.cpp @@ -2162,65 +2162,65 @@ static u32 sceMpegFlushAu(u32 mpeg) const HLEFunction sceMpeg[] = { - {0xe1ce83a7,WrapI_UUUU,"sceMpegGetAtracAu"}, - {0xfe246728,WrapI_UUUU,"sceMpegGetAvcAu"}, - {0xd8c5f121,WrapU_UUUUUUU,"sceMpegCreate"}, - {0xf8dcb679,WrapI_UUU,"sceMpegQueryAtracEsSize"}, - {0xc132e22f,WrapU_V,"sceMpegQueryMemSize"}, - {0x21ff80e4,WrapI_UUU,"sceMpegQueryStreamOffset"}, - {0x611e9e11,WrapU_UU,"sceMpegQueryStreamSize"}, - {0x42560f23,WrapI_UUU,"sceMpegRegistStream"}, - {0x591a4aa2,WrapU_UI,"sceMpegUnRegistStream"}, - {0x707b7629,WrapU_U,"sceMpegFlushAllStream"}, - {0x500F0429,WrapU_UI,"sceMpegFlushStream"}, - {0xa780cf7e,WrapI_U,"sceMpegMallocAvcEsBuf"}, - {0xceb870b1,WrapI_UI,"sceMpegFreeAvcEsBuf"}, - {0x167afd9e,WrapI_UUU,"sceMpegInitAu"}, - {0x682a619b,WrapU_V,"sceMpegInit"}, - {0x606a4649,WrapI_U,"sceMpegDelete"}, - {0x874624d6,WrapU_V,"sceMpegFinish"}, - {0x800c44df,WrapU_UUUI,"sceMpegAtracDecode"}, - {0x0e3c2e9d,&WrapU_UUUUU,"sceMpegAvcDecode"}, - {0x740fccd1,&WrapU_UUUU,"sceMpegAvcDecodeStop"}, - {0x4571cc64,&WrapU_U,"sceMpegAvcDecodeFlush"}, - {0x0f6c18d7,&WrapI_UU,"sceMpegAvcDecodeDetail"}, - {0xa11c7026,WrapI_UU,"sceMpegAvcDecodeMode"}, - {0x37295ed8,WrapU_UUUUUU,"sceMpegRingbufferConstruct"}, - {0x13407f13,WrapU_U,"sceMpegRingbufferDestruct"}, - {0xb240a59e,WrapU_UUU,"sceMpegRingbufferPut"}, - {0xb5f6dc87,WrapI_U,"sceMpegRingbufferAvailableSize"}, - {0xd7a29f46,WrapU_I,"sceMpegRingbufferQueryMemSize"}, - {0x769BEBB6,WrapI_U,"sceMpegRingbufferQueryPackNum"}, - {0x211a057c,WrapI_UUUUU,"sceMpegAvcQueryYCbCrSize"}, - {0xf0eb1125,WrapI_UUUU,"sceMpegAvcDecodeYCbCr"}, - {0xf2930c9c,WrapU_UUU,"sceMpegAvcDecodeStopYCbCr"}, - {0x67179b1b,WrapU_UIIIU,"sceMpegAvcInitYCbCr"}, - {0x0558B075,WrapU_UUU,"sceMpegAvcCopyYCbCr"}, - {0x31bd0272,WrapU_UUUIU,"sceMpegAvcCsc"}, - {0x9DCFB7EA,WrapU_UII,"sceMpegChangeGetAuMode"}, - {0x8C1E027D,WrapU_UIUU,"sceMpegGetPcmAu"}, - {0xC02CF6B5,WrapI_UUU,"sceMpegQueryPcmEsSize"}, - {0xC45C99CC,WrapU_UUU,"sceMpegQueryUserdataEsSize"}, - {0x234586AE,WrapU_UUI,"sceMpegChangeGetAvcAuMode"}, - {0x63B9536A,WrapU_U,"sceMpegAvcResourceGetAvcDecTopAddr"}, - {0x8160a2fe,WrapU_U,"sceMpegAvcResourceFinish"}, - {0xaf26bb01,WrapU_U,"sceMpegAvcResourceGetAvcEsBuf"}, - {0xfcbdb5ad,WrapU_U,"sceMpegAvcResourceInit"}, - {0xF5E7EA31,WrapI_UUUI,"sceMpegAvcConvertToYuv420"}, - {0x01977054,WrapI_UUUU,"sceMpegGetUserdataAu"}, - {0x3c37a7a6,WrapU_UU,"sceMpegNextAvcRpAu"}, - {0x11f95cf1,WrapU_U,"sceMpegGetAvcNalAu"}, - {0xab0e9556,WrapU_U,"sceMpegAvcDecodeDetailIndex"}, - {0xcf3547a2,WrapU_U,"sceMpegAvcDecodeDetail2"}, - {0x921fcccf,WrapU_U,"sceMpegGetAvcEsAu"}, - {0xE95838F6,WrapU_U,"sceMpegAvcCscInfo"}, - {0xD1CE4950,WrapU_U,"sceMpegAvcCscMode"}, - {0xDBB60658,WrapU_U,"sceMpegFlushAu"}, - {0xd4dd6e75,0,"sceMpeg_D4DD6E75"}, - {0x11cab459,0,"sceMpeg_11CAB459"}, - {0xc345ded2,0,"sceMpeg_C345DED2"}, - {0xb27711a8,0,"sceMpeg_B27711A8"}, - {0x988e9e12,0,"sceMpeg_988E9E12"}, + {0XE1CE83A7, &WrapI_UUUU, "sceMpegGetAtracAu", 'i', "xxxx" }, + {0XFE246728, &WrapI_UUUU, "sceMpegGetAvcAu", 'i', "xxxx" }, + {0XD8C5F121, &WrapU_UUUUUUU, "sceMpegCreate", 'x', "xxxxxxx"}, + {0XF8DCB679, &WrapI_UUU, "sceMpegQueryAtracEsSize", 'i', "xxx" }, + {0XC132E22F, &WrapU_V, "sceMpegQueryMemSize", 'x', "" }, + {0X21FF80E4, &WrapI_UUU, "sceMpegQueryStreamOffset", 'i', "xxx" }, + {0X611E9E11, &WrapU_UU, "sceMpegQueryStreamSize", 'x', "xx" }, + {0X42560F23, &WrapI_UUU, "sceMpegRegistStream", 'i', "xxx" }, + {0X591A4AA2, &WrapU_UI, "sceMpegUnRegistStream", 'x', "xi" }, + {0X707B7629, &WrapU_U, "sceMpegFlushAllStream", 'x', "x" }, + {0X500F0429, &WrapU_UI, "sceMpegFlushStream", 'x', "xi" }, + {0XA780CF7E, &WrapI_U, "sceMpegMallocAvcEsBuf", 'i', "x" }, + {0XCEB870B1, &WrapI_UI, "sceMpegFreeAvcEsBuf", 'i', "xi" }, + {0X167AFD9E, &WrapI_UUU, "sceMpegInitAu", 'i', "xxx" }, + {0X682A619B, &WrapU_V, "sceMpegInit", 'x', "" }, + {0X606A4649, &WrapI_U, "sceMpegDelete", 'i', "x" }, + {0X874624D6, &WrapU_V, "sceMpegFinish", 'x', "" }, + {0X800C44DF, &WrapU_UUUI, "sceMpegAtracDecode", 'x', "xxxi" }, + {0X0E3C2E9D, &WrapU_UUUUU, "sceMpegAvcDecode", 'x', "xxxxx" }, + {0X740FCCD1, &WrapU_UUUU, "sceMpegAvcDecodeStop", 'x', "xxxx" }, + {0X4571CC64, &WrapU_U, "sceMpegAvcDecodeFlush", 'x', "x" }, + {0X0F6C18D7, &WrapI_UU, "sceMpegAvcDecodeDetail", 'i', "xx" }, + {0XA11C7026, &WrapI_UU, "sceMpegAvcDecodeMode", 'i', "xx" }, + {0X37295ED8, &WrapU_UUUUUU, "sceMpegRingbufferConstruct", 'x', "xxxxxx" }, + {0X13407F13, &WrapU_U, "sceMpegRingbufferDestruct", 'x', "x" }, + {0XB240A59E, &WrapU_UUU, "sceMpegRingbufferPut", 'x', "xxx" }, + {0XB5F6DC87, &WrapI_U, "sceMpegRingbufferAvailableSize", 'i', "x" }, + {0XD7A29F46, &WrapU_I, "sceMpegRingbufferQueryMemSize", 'x', "i" }, + {0X769BEBB6, &WrapI_U, "sceMpegRingbufferQueryPackNum", 'i', "x" }, + {0X211A057C, &WrapI_UUUUU, "sceMpegAvcQueryYCbCrSize", 'i', "xxxxx" }, + {0XF0EB1125, &WrapI_UUUU, "sceMpegAvcDecodeYCbCr", 'i', "xxxx" }, + {0XF2930C9C, &WrapU_UUU, "sceMpegAvcDecodeStopYCbCr", 'x', "xxx" }, + {0X67179B1B, &WrapU_UIIIU, "sceMpegAvcInitYCbCr", 'x', "xiiix" }, + {0X0558B075, &WrapU_UUU, "sceMpegAvcCopyYCbCr", 'x', "xxx" }, + {0X31BD0272, &WrapU_UUUIU, "sceMpegAvcCsc", 'x', "xxxix" }, + {0X9DCFB7EA, &WrapU_UII, "sceMpegChangeGetAuMode", 'x', "xii" }, + {0X8C1E027D, &WrapU_UIUU, "sceMpegGetPcmAu", 'x', "xixx" }, + {0XC02CF6B5, &WrapI_UUU, "sceMpegQueryPcmEsSize", 'i', "xxx" }, + {0XC45C99CC, &WrapU_UUU, "sceMpegQueryUserdataEsSize", 'x', "xxx" }, + {0X234586AE, &WrapU_UUI, "sceMpegChangeGetAvcAuMode", 'x', "xxi" }, + {0X63B9536A, &WrapU_U, "sceMpegAvcResourceGetAvcDecTopAddr", 'x', "x" }, + {0X8160A2FE, &WrapU_U, "sceMpegAvcResourceFinish", 'x', "x" }, + {0XAF26BB01, &WrapU_U, "sceMpegAvcResourceGetAvcEsBuf", 'x', "x" }, + {0XFCBDB5AD, &WrapU_U, "sceMpegAvcResourceInit", 'x', "x" }, + {0XF5E7EA31, &WrapI_UUUI, "sceMpegAvcConvertToYuv420", 'i', "xxxi" }, + {0X01977054, &WrapI_UUUU, "sceMpegGetUserdataAu", 'i', "xxxx" }, + {0X3C37A7A6, &WrapU_UU, "sceMpegNextAvcRpAu", 'x', "xx" }, + {0X11F95CF1, &WrapU_U, "sceMpegGetAvcNalAu", 'x', "x" }, + {0XAB0E9556, &WrapU_U, "sceMpegAvcDecodeDetailIndex", 'x', "x" }, + {0XCF3547A2, &WrapU_U, "sceMpegAvcDecodeDetail2", 'x', "x" }, + {0X921FCCCF, &WrapU_U, "sceMpegGetAvcEsAu", 'x', "x" }, + {0XE95838F6, &WrapU_U, "sceMpegAvcCscInfo", 'x', "x" }, + {0XD1CE4950, &WrapU_U, "sceMpegAvcCscMode", 'x', "x" }, + {0XDBB60658, &WrapU_U, "sceMpegFlushAu", 'x', "x" }, + {0XD4DD6E75, nullptr, "sceMpeg_D4DD6E75", '?', "" }, + {0X11CAB459, nullptr, "sceMpeg_11CAB459", '?', "" }, + {0XC345DED2, nullptr, "sceMpeg_C345DED2", '?', "" }, + {0XB27711A8, nullptr, "sceMpeg_B27711A8", '?', "" }, + {0X988E9E12, nullptr, "sceMpeg_988E9E12", '?', "" }, }; void Register_sceMpeg() @@ -2251,12 +2251,12 @@ static u32 sceMpegbase_BEA18F91(u32 p) const HLEFunction sceMpegbase[] = { - { 0xBEA18F91, WrapU_U, "sceMpegbase_BEA18F91" }, - { 0x492B5E4B, 0, "sceMpegBaseCscInit" }, - { 0x0530BE4E, 0, "sceMpegbase_0530BE4E" }, - { 0x91929A21, 0, "sceMpegBaseCscAvc" }, - { 0x304882E1, 0, "sceMpegBaseCscAvcRange" }, - { 0x7AC0321A, 0, "sceMpegBaseYCrCbCopy" } + {0XBEA18F91, &WrapU_U, "sceMpegbase_BEA18F91", 'x', "x" }, + {0X492B5E4B, nullptr, "sceMpegBaseCscInit", '?', "" }, + {0X0530BE4E, nullptr, "sceMpegbase_0530BE4E", '?', "" }, + {0X91929A21, nullptr, "sceMpegBaseCscAvc", '?', "" }, + {0X304882E1, nullptr, "sceMpegBaseCscAvcRange", '?', "" }, + {0X7AC0321A, nullptr, "sceMpegBaseYCrCbCopy", '?', "" } }; void Register_sceMpegbase() diff --git a/Core/HLE/sceMt19937.cpp b/Core/HLE/sceMt19937.cpp index 9cfba3031c..62ea11fcb6 100644 --- a/Core/HLE/sceMt19937.cpp +++ b/Core/HLE/sceMt19937.cpp @@ -44,8 +44,8 @@ static u32 sceMt19937UInt(u32 mt19937Addr) const HLEFunction sceMt19937[] = { - {0xECF5D379, WrapU_UU, "sceMt19937Init"}, - {0xF40C98E6, WrapU_U, "sceMt19937UInt"}, + {0XECF5D379, &WrapU_UU, "sceMt19937Init", 'x', "xx"}, + {0XF40C98E6, &WrapU_U, "sceMt19937UInt", 'x', "x" }, }; void Register_sceMt19937() diff --git a/Core/HLE/sceNet.cpp b/Core/HLE/sceNet.cpp index 2380c4d1f1..4a30e079ca 100644 --- a/Core/HLE/sceNet.cpp +++ b/Core/HLE/sceNet.cpp @@ -458,94 +458,94 @@ static int sceNetUpnpGetNatInfo() } const HLEFunction sceNet[] = { - {0x39AF39A6, WrapU_UUUUU, "sceNetInit"}, - {0x281928A9, WrapU_V, "sceNetTerm"}, - {0x89360950, WrapI_UU, "sceNetEtherNtostr"}, - {0xd27961c9, WrapI_UU, "sceNetEtherStrton"}, - {0x0bf0a3ae, WrapU_U, "sceNetGetLocalEtherAddr"}, - {0x50647530, 0, "sceNetFreeThreadinfo"}, - {0xcc393e48, WrapI_U, "sceNetGetMallocStat"}, - {0xad6844c6, 0, "sceNetThreadAbort"}, + {0X39AF39A6, &WrapU_UUUUU, "sceNetInit", 'x', "xxxxx"}, + {0X281928A9, &WrapU_V, "sceNetTerm", 'x', "" }, + {0X89360950, &WrapI_UU, "sceNetEtherNtostr", 'i', "xx" }, + {0XD27961C9, &WrapI_UU, "sceNetEtherStrton", 'i', "xx" }, + {0X0BF0A3AE, &WrapU_U, "sceNetGetLocalEtherAddr", 'x', "x" }, + {0X50647530, nullptr, "sceNetFreeThreadinfo", '?', "" }, + {0XCC393E48, &WrapI_U, "sceNetGetMallocStat", 'i', "x" }, + {0XAD6844C6, nullptr, "sceNetThreadAbort", '?', "" }, }; const HLEFunction sceNetResolver[] = { - {0x224c5f44, 0, "sceNetResolverStartNtoA"}, - {0x244172af, 0, "sceNetResolverCreate"}, - {0x94523e09, 0, "sceNetResolverDelete"}, - {0xf3370e61, WrapI_V, "sceNetResolverInit"}, - {0x808F6063, 0, "sceNetResolverStop"}, - {0x6138194A, 0, "sceNetResolverTerm"}, - {0x629e2fb7, 0, "sceNetResolverStartAtoN"}, - {0x14c17ef9, 0, "sceNetResolverStartNtoAAsync"}, - {0xaac09184, 0, "sceNetResolverStartAtoNAsync"}, - {0x12748eb9, 0, "sceNetResolverWaitAsync"}, - {0x4ee99358, 0, "sceNetResolverPollAsync"}, + {0X224C5F44, nullptr, "sceNetResolverStartNtoA", '?', "" }, + {0X244172AF, nullptr, "sceNetResolverCreate", '?', "" }, + {0X94523E09, nullptr, "sceNetResolverDelete", '?', "" }, + {0XF3370E61, &WrapI_V, "sceNetResolverInit", 'i', "" }, + {0X808F6063, nullptr, "sceNetResolverStop", '?', "" }, + {0X6138194A, nullptr, "sceNetResolverTerm", '?', "" }, + {0X629E2FB7, nullptr, "sceNetResolverStartAtoN", '?', "" }, + {0X14C17EF9, nullptr, "sceNetResolverStartNtoAAsync", '?', "" }, + {0XAAC09184, nullptr, "sceNetResolverStartAtoNAsync", '?', "" }, + {0X12748EB9, nullptr, "sceNetResolverWaitAsync", '?', "" }, + {0X4EE99358, nullptr, "sceNetResolverPollAsync", '?', "" }, }; const HLEFunction sceNetInet[] = { - {0x17943399, WrapI_V, "sceNetInetInit"}, - {0x4cfe4e56, 0, "sceNetInetShutdown"}, - {0xa9ed66b9, WrapI_V, "sceNetInetTerm"}, - {0x8b7b220f, WrapI_III, "sceNetInetSocket"}, - {0x2fe71fe7, WrapI_IIIUI, "sceNetInetSetsockopt"}, - {0x4a114c7c, 0, "sceNetInetGetsockopt"}, - {0x410b34aa, WrapI_IUI, "sceNetInetConnect"}, - {0x805502DD, 0, "sceNetInetCloseWithRST"}, - {0xd10a1a7a, 0, "sceNetInetListen"}, - {0xdb094e1b, 0, "sceNetInetAccept"}, - {0xfaabb1dd, WrapI_VUI, "sceNetInetPoll" }, - {0x5be8d595, 0, "sceNetInetSelect"}, - {0x8d7284ea, 0, "sceNetInetClose"}, - {0xcda85c99, WrapI_IUUU, "sceNetInetRecv"}, - {0xc91142e4, 0, "sceNetInetRecvfrom"}, - {0xeece61d2, 0, "sceNetInetRecvmsg"}, - {0x7aa671bc, WrapI_IUUU, "sceNetInetSend"}, - {0x05038fc7, 0, "sceNetInetSendto"}, - {0x774e36f4, 0, "sceNetInetSendmsg"}, - {0xfbabe411, WrapI_V, "sceNetInetGetErrno"}, - {0x1a33f9ae, 0, "sceNetInetBind"}, - {0xb75d5b0a, 0, "sceNetInetInetAddr"}, - {0x1BDF5D13, WrapI_CU, "sceNetInetInetAton"}, - {0xd0792666, 0, "sceNetInetInetNtop"}, - {0xE30B8C19, 0, "sceNetInetInetPton"}, - {0x8ca3a97e, 0, "sceNetInetGetPspError"}, - {0xE247B6D6, 0, "sceNetInetGetpeername"}, - {0x162e6fd5, 0, "sceNetInetGetsockname"}, - {0x80A21ABD, 0, "sceNetInetSocketAbort"}, - {0x39b0c7d3, 0, "sceNetInetGetUdpcbstat"}, - {0xb3888ad4, 0, "sceNetInetGetTcpcbstat"}, + {0X17943399, &WrapI_V, "sceNetInetInit", 'i', "" }, + {0X4CFE4E56, nullptr, "sceNetInetShutdown", '?', "" }, + {0XA9ED66B9, &WrapI_V, "sceNetInetTerm", 'i', "" }, + {0X8B7B220F, &WrapI_III, "sceNetInetSocket", 'i', "iii" }, + {0X2FE71FE7, &WrapI_IIIUI, "sceNetInetSetsockopt", 'i', "iiixi"}, + {0X4A114C7C, nullptr, "sceNetInetGetsockopt", '?', "" }, + {0X410B34AA, &WrapI_IUI, "sceNetInetConnect", 'i', "ixi" }, + {0X805502DD, nullptr, "sceNetInetCloseWithRST", '?', "" }, + {0XD10A1A7A, nullptr, "sceNetInetListen", '?', "" }, + {0XDB094E1B, nullptr, "sceNetInetAccept", '?', "" }, + {0XFAABB1DD, &WrapI_VUI, "sceNetInetPoll", 'i', "pxi" }, + {0X5BE8D595, nullptr, "sceNetInetSelect", '?', "" }, + {0X8D7284EA, nullptr, "sceNetInetClose", '?', "" }, + {0XCDA85C99, &WrapI_IUUU, "sceNetInetRecv", 'i', "ixxx" }, + {0XC91142E4, nullptr, "sceNetInetRecvfrom", '?', "" }, + {0XEECE61D2, nullptr, "sceNetInetRecvmsg", '?', "" }, + {0X7AA671BC, &WrapI_IUUU, "sceNetInetSend", 'i', "ixxx" }, + {0X05038FC7, nullptr, "sceNetInetSendto", '?', "" }, + {0X774E36F4, nullptr, "sceNetInetSendmsg", '?', "" }, + {0XFBABE411, &WrapI_V, "sceNetInetGetErrno", 'i', "" }, + {0X1A33F9AE, nullptr, "sceNetInetBind", '?', "" }, + {0XB75D5B0A, nullptr, "sceNetInetInetAddr", '?', "" }, + {0X1BDF5D13, &WrapI_CU, "sceNetInetInetAton", 'i', "sx" }, + {0XD0792666, nullptr, "sceNetInetInetNtop", '?', "" }, + {0XE30B8C19, nullptr, "sceNetInetInetPton", '?', "" }, + {0X8CA3A97E, nullptr, "sceNetInetGetPspError", '?', "" }, + {0XE247B6D6, nullptr, "sceNetInetGetpeername", '?', "" }, + {0X162E6FD5, nullptr, "sceNetInetGetsockname", '?', "" }, + {0X80A21ABD, nullptr, "sceNetInetSocketAbort", '?', "" }, + {0X39B0C7D3, nullptr, "sceNetInetGetUdpcbstat", '?', "" }, + {0XB3888AD4, nullptr, "sceNetInetGetTcpcbstat", '?', "" }, }; const HLEFunction sceNetApctl[] = { - {0xCFB957C6, 0, "sceNetApctlConnect"}, - {0x24fe91a1, &WrapI_V, "sceNetApctlDisconnect" }, - {0x5deac81b, 0, "sceNetApctlGetState"}, - {0x8abadd51, WrapU_UU, "sceNetApctlAddHandler"}, - {0xe2f91f9b, WrapI_V, "sceNetApctlInit"}, - {0x5963991b, WrapI_U, "sceNetApctlDelHandler"}, - {0xb3edd0ec, WrapI_V, "sceNetApctlTerm"}, - {0x2BEFDF23, 0, "sceNetApctlGetInfo"}, - {0xa3e77e13, 0, "sceNetApctlScanSSID2"}, - {0xe9b2e5e6, 0, "sceNetApctlScanUser"}, - {0xf25a5006, 0, "sceNetApctlGetBSSDescIDList2"}, - {0x2935c45b, 0, "sceNetApctlGetBSSDescEntry2"}, - {0x04776994, 0, "sceNetApctlGetBSSDescEntryUser"}, - {0x6bddcb8c, 0, "sceNetApctlGetBSSDescIDListUser"}, + {0XCFB957C6, nullptr, "sceNetApctlConnect", '?', "" }, + {0X24FE91A1, &WrapI_V, "sceNetApctlDisconnect", 'i', "" }, + {0X5DEAC81B, nullptr, "sceNetApctlGetState", '?', "" }, + {0X8ABADD51, &WrapU_UU, "sceNetApctlAddHandler", 'x', "xx" }, + {0XE2F91F9B, &WrapI_V, "sceNetApctlInit", 'i', "" }, + {0X5963991B, &WrapI_U, "sceNetApctlDelHandler", 'i', "x" }, + {0XB3EDD0EC, &WrapI_V, "sceNetApctlTerm", 'i', "" }, + {0X2BEFDF23, nullptr, "sceNetApctlGetInfo", '?', "" }, + {0XA3E77E13, nullptr, "sceNetApctlScanSSID2", '?', "" }, + {0XE9B2E5E6, nullptr, "sceNetApctlScanUser", '?', "" }, + {0XF25A5006, nullptr, "sceNetApctlGetBSSDescIDList2", '?', "" }, + {0X2935C45B, nullptr, "sceNetApctlGetBSSDescEntry2", '?', "" }, + {0X04776994, nullptr, "sceNetApctlGetBSSDescEntryUser", '?', "" }, + {0X6BDDCB8C, nullptr, "sceNetApctlGetBSSDescIDListUser", '?', "" }, }; const HLEFunction sceWlanDrv[] = { - {0xd7763699, WrapU_V, "sceWlanGetSwitchState"}, - {0x0c622081, WrapU_U, "sceWlanGetEtherAddr"}, - {0x93440B11, WrapU_V, "sceWlanDevIsPowerOn"}, + {0XD7763699, &WrapU_V, "sceWlanGetSwitchState", 'x', "" }, + {0X0C622081, &WrapU_U, "sceWlanGetEtherAddr", 'x', "x" }, + {0X93440B11, &WrapU_V, "sceWlanDevIsPowerOn", 'x', "" }, }; // see http://www.kingx.de/forum/showthread.php?tid=35164 const HLEFunction sceNetUpnp[] = { - { 0x27045362, WrapI_V, "sceNetUpnpGetNatInfo" }, - { 0x3432B2E5, WrapI_V, "sceNetUpnpStart" }, - { 0x3E32ED9E, WrapI_V, "sceNetUpnpStop" }, - { 0x540491EF, WrapI_V, "sceNetUpnpTerm" }, - { 0xE24220B5, WrapI_II, "sceNetUpnpInit" }, + {0X27045362, &WrapI_V, "sceNetUpnpGetNatInfo", 'i', "" }, + {0X3432B2E5, &WrapI_V, "sceNetUpnpStart", 'i', "" }, + {0X3E32ED9E, &WrapI_V, "sceNetUpnpStop", 'i', "" }, + {0X540491EF, &WrapI_V, "sceNetUpnpTerm", 'i', "" }, + {0XE24220B5, &WrapI_II, "sceNetUpnpInit", 'i', "ii" }, }; void Register_sceNet() { diff --git a/Core/HLE/sceNetAdhoc.cpp b/Core/HLE/sceNetAdhoc.cpp index 18ca5705a6..b2cdd35fe9 100644 --- a/Core/HLE/sceNetAdhoc.cpp +++ b/Core/HLE/sceNetAdhoc.cpp @@ -3487,53 +3487,53 @@ void __NetTriggerCallbacks() } const HLEFunction sceNetAdhoc[] = { - {0xE1D621D7, WrapU_V, "sceNetAdhocInit"}, - {0xA62C6F57, WrapI_V, "sceNetAdhocTerm"}, - {0x0AD043ED, WrapI_U, "sceNetAdhocctlConnect"}, - {0x6f92741b, WrapI_CUIU, "sceNetAdhocPdpCreate"}, - {0xabed3790, WrapI_ICUVIII, "sceNetAdhocPdpSend"}, - {0xdfe53e03, WrapI_IVVVVUI, "sceNetAdhocPdpRecv"}, - {0x7f27bb5e, WrapI_II, "sceNetAdhocPdpDelete"}, - {0xc7c1fc57, WrapI_UU, "sceNetAdhocGetPdpStat"}, - {0x157e6225, WrapI_II, "sceNetAdhocPtpClose"}, - {0x4da4c788, WrapI_IUUII, "sceNetAdhocPtpSend"}, - {0x877f6d66, WrapI_CICIIIII, "sceNetAdhocPtpOpen"}, - {0x8bea2b3e, WrapI_IUUII, "sceNetAdhocPtpRecv"}, - {0x9df81198, WrapI_IUUII, "sceNetAdhocPtpAccept"}, - {0xe08bdac1, WrapI_CIIIIII, "sceNetAdhocPtpListen"}, - {0xfc6fc07b, WrapI_III, "sceNetAdhocPtpConnect"}, - {0x9ac2eeac, WrapI_III, "sceNetAdhocPtpFlush"}, - {0xb9685118, WrapI_UU, "sceNetAdhocGetPtpStat"}, - {0x3278ab0c, WrapI_CUI, "sceNetAdhocGameModeCreateReplica"}, - {0x98c204c8, WrapI_V, "sceNetAdhocGameModeUpdateMaster"}, - {0xfa324b4e, WrapI_IU, "sceNetAdhocGameModeUpdateReplica"}, - {0xa0229362, WrapI_V, "sceNetAdhocGameModeDeleteMaster"}, - {0x0b2228e9, WrapI_I, "sceNetAdhocGameModeDeleteReplica"}, - {0x7F75C338, WrapI_UI, "sceNetAdhocGameModeCreateMaster"}, - {0x73bfd52d, WrapI_II, "sceNetAdhocSetSocketAlert"}, - {0x4d2ce199, WrapI_IU, "sceNetAdhocGetSocketAlert"}, - {0x7a662d6b, WrapI_UIII, "sceNetAdhocPollSocket"}, + {0XE1D621D7, &WrapU_V, "sceNetAdhocInit", 'x', "" }, + {0XA62C6F57, &WrapI_V, "sceNetAdhocTerm", 'i', "" }, + {0X0AD043ED, &WrapI_U, "sceNetAdhocctlConnect", 'i', "x" }, + {0X6F92741B, &WrapI_CUIU, "sceNetAdhocPdpCreate", 'i', "sxix" }, + {0XABED3790, &WrapI_ICUVIII, "sceNetAdhocPdpSend", 'i', "isxpiii" }, + {0XDFE53E03, &WrapI_IVVVVUI, "sceNetAdhocPdpRecv", 'i', "ippppxi" }, + {0X7F27BB5E, &WrapI_II, "sceNetAdhocPdpDelete", 'i', "ii" }, + {0XC7C1FC57, &WrapI_UU, "sceNetAdhocGetPdpStat", 'i', "xx" }, + {0X157E6225, &WrapI_II, "sceNetAdhocPtpClose", 'i', "ii" }, + {0X4DA4C788, &WrapI_IUUII, "sceNetAdhocPtpSend", 'i', "ixxii" }, + {0X877F6D66, &WrapI_CICIIIII, "sceNetAdhocPtpOpen", 'i', "sisiiiii" }, + {0X8BEA2B3E, &WrapI_IUUII, "sceNetAdhocPtpRecv", 'i', "ixxii" }, + {0X9DF81198, &WrapI_IUUII, "sceNetAdhocPtpAccept", 'i', "ixxii" }, + {0XE08BDAC1, &WrapI_CIIIIII, "sceNetAdhocPtpListen", 'i', "siiiiii" }, + {0XFC6FC07B, &WrapI_III, "sceNetAdhocPtpConnect", 'i', "iii" }, + {0X9AC2EEAC, &WrapI_III, "sceNetAdhocPtpFlush", 'i', "iii" }, + {0XB9685118, &WrapI_UU, "sceNetAdhocGetPtpStat", 'i', "xx" }, + {0X3278AB0C, &WrapI_CUI, "sceNetAdhocGameModeCreateReplica", 'i', "sxi" }, + {0X98C204C8, &WrapI_V, "sceNetAdhocGameModeUpdateMaster", 'i', "" }, + {0XFA324B4E, &WrapI_IU, "sceNetAdhocGameModeUpdateReplica", 'i', "ix" }, + {0XA0229362, &WrapI_V, "sceNetAdhocGameModeDeleteMaster", 'i', "" }, + {0X0B2228E9, &WrapI_I, "sceNetAdhocGameModeDeleteReplica", 'i', "i" }, + {0X7F75C338, &WrapI_UI, "sceNetAdhocGameModeCreateMaster", 'i', "xi" }, + {0X73BFD52D, &WrapI_II, "sceNetAdhocSetSocketAlert", 'i', "ii" }, + {0X4D2CE199, &WrapI_IU, "sceNetAdhocGetSocketAlert", 'i', "ix" }, + {0X7A662D6B, &WrapI_UIII, "sceNetAdhocPollSocket", 'i', "xiii" }, // Fake function for PPSSPP's use. - {0x756E6E6F, WrapV_V<__NetTriggerCallbacks>, "__NetTriggerCallbacks"}, + {0X756E6E6F, &WrapV_V<__NetTriggerCallbacks>, "__NetTriggerCallbacks", 'v', "" }, }; const HLEFunction sceNetAdhocMatching[] = { - {0x2a2a1e07, WrapI_U, "sceNetAdhocMatchingInit"}, - {0x7945ecda, WrapI_V, "sceNetAdhocMatchingTerm"}, - {0xca5eda6f, WrapI_IIIIIIIIU, "sceNetAdhocMatchingCreate"}, - {0x93ef3843, WrapI_IIIIIIU, "sceNetAdhocMatchingStart"}, - {0x32b156b3, WrapI_I, "sceNetAdhocMatchingStop"}, - {0xf16eaf4f, WrapI_I, "sceNetAdhocMatchingDelete"}, - {0x5e3d4b79, WrapI_ICIU, "sceNetAdhocMatchingSelectTarget"}, - {0xea3c6108, WrapI_IC, "sceNetAdhocMatchingCancelTarget"}, - {0x8f58bedf, WrapI_ICIU, "sceNetAdhocMatchingCancelTargetWithOpt"}, - {0xb5d96c2a, WrapI_IUU, "sceNetAdhocMatchingGetHelloOpt"}, - {0xb58e61b7, WrapI_IIU, "sceNetAdhocMatchingSetHelloOpt"}, - {0xc58bcd9e, WrapI_IUU, "sceNetAdhocMatchingGetMembers"}, - {0xf79472d7, WrapI_ICIU, "sceNetAdhocMatchingSendData"}, - {0xec19337d, WrapI_IC, "sceNetAdhocMatchingAbortSendData"}, - {0x40F8F435, WrapI_V, "sceNetAdhocMatchingGetPoolMaxAlloc"}, - {0x9c5cfb7d, WrapI_U, "sceNetAdhocMatchingGetPoolStat"}, + {0X2A2A1E07, &WrapI_U, "sceNetAdhocMatchingInit", 'i', "x" }, + {0X7945ECDA, &WrapI_V, "sceNetAdhocMatchingTerm", 'i', "" }, + {0XCA5EDA6F, &WrapI_IIIIIIIIU, "sceNetAdhocMatchingCreate", 'i', "iiiiiiiix"}, + {0X93EF3843, &WrapI_IIIIIIU, "sceNetAdhocMatchingStart", 'i', "iiiiiix" }, + {0X32B156B3, &WrapI_I, "sceNetAdhocMatchingStop", 'i', "i" }, + {0XF16EAF4F, &WrapI_I, "sceNetAdhocMatchingDelete", 'i', "i" }, + {0X5E3D4B79, &WrapI_ICIU, "sceNetAdhocMatchingSelectTarget", 'i', "isix" }, + {0XEA3C6108, &WrapI_IC, "sceNetAdhocMatchingCancelTarget", 'i', "is" }, + {0X8F58BEDF, &WrapI_ICIU, "sceNetAdhocMatchingCancelTargetWithOpt", 'i', "isix" }, + {0XB5D96C2A, &WrapI_IUU, "sceNetAdhocMatchingGetHelloOpt", 'i', "ixx" }, + {0XB58E61B7, &WrapI_IIU, "sceNetAdhocMatchingSetHelloOpt", 'i', "iix" }, + {0XC58BCD9E, &WrapI_IUU, "sceNetAdhocMatchingGetMembers", 'i', "ixx" }, + {0XF79472D7, &WrapI_ICIU, "sceNetAdhocMatchingSendData", 'i', "isix" }, + {0XEC19337D, &WrapI_IC, "sceNetAdhocMatchingAbortSendData", 'i', "is" }, + {0X40F8F435, &WrapI_V, "sceNetAdhocMatchingGetPoolMaxAlloc", 'i', "" }, + {0X9C5CFB7D, &WrapI_U, "sceNetAdhocMatchingGetPoolStat", 'i', "x" }, }; static int sceNetAdhocctlExitGameMode() { @@ -3729,28 +3729,28 @@ static int sceNetAdhocctlGetAddrByName(const char *nickName, u32 sizeAddr, u32 b } const HLEFunction sceNetAdhocctl[] = { - {0xE26F226E, WrapU_IIU, "sceNetAdhocctlInit"}, - {0x9D689E13, WrapI_V, "sceNetAdhocctlTerm"}, - {0x20B317A0, WrapU_UU, "sceNetAdhocctlAddHandler"}, - {0x6402490B, WrapU_U, "sceNetAdhocctlDelHandler"}, - {0x34401D65, WrapU_V, "sceNetAdhocctlDisconnect"}, - {0x0ad043ed, WrapI_U, "sceNetAdhocctlConnect"}, - {0x08fff7a0, WrapI_V, "sceNetAdhocctlScan"}, - {0x75ecd386, WrapI_U, "sceNetAdhocctlGetState"}, - {0x8916c003, WrapI_CU, "sceNetAdhocctlGetNameByAddr"}, - {0xded9d28e, WrapI_U, "sceNetAdhocctlGetParameter"}, - {0x81aee1be, WrapI_UU, "sceNetAdhocctlGetScanInfo"}, - {0x5e7f79c9, WrapI_U, "sceNetAdhocctlJoin"}, - {0x8db83fdc, WrapI_CIU, "sceNetAdhocctlGetPeerInfo"}, - {0xec0635c1, WrapI_C, "sceNetAdhocctlCreate"}, - {0xa5c055ce, WrapI_CIIUII, "sceNetAdhocctlCreateEnterGameMode"}, - {0x1ff89745, WrapI_CCII, "sceNetAdhocctlJoinEnterGameMode"}, - {0xcf8e084d, WrapI_V, "sceNetAdhocctlExitGameMode"}, - {0xe162cb14, WrapI_UU, "sceNetAdhocctlGetPeerList"}, - {0x362cbe8f, WrapI_U, "sceNetAdhocctlGetAdhocId"}, - {0x5a014ce0, WrapI_U, "sceNetAdhocctlGetGameModeInfo"}, - {0x99560abe, WrapI_CUU, "sceNetAdhocctlGetAddrByName"}, - {0xb0b80e80, WrapI_CIIIUUI, "sceNetAdhocctlCreateEnterGameModeMin" }, // ?? + {0XE26F226E, &WrapU_IIU, "sceNetAdhocctlInit", 'x', "iix" }, + {0X9D689E13, &WrapI_V, "sceNetAdhocctlTerm", 'i', "" }, + {0X20B317A0, &WrapU_UU, "sceNetAdhocctlAddHandler", 'x', "xx" }, + {0X6402490B, &WrapU_U, "sceNetAdhocctlDelHandler", 'x', "x" }, + {0X34401D65, &WrapU_V, "sceNetAdhocctlDisconnect", 'x', "" }, + {0X0AD043ED, &WrapI_U, "sceNetAdhocctlConnect", 'i', "x" }, + {0X08FFF7A0, &WrapI_V, "sceNetAdhocctlScan", 'i', "" }, + {0X75ECD386, &WrapI_U, "sceNetAdhocctlGetState", 'i', "x" }, + {0X8916C003, &WrapI_CU, "sceNetAdhocctlGetNameByAddr", 'i', "sx" }, + {0XDED9D28E, &WrapI_U, "sceNetAdhocctlGetParameter", 'i', "x" }, + {0X81AEE1BE, &WrapI_UU, "sceNetAdhocctlGetScanInfo", 'i', "xx" }, + {0X5E7F79C9, &WrapI_U, "sceNetAdhocctlJoin", 'i', "x" }, + {0X8DB83FDC, &WrapI_CIU, "sceNetAdhocctlGetPeerInfo", 'i', "six" }, + {0XEC0635C1, &WrapI_C, "sceNetAdhocctlCreate", 'i', "s" }, + {0XA5C055CE, &WrapI_CIIUII, "sceNetAdhocctlCreateEnterGameMode", 'i', "siixii" }, + {0X1FF89745, &WrapI_CCII, "sceNetAdhocctlJoinEnterGameMode", 'i', "ssii" }, + {0XCF8E084D, &WrapI_V, "sceNetAdhocctlExitGameMode", 'i', "" }, + {0XE162CB14, &WrapI_UU, "sceNetAdhocctlGetPeerList", 'i', "xx" }, + {0X362CBE8F, &WrapI_U, "sceNetAdhocctlGetAdhocId", 'i', "x" }, + {0X5A014CE0, &WrapI_U, "sceNetAdhocctlGetGameModeInfo", 'i', "x" }, + {0X99560ABE, &WrapI_CUU, "sceNetAdhocctlGetAddrByName", 'i', "sxx" }, + {0XB0B80E80, &WrapI_CIIIUUI, "sceNetAdhocctlCreateEnterGameModeMin", 'i', "siiixxi" }, // ?? }; int sceNetAdhocDiscoverInitStart() { @@ -3785,12 +3785,12 @@ int sceNetAdhocDiscoverRequestSuspend(void) } const HLEFunction sceNetAdhocDiscover[] = { - {0x941B3877, WrapI_V, "sceNetAdhocDiscoverInitStart" }, - {0x52DE1B97, WrapI_V, "sceNetAdhocDiscoverUpdate" }, - {0x944DDBC6, WrapI_V, "sceNetAdhocDiscoverGetStatus" }, - {0xA2246614, WrapI_V, "sceNetAdhocDiscoverTerm" }, - {0xF7D13214, WrapI_V, "sceNetAdhocDiscoverStop" }, - {0xA423A21B, WrapI_V, "sceNetAdhocDiscoverRequestSuspend" }, + {0X941B3877, &WrapI_V, "sceNetAdhocDiscoverInitStart", 'i', "" }, + {0X52DE1B97, &WrapI_V, "sceNetAdhocDiscoverUpdate", 'i', "" }, + {0X944DDBC6, &WrapI_V, "sceNetAdhocDiscoverGetStatus", 'i', "" }, + {0XA2246614, &WrapI_V, "sceNetAdhocDiscoverTerm", 'i', "" }, + {0XF7D13214, &WrapI_V, "sceNetAdhocDiscoverStop", 'i', "" }, + {0XA423A21B, &WrapI_V, "sceNetAdhocDiscoverRequestSuspend", 'i', "" }, }; void Register_sceNetAdhoc() { diff --git a/Core/HLE/sceNp.cpp b/Core/HLE/sceNp.cpp index d5279ef216..a8a926c72d 100644 --- a/Core/HLE/sceNp.cpp +++ b/Core/HLE/sceNp.cpp @@ -38,8 +38,8 @@ static int sceNp_37E1E274() } const HLEFunction sceNp[] = { - {0x857B47D3, &WrapI_V, "sceNp_857B47D3"}, - {0x37E1E274, &WrapI_V, "sceNp_37E1E274"}, + {0X857B47D3, &WrapI_V, "sceNp_857B47D3", 'i', "" }, + {0X37E1E274, &WrapI_V, "sceNp_37E1E274", 'i', "" }, }; void Register_sceNp() @@ -61,8 +61,8 @@ static int sceNpAuth_A1DE86F8(u32 poolSize, u32 stackSize, u32 threadPrio) } const HLEFunction sceNpAuth[] = { - {0x4EC1F667, &WrapI_V, "sceNpAuth_4EC1F667"}, - {0xA1DE86F8, &WrapI_UUU, "sceNpAuth_A1DE86F8"}, + {0X4EC1F667, &WrapI_V, "sceNpAuth_4EC1F667", 'i', "" }, + {0XA1DE86F8, &WrapI_UUU, "sceNpAuth_A1DE86F8", 'i', "xxx"}, }; void Register_sceNpAuth() @@ -84,8 +84,8 @@ static int sceNpService_0F8F5821(u32 poolSize, u32 stackSize, u32 threadPrio) } const HLEFunction sceNpService[] = { - {0x00ACFAC3, &WrapI_V, "sceNpService_00ACFAC3"}, - {0x0F8F5821, &WrapI_UUU, "sceNpService_0F8F5821"}, + {0X00ACFAC3, &WrapI_V, "sceNpService_00ACFAC3", 'i', "" }, + {0X0F8F5821, &WrapI_UUU, "sceNpService_0F8F5821", 'i', "xxx"}, }; void Register_sceNpService() @@ -94,22 +94,22 @@ void Register_sceNpService() } const HLEFunction sceNpCommerce2[] = { - {0x005B5F20, 0, "sceNpCommerce2_005B5F20"}, - {0x0e9956e3, 0, "sceNpCommerce2_0e9956e3"}, - {0x1888a9fe, 0, "sceNpCommerce2_1888a9fe"}, - {0x1c952dcb, 0, "sceNpCommerce2_1c952dcb"}, - {0x2b25f6e9, 0, "sceNpCommerce2_2b25f6e9"}, - {0x3371d5f1, 0, "sceNpCommerce2_3371d5f1"}, - {0x4ecd4503, 0, "sceNpCommerce2_4ecd4503"}, - {0x590a3229, 0, "sceNpCommerce2_590a3229"}, - {0x6f1fe37f, 0, "sceNpCommerce2_6f1fe37f"}, - {0xa5a34ea4, 0, "sceNpCommerce2_a5a34ea4"}, - {0xaa4a1e3d, 0, "sceNpCommerce2_aa4a1e3d"}, - {0xbc61ffc8, 0, "sceNpCommerce2_bc61ffc8"}, - {0xc7f32242, 0, "sceNpCommerce2_c7f32242"}, - {0xf2278b90, 0, "sceNpCommerce2_f2278b90"}, - {0xf297ab9c, 0, "sceNpCommerce2_f297ab9c"}, - {0xfc30c19e, 0, "sceNpCommerce2_fc30c19e"}, + {0X005B5F20, nullptr, "sceNpCommerce2_005B5F20", '?', "" }, + {0X0E9956E3, nullptr, "sceNpCommerce2_0e9956e3", '?', "" }, + {0X1888A9FE, nullptr, "sceNpCommerce2_1888a9fe", '?', "" }, + {0X1C952DCB, nullptr, "sceNpCommerce2_1c952dcb", '?', "" }, + {0X2B25F6E9, nullptr, "sceNpCommerce2_2b25f6e9", '?', "" }, + {0X3371D5F1, nullptr, "sceNpCommerce2_3371d5f1", '?', "" }, + {0X4ECD4503, nullptr, "sceNpCommerce2_4ecd4503", '?', "" }, + {0X590A3229, nullptr, "sceNpCommerce2_590a3229", '?', "" }, + {0X6F1FE37F, nullptr, "sceNpCommerce2_6f1fe37f", '?', "" }, + {0XA5A34EA4, nullptr, "sceNpCommerce2_a5a34ea4", '?', "" }, + {0XAA4A1E3D, nullptr, "sceNpCommerce2_aa4a1e3d", '?', "" }, + {0XBC61FFC8, nullptr, "sceNpCommerce2_bc61ffc8", '?', "" }, + {0XC7F32242, nullptr, "sceNpCommerce2_c7f32242", '?', "" }, + {0XF2278B90, nullptr, "sceNpCommerce2_f2278b90", '?', "" }, + {0XF297AB9C, nullptr, "sceNpCommerce2_f297ab9c", '?', "" }, + {0XFC30C19E, nullptr, "sceNpCommerce2_fc30c19e", '?', "" }, }; void Register_sceNpCommerce2() diff --git a/Core/HLE/sceOpenPSID.cpp b/Core/HLE/sceOpenPSID.cpp index 3a4701524d..19577dae22 100644 --- a/Core/HLE/sceOpenPSID.cpp +++ b/Core/HLE/sceOpenPSID.cpp @@ -37,7 +37,7 @@ static int sceOpenPSIDGetOpenPSID(u32 OpenPSIDPtr) const HLEFunction sceOpenPSID[] = { - {0xc69bebce, WrapI_U, "sceOpenPSIDGetOpenPSID"}, + {0XC69BEBCE, &WrapI_U, "sceOpenPSIDGetOpenPSID", 'i', "x"}, }; void Register_sceOpenPSID() diff --git a/Core/HLE/sceP3da.cpp b/Core/HLE/sceP3da.cpp index 8e2efaae3e..1595dc139e 100644 --- a/Core/HLE/sceP3da.cpp +++ b/Core/HLE/sceP3da.cpp @@ -68,9 +68,9 @@ static u32 sceP3daBridgeCore(u32 p3daCoreAddr, u32 channelsNum, u32 samplesNum, const HLEFunction sceP3da[] = { - {0x374500a5, WrapU_UU, "sceP3daBridgeInit"}, - {0x43F756a2, WrapU_V, "sceP3daBridgeExit"}, - {0x013016f3, WrapU_UUUUU, "sceP3daBridgeCore"}, + {0X374500A5, &WrapU_UU, "sceP3daBridgeInit", 'x', "xx" }, + {0X43F756A2, &WrapU_V, "sceP3daBridgeExit", 'x', "" }, + {0X013016F3, &WrapU_UUUUU, "sceP3daBridgeCore", 'x', "xxxxx"}, }; void Register_sceP3da() diff --git a/Core/HLE/sceParseHttp.cpp b/Core/HLE/sceParseHttp.cpp index 3c78bd3727..7da109f4af 100644 --- a/Core/HLE/sceParseHttp.cpp +++ b/Core/HLE/sceParseHttp.cpp @@ -20,8 +20,8 @@ const HLEFunction sceParseHttp [] = { - {0x8077A433, 0, "sceParseHttpStatusLine"}, - {0xAD7BFDEF, 0, "sceParseHttpResponseHeader"}, + {0X8077A433, nullptr, "sceParseHttpStatusLine", '?', ""}, + {0XAD7BFDEF, nullptr, "sceParseHttpResponseHeader", '?', ""}, }; void Register_sceParseHttp() diff --git a/Core/HLE/sceParseUri.cpp b/Core/HLE/sceParseUri.cpp index 890ae1b99c..b8b5e15cd6 100644 --- a/Core/HLE/sceParseUri.cpp +++ b/Core/HLE/sceParseUri.cpp @@ -20,10 +20,10 @@ const HLEFunction sceParseUri[] = { - {0x49E950EC, 0, "sceUriEscape"}, - {0x062BB07E, 0, "sceUriUnescape"}, - {0x568518C9, 0, "sceUriParse"}, - {0x7EE318AF, 0, "sceUriBuild"}, + {0X49E950EC, nullptr, "sceUriEscape", '?', ""}, + {0X062BB07E, nullptr, "sceUriUnescape", '?', ""}, + {0X568518C9, nullptr, "sceUriParse", '?', ""}, + {0X7EE318AF, nullptr, "sceUriBuild", '?', ""}, }; void Register_sceParseUri() diff --git a/Core/HLE/scePauth.cpp b/Core/HLE/scePauth.cpp index c0b49704ea..31ab599fa3 100644 --- a/Core/HLE/scePauth.cpp +++ b/Core/HLE/scePauth.cpp @@ -123,8 +123,8 @@ static int scePauth_98B83B5D(u32 srcPtr, int srcLength, u32 destLengthPtr, u32 w } const HLEFunction scePauth[] = { - {0xF7AA47F6, &WrapI_UIUU, "scePauth_F7AA47F6"}, - {0x98B83B5D, &WrapI_UIUU, "scePauth_98B83B5D"}, + {0XF7AA47F6, &WrapI_UIUU, "scePauth_F7AA47F6", 'i', "xixx"}, + {0X98B83B5D, &WrapI_UIUU, "scePauth_98B83B5D", 'i', "xixx"}, }; void Register_scePauth() diff --git a/Core/HLE/scePower.cpp b/Core/HLE/scePower.cpp index 743332d78d..36422ddcc4 100644 --- a/Core/HLE/scePower.cpp +++ b/Core/HLE/scePower.cpp @@ -448,81 +448,81 @@ static u32 IsPSPNonFat() { } static const HLEFunction scePower[] = { - {0x04B7766E,&WrapI_II,"scePowerRegisterCallback"}, - {0x2B51FE2F,0,"scePower_2B51FE2F"}, - {0x442BFBAC,0,"scePowerGetBacklightMaximum"}, - {0xEFD3C963,&WrapI_V,"scePowerTick"}, - {0xEDC13FE5,0,"scePowerGetIdleTimer"}, - {0x7F30B3B1,0,"scePowerIdleTimerEnable"}, - {0x972CE941,0,"scePowerIdleTimerDisable"}, - {0x27F3292C,0,"scePowerBatteryUpdateInfo"}, - {0xE8E4E204,0,"scePower_E8E4E204"}, - {0xB999184C,0,"scePowerGetLowBatteryCapacity"}, - {0x87440F5E,&WrapI_V,"scePowerIsPowerOnline"}, - {0x0AFD0D8B,&WrapI_V,"scePowerIsBatteryExist"}, - {0x1E490401,&WrapI_V,"scePowerIsBatteryCharging"}, - {0xB4432BC8,&WrapI_V,"scePowerGetBatteryChargingStatus"}, - {0xD3075926,&WrapI_V,"scePowerIsLowBattery"}, - {0x78A1A796,0,"scePowerIsSuspendRequired"}, - {0x94F5A53F,0,"scePowerGetBatteryRemainCapacity"}, - {0xFD18A0FF,0,"scePowerGetBatteryFullCapacity"}, - {0x2085D15D,&WrapI_V,"scePowerGetBatteryLifePercent"}, - {0x8EFB3FA2,&WrapI_V,"scePowerGetBatteryLifeTime"}, - {0x28E12023,&WrapI_V,"scePowerGetBatteryTemp"}, - {0x862AE1A6,0,"scePowerGetBatteryElec"}, - {0x483CE86B,0,"scePowerGetBatteryVolt"}, - {0xcb49f5ce,0,"scePowerGetBatteryChargeCycle"}, - {0x23436A4A,0,"scePowerGetInnerTemp"}, - {0x0CD21B1F,0,"scePowerSetPowerSwMode"}, - {0x165CE085,0,"scePowerGetPowerSwMode"}, - {0xD6D016EF,0,"scePowerLock"}, - {0xCA3D34C1,0,"scePowerUnlock"}, - {0xDB62C9CF,0,"scePowerCancelRequest"}, - {0x7FA406DD,0,"scePowerIsRequest"}, - {0x2B7C7CF4,0,"scePowerRequestStandby"}, - {0xAC32C9CC,0,"scePowerRequestSuspend"}, - {0x2875994B,0,"scePower_2875994B"}, - {0x0074EF9B,0,"scePowerGetResumeCount"}, - {0xDFA8BAF8,WrapI_I,"scePowerUnregisterCallback"}, - {0xDB9D28DD,WrapI_I,"scePowerUnregitserCallback"}, - {0x843FBF43,WrapU_U,"scePowerSetCpuClockFrequency"}, - {0xB8D7B3FB,WrapU_U,"scePowerSetBusClockFrequency"}, - {0xFEE03A2F,WrapU_V,"scePowerGetCpuClockFrequency"}, - {0x478FE6F5,WrapU_V,"scePowerGetBusClockFrequency"}, - {0xFDB5BFE9,WrapU_V,"scePowerGetCpuClockFrequencyInt"}, - {0xBD681969,WrapU_V,"scePowerGetBusClockFrequencyInt"}, - {0xB1A52C83,WrapF_V,"scePowerGetCpuClockFrequencyFloat"}, - {0x9BADB3EB,WrapF_V,"scePowerGetBusClockFrequencyFloat"}, - {0x737486F2,WrapU_UUU,"scePowerSetClockFrequency"}, - {0x34f9c463,WrapU_V,"scePowerGetPllClockFrequencyInt"}, - {0xea382a27,WrapF_V,"scePowerGetPllClockFrequencyFloat"}, - {0xebd177d6,WrapU_UUU,"scePower_EBD177D6"}, // This is also the same as SetClockFrequency - {0x469989ad,WrapU_UUU,"scePower_469989ad"}, // This is also the same as SetClockFrequency - {0x545a7f3c,0,"scePower_545A7F3C"}, // TODO: Supposedly the same as SetClockFrequency also? - {0xa4e93389,0,"scePower_A4E93389"}, // TODO: Supposedly the same as SetClockFrequency also? - {0xa85880d0,WrapU_V,"scePower_a85880d0_IsPSPNonFat"}, - {0x3951af53,0,"scePowerWaitRequestCompletion"}, - {0x0442d852,0,"scePowerRequestColdReset"}, - {0xbafa3df0,0,"scePowerGetCallbackMode"}, - {0xa9d22232,0,"scePowerSetCallbackMode"}, + {0X04B7766E, &WrapI_II, "scePowerRegisterCallback", 'i', "ii" }, + {0X2B51FE2F, nullptr, "scePower_2B51FE2F", '?', "" }, + {0X442BFBAC, nullptr, "scePowerGetBacklightMaximum", '?', "" }, + {0XEFD3C963, &WrapI_V, "scePowerTick", 'i', "" }, + {0XEDC13FE5, nullptr, "scePowerGetIdleTimer", '?', "" }, + {0X7F30B3B1, nullptr, "scePowerIdleTimerEnable", '?', "" }, + {0X972CE941, nullptr, "scePowerIdleTimerDisable", '?', "" }, + {0X27F3292C, nullptr, "scePowerBatteryUpdateInfo", '?', "" }, + {0XE8E4E204, nullptr, "scePower_E8E4E204", '?', "" }, + {0XB999184C, nullptr, "scePowerGetLowBatteryCapacity", '?', "" }, + {0X87440F5E, &WrapI_V, "scePowerIsPowerOnline", 'i', "" }, + {0X0AFD0D8B, &WrapI_V, "scePowerIsBatteryExist", 'i', "" }, + {0X1E490401, &WrapI_V, "scePowerIsBatteryCharging", 'i', "" }, + {0XB4432BC8, &WrapI_V, "scePowerGetBatteryChargingStatus", 'i', "" }, + {0XD3075926, &WrapI_V, "scePowerIsLowBattery", 'i', "" }, + {0X78A1A796, nullptr, "scePowerIsSuspendRequired", '?', "" }, + {0X94F5A53F, nullptr, "scePowerGetBatteryRemainCapacity", '?', "" }, + {0XFD18A0FF, nullptr, "scePowerGetBatteryFullCapacity", '?', "" }, + {0X2085D15D, &WrapI_V, "scePowerGetBatteryLifePercent", 'i', "" }, + {0X8EFB3FA2, &WrapI_V, "scePowerGetBatteryLifeTime", 'i', "" }, + {0X28E12023, &WrapI_V, "scePowerGetBatteryTemp", 'i', "" }, + {0X862AE1A6, nullptr, "scePowerGetBatteryElec", '?', "" }, + {0X483CE86B, nullptr, "scePowerGetBatteryVolt", '?', "" }, + {0XCB49F5CE, nullptr, "scePowerGetBatteryChargeCycle", '?', "" }, + {0X23436A4A, nullptr, "scePowerGetInnerTemp", '?', "" }, + {0X0CD21B1F, nullptr, "scePowerSetPowerSwMode", '?', "" }, + {0X165CE085, nullptr, "scePowerGetPowerSwMode", '?', "" }, + {0XD6D016EF, nullptr, "scePowerLock", '?', "" }, + {0XCA3D34C1, nullptr, "scePowerUnlock", '?', "" }, + {0XDB62C9CF, nullptr, "scePowerCancelRequest", '?', "" }, + {0X7FA406DD, nullptr, "scePowerIsRequest", '?', "" }, + {0X2B7C7CF4, nullptr, "scePowerRequestStandby", '?', "" }, + {0XAC32C9CC, nullptr, "scePowerRequestSuspend", '?', "" }, + {0X2875994B, nullptr, "scePower_2875994B", '?', "" }, + {0X0074EF9B, nullptr, "scePowerGetResumeCount", '?', "" }, + {0XDFA8BAF8, &WrapI_I, "scePowerUnregisterCallback", 'i', "i" }, + {0XDB9D28DD, &WrapI_I, "scePowerUnregitserCallback", 'i', "i" }, + {0X843FBF43, &WrapU_U, "scePowerSetCpuClockFrequency", 'x', "x" }, + {0XB8D7B3FB, &WrapU_U, "scePowerSetBusClockFrequency", 'x', "x" }, + {0XFEE03A2F, &WrapU_V, "scePowerGetCpuClockFrequency", 'x', "" }, + {0X478FE6F5, &WrapU_V, "scePowerGetBusClockFrequency", 'x', "" }, + {0XFDB5BFE9, &WrapU_V, "scePowerGetCpuClockFrequencyInt", 'x', "" }, + {0XBD681969, &WrapU_V, "scePowerGetBusClockFrequencyInt", 'x', "" }, + {0XB1A52C83, &WrapF_V, "scePowerGetCpuClockFrequencyFloat", 'f', "" }, + {0X9BADB3EB, &WrapF_V, "scePowerGetBusClockFrequencyFloat", 'f', "" }, + {0X737486F2, &WrapU_UUU, "scePowerSetClockFrequency", 'x', "xxx"}, + {0X34F9C463, &WrapU_V, "scePowerGetPllClockFrequencyInt", 'x', "" }, + {0XEA382A27, &WrapF_V, "scePowerGetPllClockFrequencyFloat", 'f', "" }, + {0XEBD177D6, &WrapU_UUU, "scePower_EBD177D6", 'x', "xxx"}, // This is also the same as SetClockFrequency + {0X469989AD, &WrapU_UUU, "scePower_469989ad", 'x', "xxx"}, // This is also the same as SetClockFrequency + {0X545A7F3C, nullptr, "scePower_545A7F3C", '?', "" }, // TODO: Supposedly the same as SetClockFrequency also? + {0XA4E93389, nullptr, "scePower_A4E93389", '?', "" }, // TODO: Supposedly the same as SetClockFrequency also? + {0XA85880D0, &WrapU_V, "scePower_a85880d0_IsPSPNonFat", 'x', "" }, + {0X3951AF53, nullptr, "scePowerWaitRequestCompletion", '?', "" }, + {0X0442D852, nullptr, "scePowerRequestColdReset", '?', "" }, + {0XBAFA3DF0, nullptr, "scePowerGetCallbackMode", '?', "" }, + {0XA9D22232, nullptr, "scePowerSetCallbackMode", '?', "" }, // These seem to be aliases. - {0x23c31ffe,&WrapI_IUU,"scePowerVolatileMemLock"}, - {0xfa97a599,&WrapI_IUU,"scePowerVolatileMemTryLock"}, - {0xb3edd801,&WrapI_I,"scePowerVolatileMemUnlock"}, + {0X23C31FFE, &WrapI_IUU, "scePowerVolatileMemLock", 'i', "ixx"}, + {0XFA97A599, &WrapI_IUU, "scePowerVolatileMemTryLock", 'i', "ixx"}, + {0XB3EDD801, &WrapI_I, "scePowerVolatileMemUnlock", 'i', "i" }, }; //890129c in tyshooter looks bogus const HLEFunction sceSuspendForUser[] = { - {0xEADB1BD7,&WrapI_I,"sceKernelPowerLock"}, //(int param) set param to 0 - {0x3AEE7261,&WrapI_I,"sceKernelPowerUnlock"},//(int param) set param to 0 - {0x090ccb3f,&WrapI_I,"sceKernelPowerTick"}, + {0XEADB1BD7, &WrapI_I, "sceKernelPowerLock", 'i', "i" }, //(int param) set param to 0 + {0X3AEE7261, &WrapI_I, "sceKernelPowerUnlock", 'i', "i" }, //(int param) set param to 0 + {0X090CCB3F, &WrapI_I, "sceKernelPowerTick", 'i', "i" }, // There's an extra 4MB that can be allocated, which seems to be "volatile". These functions // let you grab it. - {0xa14f40b2,&WrapI_IUU,"sceKernelVolatileMemTryLock"}, - {0xa569e425,&WrapI_I,"sceKernelVolatileMemUnlock"}, - {0x3e0271d3,&WrapI_IUU,"sceKernelVolatileMemLock"}, //when "acquiring mem pool" (fired up) + {0XA14F40B2, &WrapI_IUU, "sceKernelVolatileMemTryLock", 'i', "ixx"}, + {0XA569E425, &WrapI_I, "sceKernelVolatileMemUnlock", 'i', "i" }, + {0X3E0271D3, &WrapI_IUU, "sceKernelVolatileMemLock", 'i', "ixx"}, }; diff --git a/Core/HLE/scePsmf.cpp b/Core/HLE/scePsmf.cpp index ec1211c71c..38e2e4c47c 100644 --- a/Core/HLE/scePsmf.cpp +++ b/Core/HLE/scePsmf.cpp @@ -1992,65 +1992,65 @@ static int __PsmfPlayerFinish(u32 psmfPlayer) { } const HLEFunction scePsmf[] = { - {0xc22c8327, WrapU_UU, "scePsmfSetPsmf"}, - {0xC7DB3A5B, WrapU_UUU, "scePsmfGetCurrentStreamType"}, - {0x28240568, WrapU_U, "scePsmfGetCurrentStreamNumber"}, - {0x1E6D9013, WrapU_UUU, "scePsmfSpecifyStreamWithStreamType"}, - {0x0C120E1D, WrapU_UUU, "scePsmfSpecifyStreamWithStreamTypeNumber"}, - {0x4BC9BDE0, WrapU_UI, "scePsmfSpecifyStream"}, - {0x76D3AEBA, WrapU_UU, "scePsmfGetPresentationStartTime"}, - {0xBD8AE0D8, WrapU_UU, "scePsmfGetPresentationEndTime"}, - {0xEAED89CD, WrapU_U, "scePsmfGetNumberOfStreams"}, - {0x7491C438, WrapU_U, "scePsmfGetNumberOfEPentries"}, - {0x0BA514E5, WrapU_UU, "scePsmfGetVideoInfo"}, - {0xA83F7113, WrapU_UU, "scePsmfGetAudioInfo"}, - {0x971A3A90, WrapU_U, "scePsmfCheckEPmap"}, - {0x68d42328, WrapU_UI, "scePsmfGetNumberOfSpecificStreams"}, - {0x5b70fcc1, WrapU_UU, "scePsmfQueryStreamOffset"}, - {0x9553cc91, WrapU_UU, "scePsmfQueryStreamSize"}, - {0xB78EB9E9, WrapU_UU, "scePsmfGetHeaderSize"}, - {0xA5EBFE81, WrapU_UU, "scePsmfGetStreamSize"}, - {0xE1283895, WrapU_U, "scePsmfGetPsmfVersion"}, - {0x2673646B, WrapU_U, "scePsmfVerifyPsmf"}, - {0x4E624A34, WrapU_UIU, "scePsmfGetEPWithId"}, - {0x7C0E7AC3, WrapU_UUU, "scePsmfGetEPWithTimestamp"}, - {0x5F457515, WrapU_UU, "scePsmfGetEPidWithTimestamp"}, - {0x43ac7dbb, 0, "scePsmfGetPsmfMark"}, - {0xde78e9fc, 0, "scePsmfGetNumberOfPsmfMarks"}, + {0XC22C8327, &WrapU_UU, "scePsmfSetPsmf", 'x', "xx" }, + {0XC7DB3A5B, &WrapU_UUU, "scePsmfGetCurrentStreamType", 'x', "xxx"}, + {0X28240568, &WrapU_U, "scePsmfGetCurrentStreamNumber", 'x', "x" }, + {0X1E6D9013, &WrapU_UUU, "scePsmfSpecifyStreamWithStreamType", 'x', "xxx"}, + {0X0C120E1D, &WrapU_UUU, "scePsmfSpecifyStreamWithStreamTypeNumber", 'x', "xxx"}, + {0X4BC9BDE0, &WrapU_UI, "scePsmfSpecifyStream", 'x', "xi" }, + {0X76D3AEBA, &WrapU_UU, "scePsmfGetPresentationStartTime", 'x', "xx" }, + {0XBD8AE0D8, &WrapU_UU, "scePsmfGetPresentationEndTime", 'x', "xx" }, + {0XEAED89CD, &WrapU_U, "scePsmfGetNumberOfStreams", 'x', "x" }, + {0X7491C438, &WrapU_U, "scePsmfGetNumberOfEPentries", 'x', "x" }, + {0X0BA514E5, &WrapU_UU, "scePsmfGetVideoInfo", 'x', "xx" }, + {0XA83F7113, &WrapU_UU, "scePsmfGetAudioInfo", 'x', "xx" }, + {0X971A3A90, &WrapU_U, "scePsmfCheckEPmap", 'x', "x" }, + {0X68D42328, &WrapU_UI, "scePsmfGetNumberOfSpecificStreams", 'x', "xi" }, + {0X5B70FCC1, &WrapU_UU, "scePsmfQueryStreamOffset", 'x', "xx" }, + {0X9553CC91, &WrapU_UU, "scePsmfQueryStreamSize", 'x', "xx" }, + {0XB78EB9E9, &WrapU_UU, "scePsmfGetHeaderSize", 'x', "xx" }, + {0XA5EBFE81, &WrapU_UU, "scePsmfGetStreamSize", 'x', "xx" }, + {0XE1283895, &WrapU_U, "scePsmfGetPsmfVersion", 'x', "x" }, + {0X2673646B, &WrapU_U, "scePsmfVerifyPsmf", 'x', "x" }, + {0X4E624A34, &WrapU_UIU, "scePsmfGetEPWithId", 'x', "xix"}, + {0X7C0E7AC3, &WrapU_UUU, "scePsmfGetEPWithTimestamp", 'x', "xxx"}, + {0X5F457515, &WrapU_UU, "scePsmfGetEPidWithTimestamp", 'x', "xx" }, + {0X43AC7DBB, nullptr, "scePsmfGetPsmfMark", '?', "" }, + {0XDE78E9FC, nullptr, "scePsmfGetNumberOfPsmfMarks", '?', "" }, }; const HLEFunction scePsmfPlayer[] = { - {0x235d8787, WrapI_UU, "scePsmfPlayerCreate"}, - {0x1078c008, WrapI_U, "scePsmfPlayerStop"}, - {0x1e57a8e7, WrapU_UII, "scePsmfPlayerConfigPlayer"}, - {0x2beb1569, WrapI_U, "scePsmfPlayerBreak"}, - {0x3d6d25a9, WrapI_UC,"scePsmfPlayerSetPsmf"}, - {0x58B83577, WrapI_UC, "scePsmfPlayerSetPsmfCB"}, - {0x3ea82a4b, WrapI_U, "scePsmfPlayerGetAudioOutSize"}, - {0x3ed62233, WrapU_UU, "scePsmfPlayerGetCurrentPts"}, - {0x46f61f8b, WrapI_UU, "scePsmfPlayerGetVideoData"}, - {0x68f07175, WrapU_UUU, "scePsmfPlayerGetCurrentAudioStream"}, - {0x75f03fa2, WrapU_UII, "scePsmfPlayerSelectSpecificVideo"}, - {0x85461eff, WrapU_UII, "scePsmfPlayerSelectSpecificAudio"}, - {0x8a9ebdcd, WrapU_U, "scePsmfPlayerSelectVideo"}, - {0x95a84ee5, WrapI_UUI, "scePsmfPlayerStart"}, - {0x9b71a274, WrapI_U, "scePsmfPlayerDelete"}, - {0x9ff2b2e7, WrapU_UUU, "scePsmfPlayerGetCurrentVideoStream"}, - {0xa0b8ca55, WrapI_U, "scePsmfPlayerUpdate"}, - {0xa3d81169, WrapU_UII, "scePsmfPlayerChangePlayMode"}, - {0xb8d10c56, WrapU_U, "scePsmfPlayerSelectAudio"}, - {0xb9848a74, WrapI_UU, "scePsmfPlayerGetAudioData"}, - {0xdf089680, WrapU_UU, "scePsmfPlayerGetPsmfInfo"}, - {0xe792cd94, WrapI_U, "scePsmfPlayerReleasePsmf"}, - {0xf3efaa91, WrapU_UUU, "scePsmfPlayerGetCurrentPlayMode"}, - {0xf8ef08a6, WrapI_U, "scePsmfPlayerGetCurrentStatus"}, - {0x2D0E4E0A, WrapI_UUU, "scePsmfPlayerSetTempBuf"}, - {0x76C0F4AE, WrapI_UCI, "scePsmfPlayerSetPsmfOffset"}, - {0xA72DB4F9, WrapI_UCI, "scePsmfPlayerSetPsmfOffsetCB"}, - {0x340c12cb, 0, "scePsmfPlayer_340C12CB"}, + {0X235D8787, &WrapI_UU, "scePsmfPlayerCreate", 'i', "xx" }, + {0X1078C008, &WrapI_U, "scePsmfPlayerStop", 'i', "x" }, + {0X1E57A8E7, &WrapU_UII, "scePsmfPlayerConfigPlayer", 'x', "xii"}, + {0X2BEB1569, &WrapI_U, "scePsmfPlayerBreak", 'i', "x" }, + {0X3D6D25A9, &WrapI_UC, "scePsmfPlayerSetPsmf", 'i', "xs" }, + {0X58B83577, &WrapI_UC, "scePsmfPlayerSetPsmfCB", 'i', "xs" }, + {0X3EA82A4B, &WrapI_U, "scePsmfPlayerGetAudioOutSize", 'i', "x" }, + {0X3ED62233, &WrapU_UU, "scePsmfPlayerGetCurrentPts", 'x', "xx" }, + {0X46F61F8B, &WrapI_UU, "scePsmfPlayerGetVideoData", 'i', "xx" }, + {0X68F07175, &WrapU_UUU, "scePsmfPlayerGetCurrentAudioStream", 'x', "xxx"}, + {0X75F03FA2, &WrapU_UII, "scePsmfPlayerSelectSpecificVideo", 'x', "xii"}, + {0X85461EFF, &WrapU_UII, "scePsmfPlayerSelectSpecificAudio", 'x', "xii"}, + {0X8A9EBDCD, &WrapU_U, "scePsmfPlayerSelectVideo", 'x', "x" }, + {0X95A84EE5, &WrapI_UUI, "scePsmfPlayerStart", 'i', "xxi"}, + {0X9B71A274, &WrapI_U, "scePsmfPlayerDelete", 'i', "x" }, + {0X9FF2B2E7, &WrapU_UUU, "scePsmfPlayerGetCurrentVideoStream", 'x', "xxx"}, + {0XA0B8CA55, &WrapI_U, "scePsmfPlayerUpdate", 'i', "x" }, + {0XA3D81169, &WrapU_UII, "scePsmfPlayerChangePlayMode", 'x', "xii"}, + {0XB8D10C56, &WrapU_U, "scePsmfPlayerSelectAudio", 'x', "x" }, + {0XB9848A74, &WrapI_UU, "scePsmfPlayerGetAudioData", 'i', "xx" }, + {0XDF089680, &WrapU_UU, "scePsmfPlayerGetPsmfInfo", 'x', "xx" }, + {0XE792CD94, &WrapI_U, "scePsmfPlayerReleasePsmf", 'i', "x" }, + {0XF3EFAA91, &WrapU_UUU, "scePsmfPlayerGetCurrentPlayMode", 'x', "xxx"}, + {0XF8EF08A6, &WrapI_U, "scePsmfPlayerGetCurrentStatus", 'i', "x" }, + {0X2D0E4E0A, &WrapI_UUU, "scePsmfPlayerSetTempBuf", 'i', "xxx"}, + {0X76C0F4AE, &WrapI_UCI, "scePsmfPlayerSetPsmfOffset", 'i', "xsi"}, + {0XA72DB4F9, &WrapI_UCI, "scePsmfPlayerSetPsmfOffsetCB", 'i', "xsi"}, + {0X340C12CB, nullptr, "scePsmfPlayer_340C12CB", '?', "" }, // Fake function for PPSSPP's use. - {0x05b193b7, WrapI_U<__PsmfPlayerFinish>, "__PsmfPlayerFinish"}, + {0X05B193B7, &WrapI_U<__PsmfPlayerFinish>, "__PsmfPlayerFinish", 'i', "x" }, }; void Register_scePsmf() { diff --git a/Core/HLE/scePspNpDrm_user.cpp b/Core/HLE/scePspNpDrm_user.cpp index 00fcb94ebd..6b844a1de0 100644 --- a/Core/HLE/scePspNpDrm_user.cpp +++ b/Core/HLE/scePspNpDrm_user.cpp @@ -45,12 +45,12 @@ static int sceNpDrmOpen() const HLEFunction sceNpDrm[] = { - {0xA1336091, WrapI_U, "sceNpDrmSetLicenseeKey"}, - {0x9B745542, WrapI_V, "sceNpDrmClearLicenseeKey"}, - {0x275987D1, WrapI_C, "sceNpDrmRenameCheck"}, - {0x08d98894, WrapI_U, "sceNpDrmEdataSetupKey"}, - {0x219EF5CC, WrapI_U, "sceNpDrmEdataGetDataSize"}, - {0x2BAA4294, WrapI_V, "sceNpDrmOpen"}, + {0XA1336091, &WrapI_U, "sceNpDrmSetLicenseeKey", 'i', "x"}, + {0X9B745542, &WrapI_V, "sceNpDrmClearLicenseeKey", 'i', "" }, + {0X275987D1, &WrapI_C, "sceNpDrmRenameCheck", 'i', "s"}, + {0X08D98894, &WrapI_U, "sceNpDrmEdataSetupKey", 'i', "x"}, + {0X219EF5CC, &WrapI_U, "sceNpDrmEdataGetDataSize", 'i', "x"}, + {0X2BAA4294, &WrapI_V, "sceNpDrmOpen", 'i', "" }, }; void Register_sceNpDrm() diff --git a/Core/HLE/sceRtc.cpp b/Core/HLE/sceRtc.cpp index d9be62ef84..394d7915c3 100644 --- a/Core/HLE/sceRtc.cpp +++ b/Core/HLE/sceRtc.cpp @@ -1080,52 +1080,52 @@ static int sceRtcFormatRFC3339LocalTime(u32 outPtr, u32 srcTickPtr) const HLEFunction sceRtc[] = { - {0xC41C2853, &WrapU_V, "sceRtcGetTickResolution"}, - {0x3f7ad767, &WrapU_U, "sceRtcGetCurrentTick"}, - {0x011F03C1, &WrapU64_V, "sceRtcGetAccumulativeTime"}, - {0x029CA3B3, &WrapU64_V, "sceRtcGetAccumlativeTime"}, - {0x4cfa57b0, &WrapU_UI, "sceRtcGetCurrentClock"}, - {0xE7C27D1B, &WrapU_U, "sceRtcGetCurrentClockLocalTime"}, - {0x34885E0D, &WrapI_UU, "sceRtcConvertUtcToLocalTime"}, - {0x779242A2, &WrapI_UU, "sceRtcConvertLocalTimeToUTC"}, - {0x42307A17, &WrapU_U, "sceRtcIsLeapYear"}, - {0x05ef322c, &WrapU_UU, "sceRtcGetDaysInMonth"}, - {0x57726bc1, &WrapU_UUU, "sceRtcGetDayOfWeek"}, - {0x4B1B5E82, &WrapI_U, "sceRtcCheckValid"}, - {0x3a807cc8, &WrapI_UU, "sceRtcSetTime_t"}, - {0x27c4594c, &WrapI_UU, "sceRtcGetTime_t"}, - {0xF006F264, &WrapI_UU, "sceRtcSetDosTime"}, - {0x36075567, &WrapI_UU, "sceRtcGetDosTime"}, - {0x7ACE4C04, &WrapI_UU64, "sceRtcSetWin32FileTime"}, - {0xCF561893, &WrapI_UU, "sceRtcGetWin32FileTime"}, - {0x7ED29E40, &WrapU_UU, "sceRtcSetTick"}, - {0x6FF40ACC, &WrapU_UU, "sceRtcGetTick"}, - {0x9ED0AE87, &WrapI_UU, "sceRtcCompareTick"}, - {0x44F45E05, &WrapI_UUU64, "sceRtcTickAddTicks"}, - {0x26D25A5D, &WrapI_UUU64, "sceRtcTickAddMicroseconds"}, - {0xF2A4AFE5, &WrapI_UUU64, "sceRtcTickAddSeconds"}, - {0xE6605BCA, &WrapI_UUU64, "sceRtcTickAddMinutes"}, - {0x26D7A24A, &WrapI_UUI, "sceRtcTickAddHours"}, - {0xE51B4B7A, &WrapI_UUI, "sceRtcTickAddDays"}, - {0xCF3A2CA8, &WrapI_UUI, "sceRtcTickAddWeeks"}, - {0xDBF74F1B, &WrapI_UUI, "sceRtcTickAddMonths"}, - {0x42842C77, &WrapI_UUI, "sceRtcTickAddYears"}, - {0xC663B3B9, &WrapI_UUI, "sceRtcFormatRFC2822"}, - {0x7DE6711B, &WrapI_UU, "sceRtcFormatRFC2822LocalTime"}, - {0x0498FB3C, &WrapI_UUI, "sceRtcFormatRFC3339"}, - {0x27F98543, &WrapI_UU, "sceRtcFormatRFC3339LocalTime"}, - {0xDFBC5F16, &WrapI_UU, "sceRtcParseDateTime"}, - {0x28E1E988, 0, "sceRtcParseRFC3339"}, - {0xe1c93e47, &WrapI_UU, "sceRtcGetTime64_t"}, - {0x1909c99b, &WrapI_UU64, "sceRtcSetTime64_t"}, - {0x62685E98, &WrapI_U, "sceRtcGetLastAdjustedTime"}, - {0x203ceb0d, &WrapI_U, "sceRtcGetLastReincarnatedTime"}, - {0x7d1fbed3, &WrapI_UU, "sceRtcSetAlarmTick"}, - {0xf5fcc995, 0, "sceRtcGetCurrentNetworkTick"}, - {0x81fcda34, 0, "sceRtcIsAlarmed"}, - {0xfb3b18cd, 0, "sceRtcRegisterCallback"}, - {0x6a676d2d, 0, "sceRtcUnregisterCallback"}, - {0xc2ddbeb5, 0, "sceRtcGetAlarmTick"}, + {0XC41C2853, &WrapU_V, "sceRtcGetTickResolution", 'x', "" }, + {0X3F7AD767, &WrapU_U, "sceRtcGetCurrentTick", 'x', "x" }, + {0X011F03C1, &WrapU64_V, "sceRtcGetAccumulativeTime", 'X', "" }, + {0X029CA3B3, &WrapU64_V, "sceRtcGetAccumlativeTime", 'X', "" }, + {0X4CFA57B0, &WrapU_UI, "sceRtcGetCurrentClock", 'x', "xi" }, + {0XE7C27D1B, &WrapU_U, "sceRtcGetCurrentClockLocalTime", 'x', "x" }, + {0X34885E0D, &WrapI_UU, "sceRtcConvertUtcToLocalTime", 'i', "xx" }, + {0X779242A2, &WrapI_UU, "sceRtcConvertLocalTimeToUTC", 'i', "xx" }, + {0X42307A17, &WrapU_U, "sceRtcIsLeapYear", 'x', "x" }, + {0X05EF322C, &WrapU_UU, "sceRtcGetDaysInMonth", 'x', "xx" }, + {0X57726BC1, &WrapU_UUU, "sceRtcGetDayOfWeek", 'x', "xxx"}, + {0X4B1B5E82, &WrapI_U, "sceRtcCheckValid", 'i', "x" }, + {0X3A807CC8, &WrapI_UU, "sceRtcSetTime_t", 'i', "xx" }, + {0X27C4594C, &WrapI_UU, "sceRtcGetTime_t", 'i', "xx" }, + {0XF006F264, &WrapI_UU, "sceRtcSetDosTime", 'i', "xx" }, + {0X36075567, &WrapI_UU, "sceRtcGetDosTime", 'i', "xx" }, + {0X7ACE4C04, &WrapI_UU64, "sceRtcSetWin32FileTime", 'i', "xX" }, + {0XCF561893, &WrapI_UU, "sceRtcGetWin32FileTime", 'i', "xx" }, + {0X7ED29E40, &WrapU_UU, "sceRtcSetTick", 'x', "xx" }, + {0X6FF40ACC, &WrapU_UU, "sceRtcGetTick", 'x', "xx" }, + {0X9ED0AE87, &WrapI_UU, "sceRtcCompareTick", 'i', "xx" }, + {0X44F45E05, &WrapI_UUU64, "sceRtcTickAddTicks", 'i', "xxX"}, + {0X26D25A5D, &WrapI_UUU64, "sceRtcTickAddMicroseconds", 'i', "xxX"}, + {0XF2A4AFE5, &WrapI_UUU64, "sceRtcTickAddSeconds", 'i', "xxX"}, + {0XE6605BCA, &WrapI_UUU64, "sceRtcTickAddMinutes", 'i', "xxX"}, + {0X26D7A24A, &WrapI_UUI, "sceRtcTickAddHours", 'i', "xxi"}, + {0XE51B4B7A, &WrapI_UUI, "sceRtcTickAddDays", 'i', "xxi"}, + {0XCF3A2CA8, &WrapI_UUI, "sceRtcTickAddWeeks", 'i', "xxi"}, + {0XDBF74F1B, &WrapI_UUI, "sceRtcTickAddMonths", 'i', "xxi"}, + {0X42842C77, &WrapI_UUI, "sceRtcTickAddYears", 'i', "xxi"}, + {0XC663B3B9, &WrapI_UUI, "sceRtcFormatRFC2822", 'i', "xxi"}, + {0X7DE6711B, &WrapI_UU, "sceRtcFormatRFC2822LocalTime", 'i', "xx" }, + {0X0498FB3C, &WrapI_UUI, "sceRtcFormatRFC3339", 'i', "xxi"}, + {0X27F98543, &WrapI_UU, "sceRtcFormatRFC3339LocalTime", 'i', "xx" }, + {0XDFBC5F16, &WrapI_UU, "sceRtcParseDateTime", 'i', "xx" }, + {0X28E1E988, nullptr, "sceRtcParseRFC3339", '?', "" }, + {0XE1C93E47, &WrapI_UU, "sceRtcGetTime64_t", 'i', "xx" }, + {0X1909C99B, &WrapI_UU64, "sceRtcSetTime64_t", 'i', "xX" }, + {0X62685E98, &WrapI_U, "sceRtcGetLastAdjustedTime", 'i', "x" }, + {0X203CEB0D, &WrapI_U, "sceRtcGetLastReincarnatedTime", 'i', "x" }, + {0X7D1FBED3, &WrapI_UU, "sceRtcSetAlarmTick", 'i', "xx" }, + {0XF5FCC995, nullptr, "sceRtcGetCurrentNetworkTick", '?', "" }, + {0X81FCDA34, nullptr, "sceRtcIsAlarmed", '?', "" }, + {0XFB3B18CD, nullptr, "sceRtcRegisterCallback", '?', "" }, + {0X6A676D2D, nullptr, "sceRtcUnregisterCallback", '?', "" }, + {0XC2DDBEB5, nullptr, "sceRtcGetAlarmTick", '?', "" }, }; void Register_sceRtc() diff --git a/Core/HLE/sceSas.cpp b/Core/HLE/sceSas.cpp index f346fa325a..0b4b51aad3 100644 --- a/Core/HLE/sceSas.cpp +++ b/Core/HLE/sceSas.cpp @@ -576,38 +576,38 @@ static u32 __sceSasUnsetATRAC3(u32 core, int voiceNum) { const HLEFunction sceSasCore[] = { - {0x42778a9f, WrapU_UUUUU, "__sceSasInit"}, - {0xa3589d81, WrapU_UU<_sceSasCore>, "__sceSasCore"}, - {0x50a14dfc, WrapU_UUII<_sceSasCoreWithMix>, "__sceSasCoreWithMix"}, - {0x68a46b95, WrapU_U, "__sceSasGetEndFlag"}, - {0x440ca7d8, WrapU_UIIIII, "__sceSasSetVolume"}, - {0xad84d37f, WrapU_UII, "__sceSasSetPitch"}, - {0x99944089, WrapU_UIUII, "__sceSasSetVoice"}, - {0xb7660a23, WrapU_UII, "__sceSasSetNoise"}, - {0x019b25eb, WrapU_UIIIIII, "__sceSasSetADSR"}, - {0x9ec3676a, WrapU_UIIIIII, "__sceSasSetADSRmode"}, - {0x5f9529f6, WrapU_UII, "__sceSasSetSL"}, - {0x74ae582a, WrapU_UI, "__sceSasGetEnvelopeHeight"}, - {0xcbcd4f79, WrapU_UIUU, "__sceSasSetSimpleADSR"}, - {0xa0cf2fa4, WrapU_UI, "__sceSasSetKeyOff"}, - {0x76f01aca, WrapU_UI, "__sceSasSetKeyOn"}, - {0xf983b186, WrapU_UII, "__sceSasRevVON"}, - {0xd5a229c9, WrapU_UUU, "__sceSasRevEVOL"}, - {0x33d4ab37, WrapU_UI, "__sceSasRevType"}, - {0x267a6dd2, WrapU_UII, "__sceSasRevParam"}, - {0x2c8e6ab3, WrapU_U, "__sceSasGetPauseFlag"}, - {0x787d04d5, WrapU_UUI, "__sceSasSetPause"}, - {0xa232cbe6, WrapU_UII, "__sceSasSetTrianglarWave"}, // Typo. - {0xd5ebbbcd, WrapU_UII, "__sceSasSetSteepWave"}, - {0xBD11B7C2, WrapU_U, "__sceSasGetGrain"}, - {0xd1e0a01e, WrapU_UI, "__sceSasSetGrain"}, - {0xe175ef66, WrapU_U, "__sceSasGetOutputmode"}, - {0xe855bf76, WrapU_UU, "__sceSasSetOutputmode"}, - {0x07f58c24, WrapU_UU, "__sceSasGetAllEnvelopeHeights"}, - {0xE1CD9561, WrapU_UIUII, "__sceSasSetVoicePCM"}, - {0x4AA9EAD6, WrapU_UIU<__sceSasSetVoiceATRAC3>,"__sceSasSetVoiceATRAC3"}, - {0x7497EA85, WrapU_UIUI<__sceSasConcatenateATRAC3>,"__sceSasConcatenateATRAC3"}, - {0xF6107F00, WrapU_UI<__sceSasUnsetATRAC3>,"__sceSasUnsetATRAC3"}, + {0X42778A9F, &WrapU_UUUUU, "__sceSasInit", 'x', "xxxxx" }, + {0XA3589D81, &WrapU_UU<_sceSasCore>, "__sceSasCore", 'x', "xx" }, + {0X50A14DFC, &WrapU_UUII<_sceSasCoreWithMix>, "__sceSasCoreWithMix", 'x', "xxii" }, + {0X68A46B95, &WrapU_U, "__sceSasGetEndFlag", 'x', "x" }, + {0X440CA7D8, &WrapU_UIIIII, "__sceSasSetVolume", 'x', "xiiiii" }, + {0XAD84D37F, &WrapU_UII, "__sceSasSetPitch", 'x', "xii" }, + {0X99944089, &WrapU_UIUII, "__sceSasSetVoice", 'x', "xixii" }, + {0XB7660A23, &WrapU_UII, "__sceSasSetNoise", 'x', "xii" }, + {0X019B25EB, &WrapU_UIIIIII, "__sceSasSetADSR", 'x', "xiiiiii"}, + {0X9EC3676A, &WrapU_UIIIIII, "__sceSasSetADSRmode", 'x', "xiiiiii"}, + {0X5F9529F6, &WrapU_UII, "__sceSasSetSL", 'x', "xii" }, + {0X74AE582A, &WrapU_UI, "__sceSasGetEnvelopeHeight", 'x', "xi" }, + {0XCBCD4F79, &WrapU_UIUU, "__sceSasSetSimpleADSR", 'x', "xixx" }, + {0XA0CF2FA4, &WrapU_UI, "__sceSasSetKeyOff", 'x', "xi" }, + {0X76F01ACA, &WrapU_UI, "__sceSasSetKeyOn", 'x', "xi" }, + {0XF983B186, &WrapU_UII, "__sceSasRevVON", 'x', "xii" }, + {0XD5A229C9, &WrapU_UUU, "__sceSasRevEVOL", 'x', "xxx" }, + {0X33D4AB37, &WrapU_UI, "__sceSasRevType", 'x', "xi" }, + {0X267A6DD2, &WrapU_UII, "__sceSasRevParam", 'x', "xii" }, + {0X2C8E6AB3, &WrapU_U, "__sceSasGetPauseFlag", 'x', "x" }, + {0X787D04D5, &WrapU_UUI, "__sceSasSetPause", 'x', "xxi" }, + {0XA232CBE6, &WrapU_UII, "__sceSasSetTrianglarWave", 'x', "xii" }, // Typo. + {0XD5EBBBCD, &WrapU_UII, "__sceSasSetSteepWave", 'x', "xii" }, + {0XBD11B7C2, &WrapU_U, "__sceSasGetGrain", 'x', "x" }, + {0XD1E0A01E, &WrapU_UI, "__sceSasSetGrain", 'x', "xi" }, + {0XE175EF66, &WrapU_U, "__sceSasGetOutputmode", 'x', "x" }, + {0XE855BF76, &WrapU_UU, "__sceSasSetOutputmode", 'x', "xx" }, + {0X07F58C24, &WrapU_UU, "__sceSasGetAllEnvelopeHeights", 'x', "xx" }, + {0XE1CD9561, &WrapU_UIUII, "__sceSasSetVoicePCM", 'x', "xixii" }, + {0X4AA9EAD6, &WrapU_UIU<__sceSasSetVoiceATRAC3>, "__sceSasSetVoiceATRAC3", 'x', "xix" }, + {0X7497EA85, &WrapU_UIUI<__sceSasConcatenateATRAC3>, "__sceSasConcatenateATRAC3", 'x', "xixi" }, + {0XF6107F00, &WrapU_UI<__sceSasUnsetATRAC3>, "__sceSasUnsetATRAC3", 'x', "xi" }, }; void Register_sceSasCore() diff --git a/Core/HLE/sceSfmt19937.cpp b/Core/HLE/sceSfmt19937.cpp index daefe5abfc..320a665e47 100644 --- a/Core/HLE/sceSfmt19937.cpp +++ b/Core/HLE/sceSfmt19937.cpp @@ -108,12 +108,12 @@ static int sceSfmt19937FillArray64(u32 sfmt, u32 array, int arraylen) { const HLEFunction sceSfmt19937[] = { - { 0x161ACEB2, WrapI_UU, "sceSfmt19937InitGenRand" }, - { 0xDD5A5D6C, WrapI_UUI, "sceSfmt19937InitByArray" }, - { 0xB33FE749, WrapU_U, "sceSfmt19937GenRand32" }, - { 0xD5AC9F99, WrapU64_U, "sceSfmt19937GenRand64" }, - { 0xDB025BFA, WrapI_UUI, "sceSfmt19937FillArray32" }, - { 0xEE2938C4, WrapI_UUI, "sceSfmt19937FillArray64" }, + {0X161ACEB2, &WrapI_UU, "sceSfmt19937InitGenRand", 'i', "xx" }, + {0XDD5A5D6C, &WrapI_UUI, "sceSfmt19937InitByArray", 'i', "xxi"}, + {0XB33FE749, &WrapU_U, "sceSfmt19937GenRand32", 'x', "x" }, + {0XD5AC9F99, &WrapU64_U, "sceSfmt19937GenRand64", 'X', "x" }, + {0XDB025BFA, &WrapI_UUI, "sceSfmt19937FillArray32", 'i', "xxi"}, + {0XEE2938C4, &WrapI_UUI, "sceSfmt19937FillArray64", 'i', "xxi"}, }; void Register_sceSfmt19937() diff --git a/Core/HLE/sceSha256.cpp b/Core/HLE/sceSha256.cpp index eb9e1e77be..9ef585bd3b 100644 --- a/Core/HLE/sceSha256.cpp +++ b/Core/HLE/sceSha256.cpp @@ -40,7 +40,7 @@ static int sceSha256Digest(u32 data, int dataLen, u32 digestPtr) { const HLEFunction sceSha256[] = { - { 0x318A350C, WrapI_UIU, "sceSha256Digest" }, + {0X318A350C, &WrapI_UIU, "sceSha256Digest", 'i', "xix"}, }; void Register_sceSha256() diff --git a/Core/HLE/sceSsl.cpp b/Core/HLE/sceSsl.cpp index 9dac22afa4..2fa138cb78 100644 --- a/Core/HLE/sceSsl.cpp +++ b/Core/HLE/sceSsl.cpp @@ -110,18 +110,18 @@ static int sceSslGetUsedMemoryCurrent(u32 currentMemPtr) const HLEFunction sceSsl[] = { - {0x957ECBE2, WrapI_I, "sceSslInit"}, - {0x191CDEFF, WrapI_V, "sceSslEnd"}, - {0x5BFB6B61, 0, "sceSslGetNotAfter"}, - {0x17A10DCC, 0, "sceSslGetNotBefore"}, - {0x3DD5E023, 0, "sceSslGetSubjectName"}, - {0x1B7C8191, 0, "sceSslGetIssuerName"}, - {0xCC0919B0, 0, "sceSslGetSerialNumber"}, - {0x058D21C0, 0, "sceSslGetNameEntryCount"}, - {0xD6D097B4, 0, "sceSslGetNameEntryInfo"}, - {0xB99EDE6A, WrapI_U, "sceSslGetUsedMemoryMax"}, - {0x0EB43B06, WrapI_U, "sceSslGetUsedMemoryCurrent"}, - {0xF57765D3, 0, "sceSslGetKeyUsage"}, + {0X957ECBE2, &WrapI_I, "sceSslInit", 'i', "i"}, + {0X191CDEFF, &WrapI_V, "sceSslEnd", 'i', "" }, + {0X5BFB6B61, nullptr, "sceSslGetNotAfter", '?', "" }, + {0X17A10DCC, nullptr, "sceSslGetNotBefore", '?', "" }, + {0X3DD5E023, nullptr, "sceSslGetSubjectName", '?', "" }, + {0X1B7C8191, nullptr, "sceSslGetIssuerName", '?', "" }, + {0XCC0919B0, nullptr, "sceSslGetSerialNumber", '?', "" }, + {0X058D21C0, nullptr, "sceSslGetNameEntryCount", '?', "" }, + {0XD6D097B4, nullptr, "sceSslGetNameEntryInfo", '?', "" }, + {0XB99EDE6A, &WrapI_U, "sceSslGetUsedMemoryMax", 'i', "x"}, + {0X0EB43B06, &WrapI_U, "sceSslGetUsedMemoryCurrent", 'i', "x"}, + {0XF57765D3, nullptr, "sceSslGetKeyUsage", '?', "" }, }; void Register_sceSsl() diff --git a/Core/HLE/sceUmd.cpp b/Core/HLE/sceUmd.cpp index af72aea835..ce28b59d07 100644 --- a/Core/HLE/sceUmd.cpp +++ b/Core/HLE/sceUmd.cpp @@ -522,22 +522,22 @@ static u32 sceUmdReplacePermit() const HLEFunction sceUmdUser[] = { - {0xC6183D47,WrapI_UC,"sceUmdActivate"}, - {0x6B4A146C,&WrapU_V,"sceUmdGetDriveStat"}, - {0x46EBB729,WrapI_V,"sceUmdCheckMedium"}, - {0xE83742BA,WrapI_UC,"sceUmdDeactivate"}, - {0x8EF08FCE,WrapI_U,"sceUmdWaitDriveStat"}, - {0x56202973,WrapI_UU,"sceUmdWaitDriveStatWithTimer"}, - {0x4A9E5E29,WrapI_UU,"sceUmdWaitDriveStatCB"}, - {0x6af9b50a,WrapU_V,"sceUmdCancelWaitDriveStat"}, - {0x20628E6F,&WrapU_V,"sceUmdGetErrorStat"}, - {0x340B7686,WrapU_U,"sceUmdGetDiscInfo"}, - {0xAEE7404D,&WrapU_U,"sceUmdRegisterUMDCallBack"}, - {0xBD2BDE07,&WrapI_I,"sceUmdUnRegisterUMDCallBack"}, - {0x87533940,WrapU_V,"sceUmdReplaceProhibit"}, - {0xCBE9F02A,WrapU_V,"sceUmdReplacePermit"}, - {0x14c6c45c,0,"sceUmdUnuseUMDInMsUsbWlan"}, - {0xb103fa38,0,"sceUmdUseUMDInMsUsbWlan"}, + {0XC6183D47, &WrapI_UC, "sceUmdActivate", 'i', "xs"}, + {0X6B4A146C, &WrapU_V, "sceUmdGetDriveStat", 'x', "" }, + {0X46EBB729, &WrapI_V, "sceUmdCheckMedium", 'i', "" }, + {0XE83742BA, &WrapI_UC, "sceUmdDeactivate", 'i', "xs"}, + {0X8EF08FCE, &WrapI_U, "sceUmdWaitDriveStat", 'i', "x" }, + {0X56202973, &WrapI_UU, "sceUmdWaitDriveStatWithTimer", 'i', "xx"}, + {0X4A9E5E29, &WrapI_UU, "sceUmdWaitDriveStatCB", 'i', "xx"}, + {0X6AF9B50A, &WrapU_V, "sceUmdCancelWaitDriveStat", 'x', "" }, + {0X20628E6F, &WrapU_V, "sceUmdGetErrorStat", 'x', "" }, + {0X340B7686, &WrapU_U, "sceUmdGetDiscInfo", 'x', "x" }, + {0XAEE7404D, &WrapU_U, "sceUmdRegisterUMDCallBack", 'x', "x" }, + {0XBD2BDE07, &WrapI_I, "sceUmdUnRegisterUMDCallBack", 'i', "i" }, + {0X87533940, &WrapU_V, "sceUmdReplaceProhibit", 'x', "" }, + {0XCBE9F02A, &WrapU_V, "sceUmdReplacePermit", 'x', "" }, + {0X14C6C45C, nullptr, "sceUmdUnuseUMDInMsUsbWlan", '?', "" }, + {0XB103FA38, nullptr, "sceUmdUseUMDInMsUsbWlan", '?', "" }, }; void Register_sceUmdUser() diff --git a/Core/HLE/sceUsb.cpp b/Core/HLE/sceUsb.cpp index 27e5a561c0..40d3e19758 100644 --- a/Core/HLE/sceUsb.cpp +++ b/Core/HLE/sceUsb.cpp @@ -95,85 +95,85 @@ static int sceUsbDeactivate(u32 pid) { const HLEFunction sceUsb[] = { - {0xae5de6af, WrapI_CUU, "sceUsbStart"}, - {0xc2464fa0, WrapI_CUU, "sceUsbStop"}, - {0xc21645a4, WrapI_V, "sceUsbGetState"}, - {0x4e537366, 0, "sceUsbGetDrvList"}, - {0x112cc951, 0, "sceUsbGetDrvState"}, - {0x586db82c, WrapI_U, "sceUsbActivate"}, - {0xc572a9c8, WrapI_U, "sceUsbDeactivate"}, - {0x5be0e002, 0, "sceUsbWaitState"}, - {0x616f2b61, 0, "sceUsbWaitStateCB"}, - {0x1c360735, 0, "sceUsbWaitCancel"}, + {0XAE5DE6AF, &WrapI_CUU, "sceUsbStart", 'i', "sxx"}, + {0XC2464FA0, &WrapI_CUU, "sceUsbStop", 'i', "sxx"}, + {0XC21645A4, &WrapI_V, "sceUsbGetState", 'i', "" }, + {0X4E537366, nullptr, "sceUsbGetDrvList", '?', "" }, + {0X112CC951, nullptr, "sceUsbGetDrvState", '?', "" }, + {0X586DB82C, &WrapI_U, "sceUsbActivate", 'i', "x" }, + {0XC572A9C8, &WrapI_U, "sceUsbDeactivate", 'i', "x" }, + {0X5BE0E002, nullptr, "sceUsbWaitState", '?', "" }, + {0X616F2B61, nullptr, "sceUsbWaitStateCB", '?', "" }, + {0X1C360735, nullptr, "sceUsbWaitCancel", '?', "" }, }; const HLEFunction sceUsbstor[] = { - {0x60066CFE, 0, "sceUsbstorGetStatus"}, + {0X60066CFE, nullptr, "sceUsbstorGetStatus", '?', "" }, }; const HLEFunction sceUsbstorBoot[] = { - {0xE58818A8, 0, "sceUsbstorBootSetCapacity"}, - {0x594BBF95, 0, "sceUsbstorBootSetLoadAddr"}, - {0x6D865ECD, 0, "sceUsbstorBootGetDataSize"}, - {0xA1119F0D, 0, "sceUsbstorBootSetStatus"}, - {0x1F080078, 0, "sceUsbstorBootRegisterNotify"}, - {0xA55C9E16, 0, "sceUsbstorBootUnregisterNotify"}, + {0XE58818A8, nullptr, "sceUsbstorBootSetCapacity", '?', "" }, + {0X594BBF95, nullptr, "sceUsbstorBootSetLoadAddr", '?', "" }, + {0X6D865ECD, nullptr, "sceUsbstorBootGetDataSize", '?', "" }, + {0XA1119F0D, nullptr, "sceUsbstorBootSetStatus", '?', "" }, + {0X1F080078, nullptr, "sceUsbstorBootRegisterNotify", '?', "" }, + {0XA55C9E16, nullptr, "sceUsbstorBootUnregisterNotify", '?', "" }, }; const HLEFunction sceUsbCam[] = { - { 0x17F7B2FB, 0, "sceUsbCamSetupVideo" }, - { 0xF93C4669, 0, "sceUsbCamAutoImageReverseSW" }, - { 0x574A8C3F, 0, "sceUsbCamStartVideo" }, - { 0x6CF32CB9, 0, "sceUsbCamStopVideo" }, - { 0x03ED7A82, 0, "sceUsbCamSetupMic" }, - { 0x82A64030, 0, "sceUsbCamStartMic" }, - { 0x7DAC0C71, 0, "sceUsbCamReadVideoFrameBlocking" }, - { 0x99D86281, 0, "sceUsbCamReadVideoFrame" }, - { 0x41E73E95, 0, "sceUsbCamPollReadVideoFrameEnd" }, - { 0xF90B2293, 0, "sceUsbCamWaitReadVideoFrameEnd" }, - { 0x4C34F553, 0, "sceUsbCamGetLensDirection" }, - { 0x3F0CF289, 0, "sceUsbCamSetupStill" }, - { 0x0A41A298, 0, "sceUsbCamSetupStillEx" }, - { 0x61BE5CAC, 0, "sceUsbCamStillInputBlocking" }, - { 0xFB0A6C5D, 0, "sceUsbCamStillInput" }, - { 0x7563AFA1, 0, "sceUsbCamStillWaitInputEnd" }, - { 0x1A46CFE7, 0, "sceUsbCamStillPollInputEnd" }, - { 0xA720937C, 0, "sceUsbCamStillCancelInput" }, - { 0xE5959C36, 0, "sceUsbCamStillGetInputLength" }, - { 0xCFE9E999, 0, "sceUsbCamSetupVideoEx" }, - { 0xDF9D0C92, 0, "sceUsbCamGetReadVideoFrameSize" }, - { 0x6E205974, 0, "sceUsbCamSetSaturation" }, - { 0x4F3D84D5, 0, "sceUsbCamSetBrightness" }, - { 0x09C26C7E, 0, "sceUsbCamSetContrast" }, - { 0x622F83CC, 0, "sceUsbCamSetSharpness" }, - { 0xD4876173, 0, "sceUsbCamSetImageEffectMode" }, - { 0x1D686870, 0, "sceUsbCamSetEvLevel" }, - { 0x951BEDF5, 0, "sceUsbCamSetReverseMode" }, - { 0xC484901F, 0, "sceUsbCamSetZoom" }, - { 0x383E9FA8, 0, "sceUsbCamGetSaturation" }, - { 0x70F522C5, 0, "sceUsbCamGetBrightness" }, - { 0xA063A957, 0, "sceUsbCamGetContrast" }, - { 0xFDB68C23, 0, "sceUsbCamGetSharpness" }, - { 0x994471E0, 0, "sceUsbCamGetImageEffectMode" }, - { 0x2BCD50C0, 0, "sceUsbCamGetEvLevel" }, - { 0xD5279339, 0, "sceUsbCamGetReverseMode" }, - { 0x9E8AAF8D, 0, "sceUsbCamGetZoom" }, - { 0x11A1F128, 0, "sceUsbCamGetAutoImageReverseState" }, - { 0x08AEE98A, 0, "sceUsbCamSetMicGain" }, - { 0x2E930264, 0, "sceUsbCamSetupMicEx" }, - { 0x36636925, 0, "sceUsbCamReadMicBlocking" }, - { 0x3DC0088E, 0, "sceUsbCamReadMic" }, - { 0x41EE8797, 0, "sceUsbCamUnregisterLensRotationCallback" }, - { 0x5145868A, 0, "sceUsbCamStopMic" }, - { 0x5778B452, 0, "sceUsbCamGetMicDataLength" }, - { 0x6784E6A8, 0, "sceUsbCamSetAntiFlicker" }, - { 0xAA7D94BA, 0, "sceUsbCamGetAntiFlicker" }, - { 0xB048A67D, 0, "sceUsbCamWaitReadMicEnd" }, - { 0xD293A100, 0, "sceUsbCamRegisterLensRotationCallback" }, - { 0xF8847F60, 0, "sceUsbCamPollReadMicEnd" }, + {0X17F7B2FB, nullptr, "sceUsbCamSetupVideo", '?', "" }, + {0XF93C4669, nullptr, "sceUsbCamAutoImageReverseSW", '?', "" }, + {0X574A8C3F, nullptr, "sceUsbCamStartVideo", '?', "" }, + {0X6CF32CB9, nullptr, "sceUsbCamStopVideo", '?', "" }, + {0X03ED7A82, nullptr, "sceUsbCamSetupMic", '?', "" }, + {0X82A64030, nullptr, "sceUsbCamStartMic", '?', "" }, + {0X7DAC0C71, nullptr, "sceUsbCamReadVideoFrameBlocking", '?', "" }, + {0X99D86281, nullptr, "sceUsbCamReadVideoFrame", '?', "" }, + {0X41E73E95, nullptr, "sceUsbCamPollReadVideoFrameEnd", '?', "" }, + {0XF90B2293, nullptr, "sceUsbCamWaitReadVideoFrameEnd", '?', "" }, + {0X4C34F553, nullptr, "sceUsbCamGetLensDirection", '?', "" }, + {0X3F0CF289, nullptr, "sceUsbCamSetupStill", '?', "" }, + {0X0A41A298, nullptr, "sceUsbCamSetupStillEx", '?', "" }, + {0X61BE5CAC, nullptr, "sceUsbCamStillInputBlocking", '?', "" }, + {0XFB0A6C5D, nullptr, "sceUsbCamStillInput", '?', "" }, + {0X7563AFA1, nullptr, "sceUsbCamStillWaitInputEnd", '?', "" }, + {0X1A46CFE7, nullptr, "sceUsbCamStillPollInputEnd", '?', "" }, + {0XA720937C, nullptr, "sceUsbCamStillCancelInput", '?', "" }, + {0XE5959C36, nullptr, "sceUsbCamStillGetInputLength", '?', "" }, + {0XCFE9E999, nullptr, "sceUsbCamSetupVideoEx", '?', "" }, + {0XDF9D0C92, nullptr, "sceUsbCamGetReadVideoFrameSize", '?', "" }, + {0X6E205974, nullptr, "sceUsbCamSetSaturation", '?', "" }, + {0X4F3D84D5, nullptr, "sceUsbCamSetBrightness", '?', "" }, + {0X09C26C7E, nullptr, "sceUsbCamSetContrast", '?', "" }, + {0X622F83CC, nullptr, "sceUsbCamSetSharpness", '?', "" }, + {0XD4876173, nullptr, "sceUsbCamSetImageEffectMode", '?', "" }, + {0X1D686870, nullptr, "sceUsbCamSetEvLevel", '?', "" }, + {0X951BEDF5, nullptr, "sceUsbCamSetReverseMode", '?', "" }, + {0XC484901F, nullptr, "sceUsbCamSetZoom", '?', "" }, + {0X383E9FA8, nullptr, "sceUsbCamGetSaturation", '?', "" }, + {0X70F522C5, nullptr, "sceUsbCamGetBrightness", '?', "" }, + {0XA063A957, nullptr, "sceUsbCamGetContrast", '?', "" }, + {0XFDB68C23, nullptr, "sceUsbCamGetSharpness", '?', "" }, + {0X994471E0, nullptr, "sceUsbCamGetImageEffectMode", '?', "" }, + {0X2BCD50C0, nullptr, "sceUsbCamGetEvLevel", '?', "" }, + {0XD5279339, nullptr, "sceUsbCamGetReverseMode", '?', "" }, + {0X9E8AAF8D, nullptr, "sceUsbCamGetZoom", '?', "" }, + {0X11A1F128, nullptr, "sceUsbCamGetAutoImageReverseState", '?', "" }, + {0X08AEE98A, nullptr, "sceUsbCamSetMicGain", '?', "" }, + {0X2E930264, nullptr, "sceUsbCamSetupMicEx", '?', "" }, + {0X36636925, nullptr, "sceUsbCamReadMicBlocking", '?', "" }, + {0X3DC0088E, nullptr, "sceUsbCamReadMic", '?', "" }, + {0X41EE8797, nullptr, "sceUsbCamUnregisterLensRotationCallback", '?', "" }, + {0X5145868A, nullptr, "sceUsbCamStopMic", '?', "" }, + {0X5778B452, nullptr, "sceUsbCamGetMicDataLength", '?', "" }, + {0X6784E6A8, nullptr, "sceUsbCamSetAntiFlicker", '?', "" }, + {0XAA7D94BA, nullptr, "sceUsbCamGetAntiFlicker", '?', "" }, + {0XB048A67D, nullptr, "sceUsbCamWaitReadMicEnd", '?', "" }, + {0XD293A100, nullptr, "sceUsbCamRegisterLensRotationCallback", '?', "" }, + {0XF8847F60, nullptr, "sceUsbCamPollReadMicEnd", '?', "" }, }; void Register_sceUsb() diff --git a/Core/HLE/sceUsbGps.cpp b/Core/HLE/sceUsbGps.cpp index 9f740f16b8..d8a68601aa 100644 --- a/Core/HLE/sceUsbGps.cpp +++ b/Core/HLE/sceUsbGps.cpp @@ -38,17 +38,17 @@ static int sceUsbGpsOpen() { const HLEFunction sceUsbGps[] = { - {0x268F95CA, 0, "sceUsbGpsSetInitDataLocation"}, - {0x31F95CDE, 0, "sceUsbGpsGetPowerSaveMode"}, - {0x54D26AA4, 0, "sceUsbGpsGetInitDataLocation"}, - {0x63D1F89D, 0, "sceUsbGpsResetInitialPosition"}, - {0x69E4AAA8, 0, "sceUsbGpsSaveInitData"}, - {0x6EED4811, 0, "sceUsbGpsClose"}, - {0x7C16AC3A, WrapI_U, "sceUsbGpsGetState"}, - {0x934EC2B2, 0, "sceUsbGpsGetData"}, - {0x9D8F99E8, 0, "sceUsbGpsSetPowerSaveMode"}, - {0x9F267D34, WrapI_V, "sceUsbGpsOpen"}, - {0xA259CD67, 0, "sceUsbGpsReset"}, + {0X268F95CA, nullptr, "sceUsbGpsSetInitDataLocation", '?', "" }, + {0X31F95CDE, nullptr, "sceUsbGpsGetPowerSaveMode", '?', "" }, + {0X54D26AA4, nullptr, "sceUsbGpsGetInitDataLocation", '?', "" }, + {0X63D1F89D, nullptr, "sceUsbGpsResetInitialPosition", '?', "" }, + {0X69E4AAA8, nullptr, "sceUsbGpsSaveInitData", '?', "" }, + {0X6EED4811, nullptr, "sceUsbGpsClose", '?', "" }, + {0X7C16AC3A, &WrapI_U, "sceUsbGpsGetState", 'i', "x"}, + {0X934EC2B2, nullptr, "sceUsbGpsGetData", '?', "" }, + {0X9D8F99E8, nullptr, "sceUsbGpsSetPowerSaveMode", '?', "" }, + {0X9F267D34, &WrapI_V, "sceUsbGpsOpen", 'i', "" }, + {0XA259CD67, nullptr, "sceUsbGpsReset", '?', "" }, }; void Register_sceUsbGps() diff --git a/Core/HLE/sceUtility.cpp b/Core/HLE/sceUtility.cpp index a494cc5e69..5ef855a08d 100644 --- a/Core/HLE/sceUtility.cpp +++ b/Core/HLE/sceUtility.cpp @@ -781,141 +781,141 @@ static u32 sceUtilityUnloadUsbModule(u32 module) const HLEFunction sceUtility[] = { - {0x1579a159, &WrapU_U, "sceUtilityLoadNetModule"}, - {0x64d50c56, &WrapU_U, "sceUtilityUnloadNetModule"}, + {0X1579A159, &WrapU_U, "sceUtilityLoadNetModule", 'x', "x" }, + {0X64D50C56, &WrapU_U, "sceUtilityUnloadNetModule", 'x', "x" }, - {0xf88155f6, &WrapI_V, "sceUtilityNetconfShutdownStart"}, - {0x4db1e739, &WrapI_U, "sceUtilityNetconfInitStart"}, - {0x91e70e35, &WrapI_I, "sceUtilityNetconfUpdate"}, - {0x6332aa39, &WrapI_V, "sceUtilityNetconfGetStatus"}, - {0x5eee6548, &WrapI_I, "sceUtilityCheckNetParam"}, - {0x434d4b3a, 0, "sceUtilityGetNetParam"}, - {0x4FED24D8, 0, "sceUtilityGetNetParamLatestID"}, + {0XF88155F6, &WrapI_V, "sceUtilityNetconfShutdownStart", 'i', "" }, + {0X4DB1E739, &WrapI_U, "sceUtilityNetconfInitStart", 'i', "x" }, + {0X91E70E35, &WrapI_I, "sceUtilityNetconfUpdate", 'i', "i" }, + {0X6332AA39, &WrapI_V, "sceUtilityNetconfGetStatus", 'i', "" }, + {0X5EEE6548, &WrapI_I, "sceUtilityCheckNetParam", 'i', "i" }, + {0X434D4B3A, nullptr, "sceUtilityGetNetParam", '?', "" }, + {0X4FED24D8, nullptr, "sceUtilityGetNetParamLatestID", '?', "" }, - {0x67af3428, &WrapI_V, "sceUtilityMsgDialogShutdownStart"}, - {0x2ad8e239, &WrapI_U, "sceUtilityMsgDialogInitStart"}, - {0x95fc253b, &WrapI_I, "sceUtilityMsgDialogUpdate"}, - {0x9a1c91d7, &WrapI_V, "sceUtilityMsgDialogGetStatus"}, - {0x4928bd96, &WrapI_V, "sceUtilityMsgDialogAbort"}, + {0X67AF3428, &WrapI_V, "sceUtilityMsgDialogShutdownStart", 'i', "" }, + {0X2AD8E239, &WrapI_U, "sceUtilityMsgDialogInitStart", 'i', "x" }, + {0X95FC253B, &WrapI_I, "sceUtilityMsgDialogUpdate", 'i', "i" }, + {0X9A1C91D7, &WrapI_V, "sceUtilityMsgDialogGetStatus", 'i', "" }, + {0X4928BD96, &WrapI_V, "sceUtilityMsgDialogAbort", 'i', "" }, - {0x9790b33c, &WrapI_V, "sceUtilitySavedataShutdownStart"}, - {0x50c4cd57, &WrapI_U, "sceUtilitySavedataInitStart"}, - {0xd4b95ffb, &WrapI_I, "sceUtilitySavedataUpdate"}, - {0x8874dbe0, &WrapI_V, "sceUtilitySavedataGetStatus"}, + {0X9790B33C, &WrapI_V, "sceUtilitySavedataShutdownStart", 'i', "" }, + {0X50C4CD57, &WrapI_U, "sceUtilitySavedataInitStart", 'i', "x" }, + {0XD4B95FFB, &WrapI_I, "sceUtilitySavedataUpdate", 'i', "i" }, + {0X8874DBE0, &WrapI_V, "sceUtilitySavedataGetStatus", 'i', "" }, - {0x3dfaeba9, &WrapI_V, "sceUtilityOskShutdownStart"}, - {0xf6269b82, &WrapI_U, "sceUtilityOskInitStart"}, - {0x4b85c861, &WrapI_I, "sceUtilityOskUpdate"}, - {0xf3f76017, &WrapI_V, "sceUtilityOskGetStatus"}, + {0X3DFAEBA9, &WrapI_V, "sceUtilityOskShutdownStart", 'i', "" }, + {0XF6269B82, &WrapI_U, "sceUtilityOskInitStart", 'i', "x" }, + {0X4B85C861, &WrapI_I, "sceUtilityOskUpdate", 'i', "i" }, + {0XF3F76017, &WrapI_V, "sceUtilityOskGetStatus", 'i', "" }, - {0x41e30674, &WrapU_UU, "sceUtilitySetSystemParamString"}, - {0x45c18506, 0, "sceUtilitySetSystemParamInt"}, - {0x34b78343, &WrapU_UUI, "sceUtilityGetSystemParamString"}, - {0xA5DA2406, &WrapU_UU, "sceUtilityGetSystemParamInt"}, + {0X41E30674, &WrapU_UU, "sceUtilitySetSystemParamString", 'x', "xx" }, + {0X45C18506, nullptr, "sceUtilitySetSystemParamInt", '?', "" }, + {0X34B78343, &WrapU_UUI, "sceUtilityGetSystemParamString", 'x', "xxi"}, + {0XA5DA2406, &WrapU_UU, "sceUtilityGetSystemParamInt", 'x', "xx" }, - {0xc492f751, &WrapI_U, "sceUtilityGameSharingInitStart"}, - {0xefc6f80f, &WrapI_V, "sceUtilityGameSharingShutdownStart"}, - {0x7853182d, &WrapI_I, "sceUtilityGameSharingUpdate"}, - {0x946963f3, &WrapI_V, "sceUtilityGameSharingGetStatus"}, + {0XC492F751, &WrapI_U, "sceUtilityGameSharingInitStart", 'i', "x" }, + {0XEFC6F80F, &WrapI_V, "sceUtilityGameSharingShutdownStart", 'i', "" }, + {0X7853182D, &WrapI_I, "sceUtilityGameSharingUpdate", 'i', "i" }, + {0X946963F3, &WrapI_V, "sceUtilityGameSharingGetStatus", 'i', "" }, - {0x2995d020, 0, "sceUtilitySavedataErrInitStart"}, - {0xb62a4061, 0, "sceUtilitySavedataErrShutdownStart"}, - {0xed0fad38, 0, "sceUtilitySavedataErrUpdate"}, - {0x88bc7406, 0, "sceUtilitySavedataErrGetStatus"}, + {0X2995D020, nullptr, "sceUtilitySavedataErrInitStart", '?', "" }, + {0XB62A4061, nullptr, "sceUtilitySavedataErrShutdownStart", '?', "" }, + {0XED0FAD38, nullptr, "sceUtilitySavedataErrUpdate", '?', "" }, + {0X88BC7406, nullptr, "sceUtilitySavedataErrGetStatus", '?', "" }, - {0xbda7d894, 0, "sceUtilityHtmlViewerGetStatus"}, - {0xcdc3aa41, 0, "sceUtilityHtmlViewerInitStart"}, - {0xf5ce1134, 0, "sceUtilityHtmlViewerShutdownStart"}, - {0x05afb9e4, 0, "sceUtilityHtmlViewerUpdate"}, + {0XBDA7D894, nullptr, "sceUtilityHtmlViewerGetStatus", '?', "" }, + {0XCDC3AA41, nullptr, "sceUtilityHtmlViewerInitStart", '?', "" }, + {0XF5CE1134, nullptr, "sceUtilityHtmlViewerShutdownStart", '?', "" }, + {0X05AFB9E4, nullptr, "sceUtilityHtmlViewerUpdate", '?', "" }, - {0x16a1a8d8, 0, "sceUtilityAuthDialogGetStatus"}, - {0x943cba46, 0, "sceUtilityAuthDialogInitStart"}, - {0x0f3eeaac, 0, "sceUtilityAuthDialogShutdownStart"}, - {0x147f7c85, 0, "sceUtilityAuthDialogUpdate"}, + {0X16A1A8D8, nullptr, "sceUtilityAuthDialogGetStatus", '?', "" }, + {0X943CBA46, nullptr, "sceUtilityAuthDialogInitStart", '?', "" }, + {0X0F3EEAAC, nullptr, "sceUtilityAuthDialogShutdownStart", '?', "" }, + {0X147F7C85, nullptr, "sceUtilityAuthDialogUpdate", '?', "" }, - {0xc629af26, &WrapU_U, "sceUtilityLoadAvModule"}, - {0xf7d8d092, &WrapU_U, "sceUtilityUnloadAvModule"}, + {0XC629AF26, &WrapU_U, "sceUtilityLoadAvModule", 'x', "x" }, + {0XF7D8D092, &WrapU_U, "sceUtilityUnloadAvModule", 'x', "x" }, - {0x2a2b3de0, &WrapU_U, "sceUtilityLoadModule"}, - {0xe49bfe92, &WrapU_U, "sceUtilityUnloadModule"}, + {0X2A2B3DE0, &WrapU_U, "sceUtilityLoadModule", 'x', "x" }, + {0XE49BFE92, &WrapU_U, "sceUtilityUnloadModule", 'x', "x" }, - {0x0251B134, &WrapI_U, "sceUtilityScreenshotInitStart"}, - {0xF9E0008C, &WrapI_V, "sceUtilityScreenshotShutdownStart"}, - {0xAB083EA9, &WrapI_U, "sceUtilityScreenshotUpdate"}, - {0xD81957B7, &WrapI_V, "sceUtilityScreenshotGetStatus"}, - {0x86A03A27, &WrapI_U, "sceUtilityScreenshotContStart"}, + {0X0251B134, &WrapI_U, "sceUtilityScreenshotInitStart", 'i', "x" }, + {0XF9E0008C, &WrapI_V, "sceUtilityScreenshotShutdownStart", 'i', "" }, + {0XAB083EA9, &WrapI_U, "sceUtilityScreenshotUpdate", 'i', "x" }, + {0XD81957B7, &WrapI_V, "sceUtilityScreenshotGetStatus", 'i', "" }, + {0X86A03A27, &WrapI_U, "sceUtilityScreenshotContStart", 'i', "x" }, - {0x0D5BC6D2, &WrapU_U, "sceUtilityLoadUsbModule"}, - {0xF64910F0, &WrapU_U, "sceUtilityUnloadUsbModule"}, + {0X0D5BC6D2, &WrapU_U, "sceUtilityLoadUsbModule", 'x', "x" }, + {0XF64910F0, &WrapU_U, "sceUtilityUnloadUsbModule", 'x', "x" }, - {0x24AC31EB, &WrapI_U, "sceUtilityGamedataInstallInitStart"}, - {0x32E32DCB, &WrapI_V, "sceUtilityGamedataInstallShutdownStart"}, - {0x4AECD179, &WrapI_I, "sceUtilityGamedataInstallUpdate"}, - {0xB57E95D9, &WrapI_V, "sceUtilityGamedataInstallGetStatus"}, - {0x180F7B62, &WrapI_V, "sceUtilityGamedataInstallAbort"}, + {0X24AC31EB, &WrapI_U, "sceUtilityGamedataInstallInitStart", 'i', "x" }, + {0X32E32DCB, &WrapI_V, "sceUtilityGamedataInstallShutdownStart", 'i', "" }, + {0X4AECD179, &WrapI_I, "sceUtilityGamedataInstallUpdate", 'i', "i" }, + {0XB57E95D9, &WrapI_V, "sceUtilityGamedataInstallGetStatus", 'i', "" }, + {0X180F7B62, &WrapI_V, "sceUtilityGamedataInstallAbort", 'i', "" }, - {0x16D02AF0, 0, "sceUtilityNpSigninInitStart"}, - {0xE19C97D6, 0, "sceUtilityNpSigninShutdownStart"}, - {0xF3FBC572, 0, "sceUtilityNpSigninUpdate"}, - {0x86ABDB1B, 0, "sceUtilityNpSigninGetStatus"}, + {0X16D02AF0, nullptr, "sceUtilityNpSigninInitStart", '?', "" }, + {0XE19C97D6, nullptr, "sceUtilityNpSigninShutdownStart", '?', "" }, + {0XF3FBC572, nullptr, "sceUtilityNpSigninUpdate", '?', "" }, + {0X86ABDB1B, nullptr, "sceUtilityNpSigninGetStatus", '?', "" }, - {0x1281DA8E, &WrapV_U, "sceUtilityInstallInitStart"}, - {0x5EF1C24A, 0, "sceUtilityInstallShutdownStart"}, - {0xA03D29BA, 0, "sceUtilityInstallUpdate"}, - {0xC4700FA3, 0, "sceUtilityInstallGetStatus"}, + {0X1281DA8E, &WrapV_U, "sceUtilityInstallInitStart", 'v', "x" }, + {0X5EF1C24A, nullptr, "sceUtilityInstallShutdownStart", '?', "" }, + {0XA03D29BA, nullptr, "sceUtilityInstallUpdate", '?', "" }, + {0XC4700FA3, nullptr, "sceUtilityInstallGetStatus", '?', "" }, - {0x54A5C62F, &WrapI_V, "sceUtilityStoreCheckoutShutdownStart"}, - {0xDA97F1AA, &WrapI_U, "sceUtilityStoreCheckoutInitStart"}, - {0xB8592D5F, &WrapI_I, "sceUtilityStoreCheckoutUpdate"}, - {0x3AAD51DC, &WrapI_V, "sceUtilityStoreCheckoutGetStatus"}, + {0X54A5C62F, &WrapI_V, "sceUtilityStoreCheckoutShutdownStart", 'i', "" }, + {0XDA97F1AA, &WrapI_U, "sceUtilityStoreCheckoutInitStart", 'i', "x" }, + {0XB8592D5F, &WrapI_I, "sceUtilityStoreCheckoutUpdate", 'i', "i" }, + {0X3AAD51DC, &WrapI_V, "sceUtilityStoreCheckoutGetStatus", 'i', "" }, - {0xd17a0573, 0, "sceUtilityPS3ScanShutdownStart"}, - {0x42071a83, 0, "sceUtilityPS3ScanInitStart"}, - {0xd852cdce, 0, "sceUtilityPS3ScanUpdate"}, - {0x89317c8f, 0, "sceUtilityPS3ScanGetStatus"}, + {0XD17A0573, nullptr, "sceUtilityPS3ScanShutdownStart", '?', "" }, + {0X42071A83, nullptr, "sceUtilityPS3ScanInitStart", '?', "" }, + {0XD852CDCE, nullptr, "sceUtilityPS3ScanUpdate", '?', "" }, + {0X89317C8F, nullptr, "sceUtilityPS3ScanGetStatus", '?', "" }, - {0xe1bc175e, 0, "sceUtility_E1BC175E"}, - {0x43e521b7, 0, "sceUtility_43E521B7"}, - {0xdb4149ee, 0, "sceUtility_DB4149EE"}, - {0xcfe7c460, 0, "sceUtility_CFE7C460"}, + {0XE1BC175E, nullptr, "sceUtility_E1BC175E", '?', "" }, + {0X43E521B7, nullptr, "sceUtility_43E521B7", '?', "" }, + {0XDB4149EE, nullptr, "sceUtility_DB4149EE", '?', "" }, + {0XCFE7C460, nullptr, "sceUtility_CFE7C460", '?', "" }, - {0xc130d441, 0, "sceUtilityPsnShutdownStart"}, - {0xa7bb7c67, 0, "sceUtilityPsnInitStart"}, - {0x0940a1b9, 0, "sceUtilityPsnUpdate"}, - {0x094198b8, 0, "sceUtilityPsnGetStatus"}, + {0XC130D441, nullptr, "sceUtilityPsnShutdownStart", '?', "" }, + {0XA7BB7C67, nullptr, "sceUtilityPsnInitStart", '?', "" }, + {0X0940A1B9, nullptr, "sceUtilityPsnUpdate", '?', "" }, + {0X094198B8, nullptr, "sceUtilityPsnGetStatus", '?', "" }, - {0x9f313d14, 0, "sceUtilityAutoConnectShutdownStart"}, - {0x3a15cd0a, 0, "sceUtilityAutoConnectInitStart"}, - {0xd23665f4, 0, "sceUtilityAutoConnectUpdate"}, - {0xd4c2bd73, 0, "sceUtilityAutoConnectGetStatus"}, - {0x0e0c27af, 0, "sceUtilityAutoConnectAbort"}, + {0X9F313D14, nullptr, "sceUtilityAutoConnectShutdownStart", '?', "" }, + {0X3A15CD0A, nullptr, "sceUtilityAutoConnectInitStart", '?', "" }, + {0XD23665F4, nullptr, "sceUtilityAutoConnectUpdate", '?', "" }, + {0XD4C2BD73, nullptr, "sceUtilityAutoConnectGetStatus", '?', "" }, + {0X0E0C27AF, nullptr, "sceUtilityAutoConnectAbort", '?', "" }, - {0x06A48659, 0, "sceUtilityRssSubscriberShutdownStart"}, - {0x4B0A8FE5, 0, "sceUtilityRssSubscriberInitStart"}, - {0xA084E056, 0, "sceUtilityRssSubscriberUpdate"}, - {0x2B96173B, 0, "sceUtilityRssSubscriberGetStatus"}, + {0X06A48659, nullptr, "sceUtilityRssSubscriberShutdownStart", '?', "" }, + {0X4B0A8FE5, nullptr, "sceUtilityRssSubscriberInitStart", '?', "" }, + {0XA084E056, nullptr, "sceUtilityRssSubscriberUpdate", '?', "" }, + {0X2B96173B, nullptr, "sceUtilityRssSubscriberGetStatus", '?', "" }, - {0x149a7895, 0, "sceUtilityDNASShutdownStart"}, - {0xdde5389d, 0, "sceUtilityDNASInitStart"}, - {0x4a833ba4, 0, "sceUtilityDNASUpdate"}, - {0xa50e5b30, 0, "sceUtilityDNASGetStatus"}, + {0X149A7895, nullptr, "sceUtilityDNASShutdownStart", '?', "" }, + {0XDDE5389D, nullptr, "sceUtilityDNASInitStart", '?', "" }, + {0X4A833BA4, nullptr, "sceUtilityDNASUpdate", '?', "" }, + {0XA50E5B30, nullptr, "sceUtilityDNASGetStatus", '?', "" }, - {0xe7b778d8, 0, "sceUtilityRssReaderShutdownStart"}, - {0x81c44706, 0, "sceUtilityRssReaderInitStart"}, - {0x6f56f9cf, 0, "sceUtilityRssReaderUpdate"}, - {0x8326ab05, 0, "sceUtilityRssReaderGetStatus"}, - {0xb0fb7ff5, 0, "sceUtilityRssReaderContStart"}, + {0XE7B778D8, nullptr, "sceUtilityRssReaderShutdownStart", '?', "" }, + {0X81C44706, nullptr, "sceUtilityRssReaderInitStart", '?', "" }, + {0X6F56F9CF, nullptr, "sceUtilityRssReaderUpdate", '?', "" }, + {0X8326AB05, nullptr, "sceUtilityRssReaderGetStatus", '?', "" }, + {0XB0FB7FF5, nullptr, "sceUtilityRssReaderContStart", '?', "" }, - {0xbc6b6296, 0, "sceNetplayDialogShutdownStart"}, - {0x3ad50ae7, 0, "sceNetplayDialogInitStart"}, - {0x417bed54, 0, "sceNetplayDialogUpdate"}, - {0xb6cee597, 0, "sceNetplayDialogGetStatus"}, + {0XBC6B6296, nullptr, "sceNetplayDialogShutdownStart", '?', "" }, + {0X3AD50AE7, nullptr, "sceNetplayDialogInitStart", '?', "" }, + {0X417BED54, nullptr, "sceNetplayDialogUpdate", '?', "" }, + {0XB6CEE597, nullptr, "sceNetplayDialogGetStatus", '?', "" }, - {0x28d35634, 0, "sceUtility_28D35634"}, - {0x70267adf, 0, "sceUtility_70267ADF"}, - {0xece1d3e5, 0, "sceUtility_ECE1D3E5"}, - {0xef3582b2, 0, "sceUtility_EF3582B2"}, + {0X28D35634, nullptr, "sceUtility_28D35634", '?', "" }, + {0X70267ADF, nullptr, "sceUtility_70267ADF", '?', "" }, + {0XECE1D3E5, nullptr, "sceUtility_ECE1D3E5", '?', "" }, + {0XEF3582B2, nullptr, "sceUtility_EF3582B2", '?', "" }, }; void Register_sceUtility() diff --git a/Core/HLE/sceVaudio.cpp b/Core/HLE/sceVaudio.cpp index bc4a0a8744..1b2140aa80 100644 --- a/Core/HLE/sceVaudio.cpp +++ b/Core/HLE/sceVaudio.cpp @@ -92,14 +92,14 @@ static u32 sceVaudioSetAlcMode(int alcMode) { } const HLEFunction sceVaudio[] = { - {0x8986295e, WrapU_IU, "sceVaudioOutputBlocking"}, - {0x03b6807d, WrapU_III, "sceVaudioChReserve"}, - {0x67585dfd, WrapU_V, "sceVaudioChRelease"}, - {0x346FBE94, WrapU_II, "sceVaudioSetEffectType"}, - {0xCBD4AC51, WrapU_I, "sceVaudioSetAlcMode"}, - {0x504e4745, 0, "sceVaudio_504E4745"}, - {0x27acc20b, 0, "sceVaudioChReserveBuffering"}, - {0xe8e78dc8, 0, "sceVaudio_E8E78DC8"}, + {0X8986295E, &WrapU_IU, "sceVaudioOutputBlocking", 'x', "ix" }, + {0X03B6807D, &WrapU_III, "sceVaudioChReserve", 'x', "iii"}, + {0X67585DFD, &WrapU_V, "sceVaudioChRelease", 'x', "" }, + {0X346FBE94, &WrapU_II, "sceVaudioSetEffectType", 'x', "ii" }, + {0XCBD4AC51, &WrapU_I, "sceVaudioSetAlcMode", 'x', "i" }, + {0X504E4745, nullptr, "sceVaudio_504E4745", '?', "" }, + {0X27ACC20B, nullptr, "sceVaudioChReserveBuffering", '?', "" }, + {0XE8E78DC8, nullptr, "sceVaudio_E8E78DC8", '?', "" }, }; void Register_sceVaudio() {