mirror of
https://github.com/libretro/ppsspp.git
synced 2024-12-13 11:38:34 +00:00
121 lines
3.6 KiB
C
121 lines
3.6 KiB
C
// 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 "../Globals.h"
|
|
#include "../MIPS/MIPS.h"
|
|
|
|
typedef void (* HLEFunc)();
|
|
|
|
enum {
|
|
// The low 8 bits are a value, indicating special jit handling.
|
|
// Currently there are none.
|
|
|
|
// The remaining 24 bits are flags.
|
|
// Don't allow the call within an interrupt. Not yet implemented.
|
|
HLE_NOT_IN_INTERRUPT = 1 << 8,
|
|
// Don't allow the call if dispatch or interrupts are disabled.
|
|
HLE_NOT_DISPATCH_SUSPENDED = 1 << 9,
|
|
};
|
|
|
|
struct HLEFunction
|
|
{
|
|
u32 ID;
|
|
HLEFunc func;
|
|
const char *name;
|
|
u32 flags;
|
|
};
|
|
|
|
struct HLEModule
|
|
{
|
|
const char *name;
|
|
int numFunctions;
|
|
const HLEFunction *funcTable;
|
|
};
|
|
|
|
typedef char SyscallModuleName[32];
|
|
|
|
struct Syscall
|
|
{
|
|
SyscallModuleName moduleName;
|
|
u32 symAddr;
|
|
u32 nid;
|
|
};
|
|
|
|
#define PARAM(n) currentMIPS->r[4+n]
|
|
#define PARAMF(n) currentMIPS->f[12+n]
|
|
#define RETURN(n) currentMIPS->r[2]=n
|
|
#define RETURNF(fl) currentMIPS->f[0]=fl
|
|
|
|
#ifndef ARRAY_SIZE
|
|
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
|
|
#endif
|
|
|
|
#include "FunctionWrappers.h"
|
|
|
|
|
|
#define P_INT(n, name) const int name = currentMIPS->r[4+n];
|
|
|
|
const char *GetFuncName(const char *module, u32 nib);
|
|
const char *GetFuncName(int module, int func);
|
|
const HLEFunction *GetFunc(const char *module, u32 nib);
|
|
int GetFuncIndex(int moduleIndex, u32 nib);
|
|
int GetModuleIndex(const char *modulename);
|
|
|
|
void RegisterModule(const char *name, int numFunctions, const HLEFunction *funcTable);
|
|
|
|
// Run the current thread's callbacks after the syscall finishes.
|
|
void hleCheckCurrentCallbacks();
|
|
// Check and potentially run all thread's callbacks after the syscall finishes.
|
|
void hleCheckAllCallbacks();
|
|
// Reschedule after the syscall finishes.
|
|
void hleReSchedule(const char *reason);
|
|
// Reschedule and go into a callback processing state after the syscall finishes.
|
|
void hleReSchedule(bool callbacks, const char *reason);
|
|
// Run interrupts after the syscall finishes.
|
|
void hleRunInterrupts();
|
|
// Pause emulation after the syscall finishes.
|
|
void hleDebugBreak();
|
|
|
|
// Delays the result for usec microseconds, allowing other threads to run during this time.
|
|
u32 hleDelayResult(u32 result, const char *reason, int usec);
|
|
u64 hleDelayResult(u64 result, const char *reason, int usec);
|
|
void hleEatCycles(int cycles);
|
|
void hleEatMicro(int usec);
|
|
|
|
inline int hleDelayResult(int result, const char *reason, int usec)
|
|
{
|
|
return hleDelayResult((u32) result, reason, usec);
|
|
}
|
|
|
|
inline s64 hleDelayResult(s64 result, const char *reason, int usec)
|
|
{
|
|
return hleDelayResult((u64) result, reason, usec);
|
|
}
|
|
|
|
void HLEInit();
|
|
void HLEDoState(PointerWrap &p);
|
|
void HLEShutdown();
|
|
u32 GetNibByName(const char *module, const char *function);
|
|
u32 GetSyscallOp(const char *module, u32 nib);
|
|
bool FuncImportIsSyscall(const char *module, u32 nib);
|
|
bool WriteSyscall(const char *module, u32 nib, u32 address);
|
|
void CallSyscall(MIPSOpcode op);
|
|
void WriteFuncStub(u32 stubAddr, u32 symAddr);
|
|
void WriteFuncMissingStub(u32 stubAddr, u32 nid);
|