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
7dd1475ed7bc608aef476b7ccb823d73b59e05b1
ppsspp/Core/HLE/FunctionWrappers.h
T
Henrik RydgårdandClaude Opus 5.5 7dd1475ed7 HLE: Pass the MIPSState to syscalls and their implementations 
HLEFunc and ReplaceFunc now take the MIPSState they run on. The dispatch
paths (both interpreters and every JIT backend) pass in the state they
belong to, and CallSyscall*, hleFinishSyscall and the HLE mips call
machinery use it instead of currentMIPS.

The wrappers in FunctionWrappers.h take the function as `auto` and call it
through HLECall, which also accepts an implementation with an extra leading
MIPSState * parameter and passes the state to it. Any other signature still
fails to compile, as before. PARAM/RETURN now refer to a local `mips`.

The HLE functions (and replacement functions) that used currentMIPS now take
the state that way. Callers outside a syscall's own frame - CoreTiming
events, the adhoc matching thread, dialogs, PPGe, the debugger UIs - pass
currentMIPS or &mipsr4k explicitly. The kernel's thread internals still use
currentMIPS.

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

957 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_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