preserve-emulation/ppsspp
1
0 Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-10-22 10:49:05 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
deb9693f6a902a6bf5eb7eddbab110ed4e35caae
ppsspp/Core/HLE/FunctionWrappers.h
T
Henrik RydgårdandClaude Opus 5.5 0a8d569c47 HLE: kuKernelCall and sctrlHENFindFunction 
Custom firmware calls, which homebrew that runs ME code uses to reach
its own kernel modules: KUBridge's kuKernelCall runs a function with the
first eight of its arguments and stores v0/v1 in ret1/ret2 afterwards;
sctrlHENFindFunction (SystemCtrlForKernel, and a new SystemCtrlForUser)
finds a loaded module's export by module, library and NID.

Tanaka's Touhou ports find and call their GE4 wrapper's exports with
them.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-20 21:18:21 +02:00

963 lines
35 KiB
C++
Raw Blame History

// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#pragma once
#include <type_traits>
#include "Common/CommonTypes.h"
#include "Core/HLE/HLE.h"
#include "Core/MemMap.h"
// For easy parameter parsing and return value processing.
// Each wrapper names the signature it unpacks. The function may also take the MIPSState it runs on
// as an extra first parameter, which is how an implementation gets at the CPU (instead of currentMIPS).
template <typename Sig>
struct HLEFuncTypes;
template <typename R, typename... Args>
struct HLEFuncTypes<R(Args...)> {
typedef R (*Plain)(Args...);
typedef R (*WithState)(MIPSState *, Args...);
};
template <typename Sig, auto func, typename... CallArgs>
inline auto HLECall(MIPSState *mips, CallArgs... args) {
typedef HLEFuncTypes<Sig> Types;
typedef std::decay_t<decltype(func)> FuncType;
if constexpr (std::is_same_v<FuncType, typename Types::WithState>) {
return func(mips, args...);
} else {
static_assert(std::is_same_v<FuncType, typename Types::Plain>, "HLE function doesn't match the signature of its wrapper");
return func(args...);
}
}
// 64bit wrappers
// 64bit values are always "aligned" in regs (never start on an odd reg.)
template<auto func> void WrapU64_V(MIPSState *mips) {
u64 retval = HLECall<u64(), func>(mips);
RETURN64(retval);
}
template<auto func> void WrapU64_U(MIPSState *mips) {
u64 retval = HLECall<u64(u32), func>(mips, PARAM(0));
RETURN64(retval);
}
template<auto func> void WrapU64_I(MIPSState *mips) {
u64 retval = HLECall<u64(int), func>(mips, PARAM(0));
RETURN64(retval);
}
template<auto func> void WrapU64_UU64(MIPSState *mips) {
u64 retval = HLECall<u64(u32, u64), func>(mips, PARAM(0), PARAM64(2));
RETURN64(retval);
}
template<auto func> void WrapU64_IU64(MIPSState *mips) {
u64 retval = HLECall<u64(int, u64), func>(mips, PARAM(0), PARAM64(2));
RETURN64(retval);
}
template<auto func> void WrapI_IU64(MIPSState *mips) {
int retval = HLECall<int(int, u64), func>(mips, PARAM(0), PARAM64(2));
RETURN(retval);
}
template<auto func> void WrapI_UU64(MIPSState *mips) {
int retval = HLECall<int(u32, u64), func>(mips, PARAM(0), PARAM64(2));
RETURN(retval);
}
template<auto func> void WrapU_UU64(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u64), func>(mips, PARAM(0), PARAM64(2));
RETURN(retval);
}
template<auto func> void WrapI_UUU64(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u64), func>(mips, PARAM(0), PARAM(1), PARAM64(2));
RETURN(retval);
}
template<auto func> void WrapU_II64I(MIPSState *mips) {
u32 retval = HLECall<u32(int, s64, int), func>(mips, PARAM(0), PARAM64(2), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UU64UU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u64, u32, u32), func>(mips, PARAM(0), PARAM64(2), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_IU64UU(MIPSState *mips) {
u32 retval = HLECall<u32(int, u64, u32, u32), func>(mips, PARAM(0), PARAM64(2), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IICU64(MIPSState *mips) {
int retval = HLECall<int(int, int, const char*, u64), func>(mips, PARAM(0), PARAM(1), Memory::GetCharPointer(PARAM(2)), PARAM64(4));
RETURN(retval);
}
template<auto func> void WrapI64_II64I(MIPSState *mips) {
s64 retval = HLECall<s64(int, s64, int), func>(mips, PARAM(0), PARAM64(2), PARAM(4));
RETURN64(retval);
}
//32bit wrappers
template<auto func> void WrapV_V(MIPSState *mips) {
HLECall<void(), func>(mips);
}
template<auto func> void WrapU_V(MIPSState *mips) {
RETURN((HLECall<u32(), func>(mips)));
}
template<auto func> void WrapU_IVI(MIPSState *mips) {
u32 retval = HLECall<u32(int, void *, int), func>(mips, PARAM(0), Memory::GetPointerWriteOrException(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_CIIU(MIPSState *mips) {
u32 retval = HLECall<int(const char *, int, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_ICUVVUI(MIPSState *mips) {
u32 retval = HLECall<int(int, const char *, u32, void *, void *, u32, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointerWriteOrException(PARAM(3)),Memory::GetPointerWriteOrException(PARAM(4)), PARAM(5), PARAM(6) );
RETURN(retval);
}
// Hm, do so many params get passed in registers?
template<auto func> void WrapI_CICIIIII(MIPSState *mips) {
u32 retval = HLECall<int(const char *, int, const char *, int, int, int, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), Memory::GetCharPointer(PARAM(2)),
PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7));
RETURN(retval);
}
// Hm, do so many params get passed in registers?
template<auto func> void WrapI_CIIIIII(MIPSState *mips) {
u32 retval = HLECall<int(const char *, int, int, int, int, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_IIIC(MIPSState *mips) {
u32 retval = HLECall<int(int, int, int, const char *), func>(mips, PARAM(0), PARAM(1), PARAM(2), Memory::GetCharPointer(PARAM(3)));
RETURN(retval);
}
// Hm, do so many params get passed in registers?
template<auto func> void WrapI_IIIIIIU(MIPSState *mips) {
u32 retval = HLECall<int(int, int, int, int, int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
// Hm, do so many params get passed in registers?
template<auto func> void WrapI_IIIIIIIIU(MIPSState *mips) {
u32 param8 = *(const u32_le *)Memory::GetPointerWriteOrException(currentMIPS->r[29]); //Fixed 9th parameter, thanks to Kingcom
u32 retval = HLECall<int(int, int, int, int, int, int, int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7), param8);
RETURN(retval);
}
template<auto func> void WrapU_IV(MIPSState *mips) {
u32 retval = HLECall<u32(int, void *), func>(mips, PARAM(0), Memory::GetPointerWriteOrException(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapF_V(MIPSState *mips) {
RETURNF((HLECall<float(), func>(mips)));
}
// TODO: Not sure about the floating point parameter passing
template<auto func> void WrapF_IFU(MIPSState *mips) {
RETURNF((HLECall<float(int, float, u32), func>(mips, PARAM(0), PARAMF(0), PARAM(1))));
}
template<auto func> void WrapU_U(MIPSState *mips) {
u32 retval = HLECall<u32(u32), func>(mips, PARAM(0));
RETURN(retval);
}
template<auto func> void WrapU_UI(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_U(MIPSState *mips) {
int retval = HLECall<int(u32), func>(mips, PARAM(0));
RETURN(retval);
}
template<auto func> void WrapI_UI(MIPSState *mips) {
int retval = HLECall<int(u32, int), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_UIIU(MIPSState *mips) {
int retval = HLECall<int(u32, int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_IUI(MIPSState *mips) {
u32 retval = HLECall<u32(int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_UU(MIPSState *mips) {
int retval = HLECall<int(u32, u32), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_UFF(MIPSState *mips) {
// Not sure about the float arguments.
int retval = HLECall<int(u32, float, float), func>(mips, PARAM(0), PARAMF(0), PARAMF(1));
RETURN(retval);
}
template<auto func> void WrapI_UUU(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_UUUI(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UUUIIII(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32, int, int, int,int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_UUUU(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UUUUU(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_UCUUI(MIPSState *mips) {
int retval = HLECall<int(u32, const char*, u32, u32, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_UICUU(MIPSState *mips) {
int retval = HLECall<int(u32, int, const char*, u32, u32), func>(mips, PARAM(0), PARAM(1), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_UUIC(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int, const char*), func>(mips, PARAM(0), PARAM(1), PARAM(2), Memory::GetCharPointer(PARAM(3)));
RETURN(retval);
}
template<auto func> void WrapI_UUIUI(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_V(MIPSState *mips) {
int retval = HLECall<int(), func>(mips);
RETURN(retval);
}
template<auto func> void WrapU_I(MIPSState *mips) {
u32 retval = HLECall<u32(int), func>(mips, PARAM(0));
RETURN(retval);
}
template<auto func> void WrapU_IIU(MIPSState *mips) {
u32 retval = HLECall<u32(int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_I(MIPSState *mips) {
int retval = HLECall<int(int), func>(mips, PARAM(0));
RETURN(retval);
}
template<auto func> void WrapV_U(MIPSState *mips) {
HLECall<void(u32), func>(mips, PARAM(0));
}
template<auto func> void WrapV_I(MIPSState *mips) {
HLECall<void(int), func>(mips, PARAM(0));
}
template<auto func> void WrapV_UU(MIPSState *mips) {
HLECall<void(u32, u32), func>(mips, PARAM(0), PARAM(1));
}
template<auto func> void WrapV_II(MIPSState *mips) {
HLECall<void(int, int), func>(mips, PARAM(0), PARAM(1));
}
template<auto func> void WrapV_UC(MIPSState *mips) {
HLECall<void(u32, const char *), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)));
}
template<auto func> void WrapI_UC(MIPSState *mips) {
int retval = HLECall<int(u32, const char *), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapI_UCI(MIPSState *mips) {
int retval = HLECall<int(u32, const char *, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_UIIIII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int , int , int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_IIIIIU(MIPSState *mips) {
u32 retval = HLECall<u32(int, int, int, int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_UIIIU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int , int , int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UIIIIII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int , int , int, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapU_UU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapU_UUI(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_UUII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_CUUU(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, u32, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapV_UIUII(MIPSState *mips) {
HLECall<void(u32, int, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
}
template<auto func> void WrapU_UIUII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_UIUII(MIPSState *mips) {
int retval = HLECall<int(u32, int, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UIUI(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UIUI(MIPSState *mips) {
u32 retval = HLECall<int(u32, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UIU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_UIUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_UIIU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UIIUU(MIPSState *mips) {
u32 retval = HLECall<int(u32, int, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_UUII(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UUIII(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapV_UIII(MIPSState *mips) {
HLECall<void(u32, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
}
template<auto func> void WrapV_UIIIII(MIPSState *mips) {
HLECall<void(u32, int, int, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
}
template<auto func> void WrapV_UII(MIPSState *mips) {
HLECall<void(u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
}
template<auto func> void WrapU_IU(MIPSState *mips) {
int retval = HLECall<u32(int, u32), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_IU(MIPSState *mips) {
int retval = HLECall<int(int, u32), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_UUI(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_UUIU(MIPSState *mips) {
int retval = HLECall<int(u32, u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_II(MIPSState *mips) {
int retval = HLECall<int(int, int), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_III(MIPSState *mips) {
int retval = HLECall<int(int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_IUI(MIPSState *mips) {
int retval = HLECall<int(int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_IIII(MIPSState *mips) {
int retval = HLECall<int(int, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_UIII(MIPSState *mips) {
int retval = HLECall<int(u32, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_IIIUI(MIPSState *mips) {
int retval = HLECall<int(int, int, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IIIUU(MIPSState *mips) {
int retval = HLECall<int(int, int, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IUUII(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IUUIII(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_ICIUU(MIPSState *mips) {
int retval = HLECall<int(int, const char *, int, u32, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IIU(MIPSState *mips) {
int retval = HLECall<int(int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapV_IU(MIPSState *mips) {
HLECall<void(int, u32), func>(mips, PARAM(0), PARAM(1));
}
template<auto func> void WrapV_UI(MIPSState *mips) {
HLECall<void(u32, int), func>(mips, PARAM(0), PARAM(1));
}
template<auto func> void WrapU_C(MIPSState *mips) {
u32 retval = HLECall<u32(const char *), func>(mips, Memory::GetCharPointer(PARAM(0)));
RETURN(retval);
}
template<auto func> void WrapU_CCCU(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, const char *, const char *, u32), func>(mips, Memory::GetCharPointer(PARAM(0)),
Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)),
PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_C(MIPSState *mips) {
int retval = HLECall<int(const char *), func>(mips, Memory::GetCharPointer(PARAM(0)));
RETURN(retval);
}
template<auto func> void WrapI_CU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapI_ICU(MIPSState *mips) {
int retval = HLECall<int(int, const char*, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_CUI(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_CUI(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, u32, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_ICIU(MIPSState *mips) {
int retval = HLECall<int(int, const char *, int, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_ICUU(MIPSState *mips) {
int retval = HLECall<int(int, const char *, u32, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_ICUUU(MIPSState *mips) {
int retval = HLECall<int(int, const char *, u32, u32, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IIUU(MIPSState *mips) {
int retval = HLECall<int(int, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_CIU(MIPSState *mips) {
int retval = HLECall<int(const char *, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_CUU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_CUUU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_CCII(MIPSState *mips) {
int retval = HLECall<int(const char *, const char*, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_CUUIUU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, u32, int, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_CIIUII(MIPSState *mips) {
int retval = HLECall<int(const char *, int, int, u32, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_CIIIUUI(MIPSState *mips) {
int retval = HLECall<int(const char *, int, int, int, u32, u32, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_CIUUU(MIPSState *mips) {
int retval = HLECall<int(const char *, int, u32, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_CUUUUU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, u32, u32, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_CCU(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, const char *, u32), func>(mips, Memory::GetCharPointer(PARAM(0)),
Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_CU(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1));
RETURN((u32) retval);
}
template<auto func> void WrapU_UC(MIPSState *mips) {
u32 retval = HLECall<u32(u32, const char *), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapU_CUU(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, u32, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN((u32) retval);
}
template<auto func> void WrapU_III(MIPSState *mips) {
u32 retval = HLECall<u32(int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_II(MIPSState *mips) {
u32 retval = HLECall<u32(int, int), func>(mips, PARAM(0), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapU_IIII(MIPSState *mips) {
u32 retval = HLECall<u32(int, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_IUU(MIPSState *mips) {
u32 retval = HLECall<u32(int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_IUUU(MIPSState *mips) {
u32 retval = HLECall<u32(int, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_IUUUU(MIPSState *mips) {
u32 retval = HLECall<u32(int, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapV_IUU(MIPSState *mips) {
HLECall<void(int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
}
template<auto func> void WrapV_IIU(MIPSState *mips) {
HLECall<void(int, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
}
template<auto func> void WrapV_UIU(MIPSState *mips) {
HLECall<void(u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
}
template<auto func> void WrapI_UIU(MIPSState *mips) {
int retval = HLECall<int(u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapV_IUUUU(MIPSState *mips) {
HLECall<void(int, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
}
template<auto func> void WrapV_UUU(MIPSState *mips) {
HLECall<void(u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
}
template<auto func> void WrapV_UUUU(MIPSState *mips) {
HLECall<void(u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
}
template<auto func> void WrapV_CUIU(MIPSState *mips) {
HLECall<void(const char *, u32, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
}
template<auto func> void WrapI_CUIU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapV_UCUIU(MIPSState *mips) {
HLECall<void(u32, const char *, u32, int, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3),
PARAM(4));
}
template<auto func> void WrapI_UCUIU(MIPSState *mips) {
int retval = HLECall<int(u32, const char *, u32, int, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2),
PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapV_CUIIU(MIPSState *mips) {
HLECall<void(const char *, u32, int, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3),
PARAM(4));
}
template<auto func> void WrapI_CUIIU(MIPSState *mips) {
int retval = HLECall<int(const char *, u32, int, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UUUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UCUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, const char *, u32, u32), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UUUI(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UUUIU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_UUUIUI(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_UUIU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, int, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UIII(MIPSState *mips) {
u32 retval = HLECall<u32(u32, int, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_IUUUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_IUUUUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IUUIUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IUII(MIPSState *mips) {
int retval = HLECall<int(int, u32, int, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapU_UUUUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapV_UUUUU(MIPSState *mips) {
HLECall<void(u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
}
template<auto func> void WrapU_CC(MIPSState *mips) {
int retval = HLECall<u32(const char *, const char *), func>(mips, Memory::GetCharPointer(PARAM(0)),
Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapV_CI(MIPSState *mips) {
HLECall<void(const char *, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1));
}
template<auto func> void WrapU_CI(MIPSState *mips) {
int retval = HLECall<u32(const char *, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1));
RETURN(retval);
}
template<auto func> void WrapU_CII(MIPSState *mips) {
int retval = HLECall<u32(const char *, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_CIUIU(MIPSState *mips) {
int retval = HLECall<int(const char *, int, u32, int, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapU_CIUIUI(MIPSState *mips) {
u32 retval = HLECall<u32(const char *, int, u32, int, u32, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapU_UUUUUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4),
PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IUUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_IUUI(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_IUIIUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, int, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IUIIUI(MIPSState *mips) {
int retval = HLECall<int(int, u32, int, int, u32, int), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);
}
template<auto func> void WrapI_IUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_UUUUUUU(MIPSState *mips) {
u32 retval = HLECall<u32(u32, u32, u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_UUUUUUU(MIPSState *mips) {
int retval = HLECall<int(u32, u32, u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_IUUUUUU(MIPSState *mips) {
int retval = HLECall<int(int, u32, u32, u32, u32, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_UIUU(MIPSState *mips) {
u32 retval = HLECall<int(u32, int, u32, u32), func>(mips, PARAM(0), PARAM(1), PARAM(2), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_IC(MIPSState *mips) {
int retval = HLECall<int(int, const char *), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapI_ICCUI(MIPSState *mips) {
int retval = HLECall<int(int, const char *, const char *, u32, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4));
RETURN(retval);
}
template<auto func> void WrapI_ICCI(MIPSState *mips) {
int retval = HLECall<int(int, const char *, const char *, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3));
RETURN(retval);
}
template<auto func> void WrapI_CII(MIPSState *mips) {
int retval = HLECall<int(const char *, int, int), func>(mips, Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_ICI(MIPSState *mips) {
int retval = HLECall<int(int, const char *, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_IVVVVUI(MIPSState *mips) {
u32 retval = HLECall<int(int, void *, void *, void *, void *, u32, int), func>(mips, PARAM(0), Memory::GetPointerWriteOrException(PARAM(1)), Memory::GetPointerWriteOrException(PARAM(2)), Memory::GetPointerWriteOrException(PARAM(3)), Memory::GetPointerWriteOrException(PARAM(4)), PARAM(5), PARAM(6) );
RETURN(retval);
}
template<auto func> void WrapI_ICUVIII(MIPSState *mips) {
u32 retval = HLECall<int(int, const char *, u32, void *, int, int, int), func>(mips, PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointerWriteOrException(PARAM(3)), PARAM(4), PARAM(5), PARAM(6));
RETURN(retval);
}
template<auto func> void WrapI_VUI(MIPSState *mips) {
u32 retval = HLECall<int(void *, u32, int), func>(mips, Memory::GetPointerWriteOrException(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_VUU(MIPSState *mips) {
u32 retval = HLECall<u32(void *, u32, u32), func>(mips, Memory::GetPointerWriteOrException(PARAM(0)), PARAM(1), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_VC(MIPSState *mips) {
u32 retval = HLECall<u32(void *, const char *), func>(mips, Memory::GetPointerWriteOrException(PARAM(0)), Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapI_CCU(MIPSState *mips) {
int retval = HLECall<int(const char *, const char*, u32), func>(mips, Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapI_CC(MIPSState *mips) {
int retval = HLECall<int(const char *, const char*), func>(mips, Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)));
RETURN(retval);
}
template<auto func> void WrapU_VCU(MIPSState *mips) {
u32 retval = HLECall<u32(void *, const char *, u32), func>(mips, Memory::GetPointerWriteOrException(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2));
RETURN(retval);
}
template<auto func> void WrapU_VI(MIPSState *mips) {
u32 retval = HLECall<u32(void *, int), func>(mips, Memory::GetPointerWriteOrException(PARAM(0)), PARAM(1));
RETURN(retval);
}
Reference in new issue View Git Blame Copy Permalink