RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-25 04:02:42 +01:00
Code Issues Releases Wiki Activity

Merge pull request #977 from Nekotekina/master

Browse Source 
ARMv7 changes
This commit is contained in:
Hykem 2015-01-25 20:18:59 +00:00
commit 9d6dc46812
28 changed files with 2522 additions and 1277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Utilities/rFile.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "Log.h"
#pragma warning(disable : 4996)
#include <wx/dir.h>
#include <wx/file.h>
#include <wx/filename.h>

1
Utilities/rMsgBox.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/msgdlg.h>
#include "define_new_memleakdetect.h"
#include "rMsgBox.h"

1
Utilities/rPlatform.cpp
View File

@ -1,5 +1,6 @@
#include "stdafx.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/image.h>
#include "define_new_memleakdetect.h"

2
Utilities/rTime.cpp
View File

@ -1,6 +1,6 @@
#include "stdafx.h"
#include "rTime.h"
#pragma warning(disable : 4996)
#include <wx/datetime.h>
std::string rDefaultDateTimeFormat = "%c";

1
rpcs3/Crypto/unpkg.cpp
View File

@ -5,6 +5,7 @@
#include "key_vault.h"
#include "unpkg.h"
#include "restore_new.h"
#pragma warning(disable : 4996)
#include <wx/progdlg.h>
#include "define_new_memleakdetect.h"

2
rpcs3/Crypto/unself.cpp
View File

@ -6,7 +6,7 @@
#include "utils.h"
#include "Emu/FS/vfsLocalFile.h"
#include "unself.h"
#pragma warning(disable : 4996)
#include <wx/mstream.h>
#include <wx/zstream.h>

6
rpcs3/Emu/ARMv7/ARMv7Context.h
View File

@ -18,7 +18,6 @@ struct ARMv7Context
void write_pc(u32 value);
u32 read_pc();
void put_stack_arg(u32 shift, u32 value);
u32 get_stack_arg(u32 pos);
void fast_call(u32 addr);
@ -39,6 +38,11 @@ struct ARMv7Context
u32 LR;
};
struct
{
u64 GPR_D[8];
};
};
union

4
rpcs3/Emu/ARMv7/ARMv7Decoder.cpp
View File

@ -649,8 +649,8 @@ const ARMv7_opcode_t ARMv7_opcode_table[] =
ARMv7_OP4(0xfff0, 0xf0f0, 0xfac0, 0xf040, T1, USUB8),
ARMv7_OP4(0x0ff0, 0x0ff0, 0x0650, 0x0ff0, A1, USUB8),
ARMv7_OP4(0xfff0, 0xf0c0, 0xfa50, 0xf080, T1, UXTAB),
ARMv7_OP4(0x0ff0, 0x03f0, 0x06e0, 0x0070, A1, UXTAB),
ARMv7_OP4(0xfff0, 0xf0c0, 0xfa50, 0xf080, T1, UXTAB, SKIP_IF( BF(16, 19) == 15 )),
ARMv7_OP4(0x0ff0, 0x03f0, 0x06e0, 0x0070, A1, UXTAB, SKIP_IF( BF(16, 19) == 15 )),
ARMv7_OP4(0xfff0, 0xf0c0, 0xfa30, 0xf080, T1, UXTAB16),
ARMv7_OP4(0x0ff0, 0x03f0, 0x06c0, 0x0070, A1, UXTAB16),

1256
rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp
View File

File diff suppressed because it is too large Load Diff

65
rpcs3/Emu/ARMv7/ARMv7Interpreter.h
View File

@ -28,71 +28,6 @@ enum SRType : u32
namespace ARMv7_instrs
{
template<typename T>
static bool IsZero(T x)
{
return x == T(0);
}
template<typename T>
static bool IsOnes(T x)
{
return x == ~T(0);
}
template<typename T>
static u8 IsZeroBit(T x)
{
return IsZero(x) ? 1 : 0;
}
template<typename T>
static bool IsOnesBit(T x, u8 len = sizeof(T) * 8)
{
return IsOnes(x) ? 1 : 0;
}
template<typename T>
u8 BitCount(T x, u8 len = sizeof(T) * 8);
template<typename T>
s8 LowestSetBit(T x, u8 len = sizeof(T) * 8);
template<typename T>
s8 HighestSetBit(T x, u8 len = sizeof(T) * 8);
template<typename T>
s8 CountLeadingZeroBits(T x, u8 len = sizeof(T) * 8);
SRType DecodeImmShift(u32 type, u32 imm5, u32* shift_n);
SRType DecodeRegShift(u8 type);
u32 LSL_C(u32 x, s32 shift, bool& carry_out);
u32 LSL_(u32 x, s32 shift);
u32 LSR_C(u32 x, s32 shift, bool& carry_out);
u32 LSR_(u32 x, s32 shift);
s32 ASR_C(s32 x, s32 shift, bool& carry_out);
s32 ASR_(s32 x, s32 shift);
u32 ROR_C(u32 x, s32 shift, bool& carry_out);
u32 ROR_(u32 x, s32 shift);
u32 RRX_C(u32 x, bool carry_in, bool& carry_out);
u32 RRX_(u32 x, bool carry_in);
template<typename T> T Shift_C(T value, SRType type, s32 amount, bool carry_in, bool& carry_out);
template<typename T> T Shift(T value, SRType type, s32 amount, bool carry_in);
template<typename T> T AddWithCarry(T x, T y, bool carry_in, bool& carry_out, bool& overflow);
u32 ThumbExpandImm_C(u32 imm12, bool carry_in, bool& carry_out);
u32 ThumbExpandImm(ARMv7Context& context, u32 imm12);
bool ConditionPassed(ARMv7Context& context, u32 cond);
// instructions
void UNK(ARMv7Context& context, const ARMv7Code code);
void NULL_OP(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);

5
rpcs3/Emu/ARMv7/ARMv7Thread.cpp
View File

@ -20,11 +20,6 @@ u32 ARMv7Context::read_pc()
return thread.PC;
}
void ARMv7Context::put_stack_arg(u32 shift, u32 value)
{
vm::psv::write32(SP + shift, value);
}
u32 ARMv7Context::get_stack_arg(u32 pos)
{
return vm::psv::read32(SP + sizeof(u32) * (pos - 5));

1119
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp
View File

File diff suppressed because it is too large Load Diff

595
rpcs3/Emu/ARMv7/Modules/sceLibKernel.h Normal file
View File

@ -0,0 +1,595 @@
#pragma once
// Error Codes
enum
{
SCE_KERNEL_ERROR_ERROR = 0x80020001,
SCE_KERNEL_ERROR_NOT_IMPLEMENTED = 0x80020002,
SCE_KERNEL_ERROR_INVALID_ARGUMENT = 0x80020003,
SCE_KERNEL_ERROR_INVALID_ARGUMENT_SIZE = 0x80020004,
SCE_KERNEL_ERROR_INVALID_FLAGS = 0x80020005,
SCE_KERNEL_ERROR_ILLEGAL_SIZE = 0x80020006,
SCE_KERNEL_ERROR_ILLEGAL_ADDR = 0x80020007,
SCE_KERNEL_ERROR_UNSUP = 0x80020008,
SCE_KERNEL_ERROR_ILLEGAL_MODE = 0x80020009,
SCE_KERNEL_ERROR_ILLEGAL_ALIGNMENT = 0x8002000A,
SCE_KERNEL_ERROR_NOSYS = 0x8002000B,
SCE_KERNEL_ERROR_DEBUG_ERROR = 0x80021000,
SCE_KERNEL_ERROR_ILLEGAL_DIPSW_NUMBER = 0x80021001,
SCE_KERNEL_ERROR_CPU_ERROR = 0x80022000,
SCE_KERNEL_ERROR_MMU_ILLEGAL_L1_TYPE = 0x80022001,
SCE_KERNEL_ERROR_MMU_L2_INDEX_OVERFLOW = 0x80022002,
SCE_KERNEL_ERROR_MMU_L2_SIZE_OVERFLOW = 0x80022003,
SCE_KERNEL_ERROR_INVALID_CPU_AFFINITY = 0x80022004,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS = 0x80022005,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS_PERMISSION = 0x80022006,
SCE_KERNEL_ERROR_VA2PA_FAULT = 0x80022007,
SCE_KERNEL_ERROR_VA2PA_MAPPED = 0x80022008,
SCE_KERNEL_ERROR_VALIDATION_CHECK_FAILED = 0x80022009,
SCE_KERNEL_ERROR_SYSMEM_ERROR = 0x80024000,
SCE_KERNEL_ERROR_INVALID_PROCESS_CONTEXT = 0x80024001,
SCE_KERNEL_ERROR_UID_NAME_TOO_LONG = 0x80024002,
SCE_KERNEL_ERROR_VARANGE_IS_NOT_PHYSICAL_CONTINUOUS = 0x80024003,
SCE_KERNEL_ERROR_PHYADDR_ERROR = 0x80024100,
SCE_KERNEL_ERROR_NO_PHYADDR = 0x80024101,
SCE_KERNEL_ERROR_PHYADDR_USED = 0x80024102,
SCE_KERNEL_ERROR_PHYADDR_NOT_USED = 0x80024103,
SCE_KERNEL_ERROR_NO_IOADDR = 0x80024104,
SCE_KERNEL_ERROR_PHYMEM_ERROR = 0x80024300,
SCE_KERNEL_ERROR_ILLEGAL_PHYPAGE_STATUS = 0x80024301,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE = 0x80024302,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE_UNIT = 0x80024303,
SCE_KERNEL_ERROR_PHYMEMPART_NOT_EMPTY = 0x80024304,
SCE_KERNEL_ERROR_NO_PHYMEMPART_LPDDR2 = 0x80024305,
SCE_KERNEL_ERROR_NO_PHYMEMPART_CDRAM = 0x80024306,
SCE_KERNEL_ERROR_FIXEDHEAP_ERROR = 0x80024400,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_SIZE = 0x80024401,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_INDEX = 0x80024402,
SCE_KERNEL_ERROR_FIXEDHEAP_INDEX_OVERFLOW = 0x80024403,
SCE_KERNEL_ERROR_FIXEDHEAP_NO_CHUNK = 0x80024404,
SCE_KERNEL_ERROR_UID_ERROR = 0x80024500,
SCE_KERNEL_ERROR_INVALID_UID = 0x80024501,
SCE_KERNEL_ERROR_SYSMEM_UID_INVALID_ARGUMENT = 0x80024502,
SCE_KERNEL_ERROR_SYSMEM_INVALID_UID_RANGE = 0x80024503,
SCE_KERNEL_ERROR_SYSMEM_NO_VALID_UID = 0x80024504,
SCE_KERNEL_ERROR_SYSMEM_CANNOT_ALLOCATE_UIDENTRY = 0x80024505,
SCE_KERNEL_ERROR_NOT_PROCESS_UID = 0x80024506,
SCE_KERNEL_ERROR_NOT_KERNEL_UID = 0x80024507,
SCE_KERNEL_ERROR_INVALID_UID_CLASS = 0x80024508,
SCE_KERNEL_ERROR_INVALID_UID_SUBCLASS = 0x80024509,
SCE_KERNEL_ERROR_UID_CANNOT_FIND_BY_NAME = 0x8002450A,
SCE_KERNEL_ERROR_VIRPAGE_ERROR = 0x80024600,
SCE_KERNEL_ERROR_ILLEGAL_VIRPAGE_TYPE = 0x80024601,
SCE_KERNEL_ERROR_BLOCK_ERROR = 0x80024700,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_ID = 0x80024701,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_TYPE = 0x80024702,
SCE_KERNEL_ERROR_BLOCK_IN_USE = 0x80024703,
SCE_KERNEL_ERROR_PARTITION_ERROR = 0x80024800,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_ID = 0x80024801,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_INDEX = 0x80024802,
SCE_KERNEL_ERROR_NO_L2PAGETABLE = 0x80024803,
SCE_KERNEL_ERROR_HEAPLIB_ERROR = 0x80024900,
SCE_KERNEL_ERROR_ILLEGAL_HEAP_ID = 0x80024901,
SCE_KERNEL_ERROR_OUT_OF_RANG = 0x80024902,
SCE_KERNEL_ERROR_HEAPLIB_NOMEM = 0x80024903,
SCE_KERNEL_ERROR_SYSMEM_ADDRESS_SPACE_ERROR = 0x80024A00,
SCE_KERNEL_ERROR_INVALID_ADDRESS_SPACE_ID = 0x80024A01,
SCE_KERNEL_ERROR_INVALID_PARTITION_INDEX = 0x80024A02,
SCE_KERNEL_ERROR_ADDRESS_SPACE_CANNOT_FIND_PARTITION_BY_ADDR = 0x80024A03,
SCE_KERNEL_ERROR_SYSMEM_MEMBLOCK_ERROR = 0x80024B00,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_TYPE = 0x80024B01,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_REMAP_TYPE = 0x80024B02,
SCE_KERNEL_ERROR_NOT_PHY_CONT_MEMBLOCK = 0x80024B03,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_CODE = 0x80024B04,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_SIZE = 0x80024B05,
SCE_KERNEL_ERROR_ILLEGAL_USERMAP_SIZE = 0x80024B06,
SCE_KERNEL_ERROR_MEMBLOCK_TYPE_FOR_KERNEL_PROCESS = 0x80024B07,
SCE_KERNEL_ERROR_PROCESS_CANNOT_REMAP_MEMBLOCK = 0x80024B08,
SCE_KERNEL_ERROR_SYSMEM_PHYMEMLOW_ERROR = 0x80024C00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_PHYMEMLOW = 0x80024C01,
SCE_KERNEL_ERROR_UNKNOWN_PHYMEMLOW_TYPE = 0x80024C02,
SCE_KERNEL_ERROR_SYSMEM_BITHEAP_ERROR = 0x80024D00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_BITHEAP = 0x80024D01,
SCE_KERNEL_ERROR_LOADCORE_ERROR = 0x80025000,
SCE_KERNEL_ERROR_ILLEGAL_ELF_HEADER = 0x80025001,
SCE_KERNEL_ERROR_ILLEGAL_SELF_HEADER = 0x80025002,
SCE_KERNEL_ERROR_EXCPMGR_ERROR = 0x80027000,
SCE_KERNEL_ERROR_ILLEGAL_EXCPCODE = 0x80027001,
SCE_KERNEL_ERROR_ILLEGAL_EXCPHANDLER = 0x80027002,
SCE_KERNEL_ERROR_NOTFOUND_EXCPHANDLER = 0x80027003,
SCE_KERNEL_ERROR_CANNOT_RELEASE_EXCPHANDLER = 0x80027004,
SCE_KERNEL_ERROR_INTRMGR_ERROR = 0x80027100,
SCE_KERNEL_ERROR_ILLEGAL_CONTEXT = 0x80027101,
SCE_KERNEL_ERROR_ILLEGAL_INTRCODE = 0x80027102,
SCE_KERNEL_ERROR_ILLEGAL_INTRPARAM = 0x80027103,
SCE_KERNEL_ERROR_ILLEGAL_INTRPRIORITY = 0x80027104,
SCE_KERNEL_ERROR_ILLEGAL_TARGET_CPU = 0x80027105,
SCE_KERNEL_ERROR_ILLEGAL_INTRFILTER = 0x80027106,
SCE_KERNEL_ERROR_ILLEGAL_INTRTYPE = 0x80027107,
SCE_KERNEL_ERROR_ILLEGAL_HANDLER = 0x80027108,
SCE_KERNEL_ERROR_FOUND_HANDLER = 0x80027109,
SCE_KERNEL_ERROR_NOTFOUND_HANDLER = 0x8002710A,
SCE_KERNEL_ERROR_NO_MEMORY = 0x8002710B,
SCE_KERNEL_ERROR_DMACMGR_ERROR = 0x80027200,
SCE_KERNEL_ERROR_ALREADY_QUEUED = 0x80027201,
SCE_KERNEL_ERROR_NOT_QUEUED = 0x80027202,
SCE_KERNEL_ERROR_NOT_SETUP = 0x80027203,
SCE_KERNEL_ERROR_ON_TRANSFERRING = 0x80027204,
SCE_KERNEL_ERROR_NOT_INITIALIZED = 0x80027205,
SCE_KERNEL_ERROR_TRANSFERRED = 0x80027206,
SCE_KERNEL_ERROR_NOT_UNDER_CONTROL = 0x80027207,
SCE_KERNEL_ERROR_SYSTIMER_ERROR = 0x80027300,
SCE_KERNEL_ERROR_NO_FREE_TIMER = 0x80027301,
SCE_KERNEL_ERROR_TIMER_NOT_ALLOCATED = 0x80027302,
SCE_KERNEL_ERROR_TIMER_COUNTING = 0x80027303,
SCE_KERNEL_ERROR_TIMER_STOPPED = 0x80027304,
SCE_KERNEL_ERROR_THREADMGR_ERROR = 0x80028000,
SCE_KERNEL_ERROR_DORMANT = 0x80028001,
SCE_KERNEL_ERROR_NOT_DORMANT = 0x80028002,
SCE_KERNEL_ERROR_UNKNOWN_THID = 0x80028003,
SCE_KERNEL_ERROR_CAN_NOT_WAIT = 0x80028004,
SCE_KERNEL_ERROR_ILLEGAL_THID = 0x80028005,
SCE_KERNEL_ERROR_THREAD_TERMINATED = 0x80028006,
SCE_KERNEL_ERROR_DELETED = 0x80028007,
SCE_KERNEL_ERROR_WAIT_TIMEOUT = 0x80028008,
SCE_KERNEL_ERROR_NOTIFY_CALLBACK = 0x80028009,
SCE_KERNEL_ERROR_WAIT_DELETE = 0x8002800A,
SCE_KERNEL_ERROR_ILLEGAL_ATTR = 0x8002800B,
SCE_KERNEL_ERROR_EVF_MULTI = 0x8002800C,
SCE_KERNEL_ERROR_WAIT_CANCEL = 0x8002800D,
SCE_KERNEL_ERROR_EVF_COND = 0x8002800E,
SCE_KERNEL_ERROR_ILLEGAL_COUNT = 0x8002800F,
SCE_KERNEL_ERROR_ILLEGAL_PRIORITY = 0x80028010,
SCE_KERNEL_ERROR_MUTEX_RECURSIVE = 0x80028011,
SCE_KERNEL_ERROR_MUTEX_LOCK_OVF = 0x80028012,
SCE_KERNEL_ERROR_MUTEX_NOT_OWNED = 0x80028013,
SCE_KERNEL_ERROR_MUTEX_UNLOCK_UDF = 0x80028014,
SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN = 0x80028015,
SCE_KERNEL_ERROR_FAST_MUTEX_RECURSIVE = 0x80028016,
SCE_KERNEL_ERROR_FAST_MUTEX_LOCK_OVF = 0x80028017,
SCE_KERNEL_ERROR_FAST_MUTEX_FAILED_TO_OWN = 0x80028018,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_OWNED = 0x80028019,
SCE_KERNEL_ERROR_FAST_MUTEX_OWNED = 0x8002801A,
SCE_KERNEL_ERROR_ALARM_CAN_NOT_CANCEL = 0x8002801B,
SCE_KERNEL_ERROR_INVALID_OBJECT_TYPE = 0x8002801C,
SCE_KERNEL_ERROR_KERNEL_TLS_FULL = 0x8002801D,
SCE_KERNEL_ERROR_ILLEGAL_KERNEL_TLS_INDEX = 0x8002801E,
SCE_KERNEL_ERROR_KERNEL_TLS_BUSY = 0x8002801F,
SCE_KERNEL_ERROR_DIFFERENT_UID_CLASS = 0x80028020,
SCE_KERNEL_ERROR_UNKNOWN_UID = 0x80028021,
SCE_KERNEL_ERROR_SEMA_ZERO = 0x80028022,
SCE_KERNEL_ERROR_SEMA_OVF = 0x80028023,
SCE_KERNEL_ERROR_PMON_NOT_THREAD_MODE = 0x80028024,
SCE_KERNEL_ERROR_PMON_NOT_CPU_MODE = 0x80028025,
SCE_KERNEL_ERROR_ALREADY_REGISTERED = 0x80028026,
SCE_KERNEL_ERROR_INVALID_THREAD_ID = 0x80028027,
SCE_KERNEL_ERROR_ALREADY_DEBUG_SUSPENDED = 0x80028028,
SCE_KERNEL_ERROR_NOT_DEBUG_SUSPENDED = 0x80028029,
SCE_KERNEL_ERROR_CAN_NOT_USE_VFP = 0x8002802A,
SCE_KERNEL_ERROR_RUNNING = 0x8002802B,
SCE_KERNEL_ERROR_EVENT_COND = 0x8002802C,
SCE_KERNEL_ERROR_MSG_PIPE_FULL = 0x8002802D,
SCE_KERNEL_ERROR_MSG_PIPE_EMPTY = 0x8002802E,
SCE_KERNEL_ERROR_ALREADY_SENT = 0x8002802F,
SCE_KERNEL_ERROR_CAN_NOT_SUSPEND = 0x80028030,
SCE_KERNEL_ERROR_FAST_MUTEX_ALREADY_INITIALIZED = 0x80028031,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_INITIALIZED = 0x80028032,
SCE_KERNEL_ERROR_THREAD_STOPPED = 0x80028033,
SCE_KERNEL_ERROR_THREAD_SUSPENDED = 0x80028034,
SCE_KERNEL_ERROR_NOT_SUSPENDED = 0x80028035,
SCE_KERNEL_ERROR_WAIT_DELETE_MUTEX = 0x80028036,
SCE_KERNEL_ERROR_WAIT_CANCEL_MUTEX = 0x80028037,
SCE_KERNEL_ERROR_WAIT_DELETE_COND = 0x80028038,
SCE_KERNEL_ERROR_WAIT_CANCEL_COND = 0x80028039,
SCE_KERNEL_ERROR_LW_MUTEX_NOT_OWNED = 0x8002803A,
SCE_KERNEL_ERROR_LW_MUTEX_LOCK_OVF = 0x8002803B,
SCE_KERNEL_ERROR_LW_MUTEX_UNLOCK_UDF = 0x8002803C,
SCE_KERNEL_ERROR_LW_MUTEX_RECURSIVE = 0x8002803D,
SCE_KERNEL_ERROR_LW_MUTEX_FAILED_TO_OWN = 0x8002803E,
SCE_KERNEL_ERROR_WAIT_DELETE_LW_MUTEX = 0x8002803F,
SCE_KERNEL_ERROR_ILLEGAL_STACK_SIZE = 0x80028040,
SCE_KERNEL_ERROR_RW_LOCK_RECURSIVE = 0x80028041,
SCE_KERNEL_ERROR_RW_LOCK_LOCK_OVF = 0x80028042,
SCE_KERNEL_ERROR_RW_LOCK_NOT_OWNED = 0x80028043,
SCE_KERNEL_ERROR_RW_LOCK_UNLOCK_UDF = 0x80028044,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_LOCK = 0x80028045,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_UNLOCK = 0x80028046,
SCE_KERNEL_ERROR_PROCESSMGR_ERROR = 0x80029000,
SCE_KERNEL_ERROR_INVALID_PID = 0x80029001,
SCE_KERNEL_ERROR_INVALID_PROCESS_TYPE = 0x80029002,
SCE_KERNEL_ERROR_PLS_FULL = 0x80029003,
SCE_KERNEL_ERROR_INVALID_PROCESS_STATUS = 0x80029004,
SCE_KERNEL_ERROR_INVALID_BUDGET_ID = 0x80029005,
SCE_KERNEL_ERROR_INVALID_BUDGET_SIZE = 0x80029006,
SCE_KERNEL_ERROR_CP14_DISABLED = 0x80029007,
SCE_KERNEL_ERROR_EXCEEDED_MAX_PROCESSES = 0x80029008,
SCE_KERNEL_ERROR_PROCESS_REMAINING = 0x80029009,
SCE_KERNEL_ERROR_IOFILEMGR_ERROR = 0x8002A000,
SCE_KERNEL_ERROR_IO_NAME_TOO_LONG = 0x8002A001,
SCE_KERNEL_ERROR_IO_REG_DEV = 0x8002A002,
SCE_KERNEL_ERROR_IO_ALIAS_USED = 0x8002A003,
SCE_KERNEL_ERROR_IO_DEL_DEV = 0x8002A004,
SCE_KERNEL_ERROR_IO_WOULD_BLOCK = 0x8002A005,
SCE_KERNEL_ERROR_MODULEMGR_START_FAILED = 0x8002D000,
SCE_KERNEL_ERROR_MODULEMGR_STOP_FAIL = 0x8002D001,
SCE_KERNEL_ERROR_MODULEMGR_IN_USE = 0x8002D002,
SCE_KERNEL_ERROR_MODULEMGR_NO_LIB = 0x8002D003,
SCE_KERNEL_ERROR_MODULEMGR_SYSCALL_REG = 0x8002D004,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_LIB = 0x8002D005,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_STUB = 0x8002D006,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_SELF = 0x8002D007,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM = 0x8002D008,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_LIB = 0x8002D009,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_STUB = 0x8002D00A,
SCE_KERNEL_ERROR_MODULEMGR_NO_FUNC_NID = 0x8002D00B,
SCE_KERNEL_ERROR_MODULEMGR_NO_VAR_NID = 0x8002D00C,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_TYPE = 0x8002D00D,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD_ENTRY = 0x8002D00E,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROC_PARAM = 0x8002D00F,
SCE_KERNEL_ERROR_MODULEMGR_NO_MODOBJ = 0x8002D010,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD = 0x8002D011,
SCE_KERNEL_ERROR_MODULEMGR_NO_PROCESS = 0x8002D012,
SCE_KERNEL_ERROR_MODULEMGR_OLD_LIB = 0x8002D013,
SCE_KERNEL_ERROR_MODULEMGR_STARTED = 0x8002D014,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STARTED = 0x8002D015,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STOPPED = 0x8002D016,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROCESS_UID = 0x8002D017,
SCE_KERNEL_ERROR_MODULEMGR_CANNOT_EXPORT_LIB_TO_SHARED = 0x8002D018,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REL_INFO = 0x8002D019,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REF_INFO = 0x8002D01A,
SCE_KERNEL_ERROR_MODULEMGR_ELINK = 0x8002D01B,
SCE_KERNEL_ERROR_MODULEMGR_NOENT = 0x8002D01C,
SCE_KERNEL_ERROR_MODULEMGR_BUSY = 0x8002D01D,
SCE_KERNEL_ERROR_MODULEMGR_NOEXEC = 0x8002D01E,
SCE_KERNEL_ERROR_MODULEMGR_NAMETOOLONG = 0x8002D01F,
SCE_KERNEL_ERROR_LIBRARYDB_NOENT = 0x8002D080,
SCE_KERNEL_ERROR_LIBRARYDB_NO_LIB = 0x8002D081,
SCE_KERNEL_ERROR_LIBRARYDB_NO_MOD = 0x8002D082,
SCE_KERNEL_ERROR_AUTHFAIL = 0x8002F000,
SCE_KERNEL_ERROR_NO_AUTH = 0x8002F001,
};
union SceKernelSysClock
{
struct
{
u32 low;
u32 hi;
};
u64 quad;
};
struct SceKernelCallFrame
{
u32 sp;
u32 pc;
};
// Memory Manager definitions
typedef s32 SceKernelMemoryType;
struct SceKernelMemBlockInfo
{
u32 size;
vm::psv::ptr<void> mappedBase;
u32 mappedSize;
SceKernelMemoryType memoryType;
u32 access;
};
struct SceKernelAllocMemBlockOpt
{
u32 size;
u32 attr;
u32 alignment;
s32 uidBaseBlock;
vm::psv::ptr<const char> strBaseBlockName;
};
// Thread Manager definitions (threads)
typedef s32(*SceKernelThreadEntry)(u32 argSize, vm::psv::ptr<void> pArgBlock);
struct SceKernelThreadOptParam
{
u32 size;
u32 attr;
};
struct SceKernelThreadInfo
{
u32 size;
s32 processId;
char name[32];
u32 attr;
u32 status;
vm::psv::ptr<SceKernelThreadEntry> entry;
vm::psv::ptr<void> pStack;
u32 stackSize;
s32 initPriority;
s32 currentPriority;
s32 initCpuAffinityMask;
s32 currentCpuAffinityMask;
s32 currentCpuId;
s32 lastExecutedCpuId;
u32 waitType;
s32 waitId;
s32 exitStatus;
SceKernelSysClock runClocks;
u32 intrPreemptCount;
u32 threadPreemptCount;
u32 threadReleaseCount;
s32 changeCpuCount;
s32 fNotifyCallback;
s32 reserved;
};
struct SceKernelThreadRunStatus
{
u32 size;
struct
{
s32 processId;
s32 threadId;
s32 priority;
} cpuInfo[4];
};
struct SceKernelSystemInfo
{
u32 size;
u32 activeCpuMask;
struct
{
SceKernelSysClock idleClock;
u32 comesOutOfIdleCount;
u32 threadSwitchCount;
} cpuInfo[4];
};
// Thread Manager definitions (callbacks)
typedef s32(*SceKernelCallbackFunction)(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon);
struct SceKernelCallbackInfo
{
u32 size;
s32 callbackId;
char name[32];
u32 attr;
s32 threadId;
vm::psv::ptr<SceKernelCallbackFunction> callbackFunc;
s32 notifyId;
s32 notifyCount;
s32 notifyArg;
vm::psv::ptr<void> pCommon;
};
// Thread Manager definitions (events)
typedef s32(*SceKernelThreadEventHandler)(s32 type, s32 threadId, s32 arg, vm::psv::ptr<void> pCommon);
struct SceKernelEventInfo
{
u32 size;
s32 eventId;
char name[32];
u32 attr;
u32 eventPattern;
u64 userData;
u32 numWaitThreads;
s32 reserved[1];
};
struct SceKernelWaitEvent
{
s32 eventId;
u32 eventPattern;
};
struct SceKernelResultEvent
{
s32 eventId;
s32 result;
u32 resultPattern;
s32 reserved[1];
u64 userData;
};
// Thread Manager definitions (event flags)
struct SceKernelEventFlagOptParam
{
u32 size;
};
struct SceKernelEventFlagInfo
{
u32 size;
s32 evfId;
char name[32];
u32 attr;
u32 initPattern;
u32 currentPattern;
s32 numWaitThreads;
};
// Thread Manager definitions (semaphores)
struct SceKernelSemaOptParam
{
u32 size;
};
struct SceKernelSemaInfo
{
u32 size;
s32 semaId;
char name[32];
u32 attr;
s32 initCount;
s32 currentCount;
s32 maxCount;
s32 numWaitThreads;
};
// Thread Manager definitions (mutexes)
struct SceKernelMutexOptParam
{
u32 size;
s32 ceilingPriority;
};
struct SceKernelMutexInfo
{
u32 size;
s32 mutexId;
char name[32];
u32 attr;
s32 initCount;
s32 currentCount;
s32 currentOwnerId;
s32 numWaitThreads;
};
// Thread Manager definitions (lightweight mutexes)
struct SceKernelLwMutexWork
{
s32 data[4];
};
struct SceKernelLwMutexOptParam
{
u32 size;
};
struct SceKernelLwMutexInfo
{
u32 size;
s32 uid;
char name[32];
u32 attr;
vm::psv::ptr<SceKernelLwMutexWork> pWork;
s32 initCount;
s32 currentCount;
s32 currentOwnerId;
s32 numWaitThreads;
};
// Thread Manager definitions (condition variables)
struct SceKernelCondOptParam
{
u32 size;
};
struct SceKernelCondInfo
{
u32 size;
s32 condId;
char name[32];
u32 attr;
s32 mutexId;
u32 numWaitThreads;
};
// Thread Manager definitions (lightweight condition variables)
struct SceKernelLwCondWork
{
s32 data[4];
};
struct SceKernelLwCondOptParam
{
u32 size;
};
struct SceKernelLwCondInfo
{
u32 size;
s32 uid;
char name[32];
u32 attr;
vm::psv::ptr<SceKernelLwCondWork> pWork;
vm::psv::ptr<SceKernelLwMutexWork> pLwMutex;
u32 numWaitThreads;
};
// Thread Manager definitions (timers)
struct SceKernelTimerOptParam
{
u32 size;
};
struct SceKernelTimerInfo
{
u32 size;
s32 timerId;
char name[32];
u32 attr;
s32 fActive;
SceKernelSysClock baseTime;
SceKernelSysClock currentTime;
SceKernelSysClock schedule;
SceKernelSysClock interval;
s32 type;
s32 fRepeat;
s32 numWaitThreads;
s32 reserved[1];
};
// Thread Manager definitions (reader/writer locks)
struct SceKernelRWLockOptParam
{
u32 size;
};
struct SceKernelRWLockInfo
{
u32 size;
s32 rwLockId;
char name[32];
u32 attr;
s32 lockCount;
s32 writeOwnerId;
s32 numReadWaitThreads;
s32 numWriteWaitThreads;
};
// IO/File Manager definitions
struct SceIoStat
{
s32 mode;
u32 attr;
s64 size;
SceDateTime ctime;
SceDateTime atime;
SceDateTime mtime;
u64 _private[6];
};
struct SceIoDirent
{
SceIoStat d_stat;
char d_name[256];
vm::psv::ptr<void> d_private;
s32 dummy;
};
// Module
extern psv_log_base sceLibKernel;

1
rpcs3/Emu/ARMv7/Modules/sceLibc.cpp
View File

@ -1,7 +1,6 @@
#include "stdafx.h"
#include "Utilities/Log.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "Emu/ARMv7/ARMv7Callback.h"

1
rpcs3/Emu/ARMv7/Modules/sceLibm.cpp
View File

@ -1,6 +1,5 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibm;

1
rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp
View File

@ -1,6 +1,5 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibstdcxx;

678
rpcs3/Emu/ARMv7/PSVFuncList.h
View File

@ -1,7 +1,9 @@
#pragma once
#include "Emu/Memory/Memory.h"
#include "ARMv7Context.h"
#include "Emu/SysCalls/LogBase.h"
// PSV module class
class psv_log_base : public LogBase
{
std::string m_name;
@ -31,385 +33,7 @@ public:
};
enum psv_error_codes
{
SCE_OK = 0,
SCE_ERROR_ERRNO_EPERM = 0x80010001,
SCE_ERROR_ERRNO_ENOENT = 0x80010002,
SCE_ERROR_ERRNO_ESRCH = 0x80010003,
SCE_ERROR_ERRNO_EINTR = 0x80010004,
SCE_ERROR_ERRNO_EIO = 0x80010005,
SCE_ERROR_ERRNO_ENXIO = 0x80010006,
SCE_ERROR_ERRNO_E2BIG = 0x80010007,
SCE_ERROR_ERRNO_ENOEXEC = 0x80010008,
SCE_ERROR_ERRNO_EBADF = 0x80010009,
SCE_ERROR_ERRNO_ECHILD = 0x8001000A,
SCE_ERROR_ERRNO_EAGAIN = 0x8001000B,
SCE_ERROR_ERRNO_ENOMEM = 0x8001000C,
SCE_ERROR_ERRNO_EACCES = 0x8001000D,
SCE_ERROR_ERRNO_EFAULT = 0x8001000E,
SCE_ERROR_ERRNO_ENOTBLK = 0x8001000F,
SCE_ERROR_ERRNO_EBUSY = 0x80010010,
SCE_ERROR_ERRNO_EEXIST = 0x80010011,
SCE_ERROR_ERRNO_EXDEV = 0x80010012,
SCE_ERROR_ERRNO_ENODEV = 0x80010013,
SCE_ERROR_ERRNO_ENOTDIR = 0x80010014,
SCE_ERROR_ERRNO_EISDIR = 0x80010015,
SCE_ERROR_ERRNO_EINVAL = 0x80010016,
SCE_ERROR_ERRNO_ENFILE = 0x80010017,
SCE_ERROR_ERRNO_EMFILE = 0x80010018,
SCE_ERROR_ERRNO_ENOTTY = 0x80010019,
SCE_ERROR_ERRNO_ETXTBSY = 0x8001001A,
SCE_ERROR_ERRNO_EFBIG = 0x8001001B,
SCE_ERROR_ERRNO_ENOSPC = 0x8001001C,
SCE_ERROR_ERRNO_ESPIPE = 0x8001001D,
SCE_ERROR_ERRNO_EROFS = 0x8001001E,
SCE_ERROR_ERRNO_EMLINK = 0x8001001F,
SCE_ERROR_ERRNO_EPIPE = 0x80010020,
SCE_ERROR_ERRNO_EDOM = 0x80010021,
SCE_ERROR_ERRNO_ERANGE = 0x80010022,
SCE_ERROR_ERRNO_ENOMSG = 0x80010023,
SCE_ERROR_ERRNO_EIDRM = 0x80010024,
SCE_ERROR_ERRNO_ECHRNG = 0x80010025,
SCE_ERROR_ERRNO_EL2NSYNC = 0x80010026,
SCE_ERROR_ERRNO_EL3HLT = 0x80010027,
SCE_ERROR_ERRNO_EL3RST = 0x80010028,
SCE_ERROR_ERRNO_ELNRNG = 0x80010029,
SCE_ERROR_ERRNO_EUNATCH = 0x8001002A,
SCE_ERROR_ERRNO_ENOCSI = 0x8001002B,
SCE_ERROR_ERRNO_EL2HLT = 0x8001002C,
SCE_ERROR_ERRNO_EDEADLK = 0x8001002D,
SCE_ERROR_ERRNO_ENOLCK = 0x8001002E,
SCE_ERROR_ERRNO_EFORMAT = 0x8001002F,
SCE_ERROR_ERRNO_EUNSUP = 0x80010030,
SCE_ERROR_ERRNO_EBADE = 0x80010032,
SCE_ERROR_ERRNO_EBADR = 0x80010033,
SCE_ERROR_ERRNO_EXFULL = 0x80010034,
SCE_ERROR_ERRNO_ENOANO = 0x80010035,
SCE_ERROR_ERRNO_EBADRQC = 0x80010036,
SCE_ERROR_ERRNO_EBADSLT = 0x80010037,
SCE_ERROR_ERRNO_EDEADLOCK = 0x80010038,
SCE_ERROR_ERRNO_EBFONT = 0x80010039,
SCE_ERROR_ERRNO_ENOSTR = 0x8001003C,
SCE_ERROR_ERRNO_ENODATA = 0x8001003D,
SCE_ERROR_ERRNO_ETIME = 0x8001003E,
SCE_ERROR_ERRNO_ENOSR = 0x8001003F,
SCE_ERROR_ERRNO_ENONET = 0x80010040,
SCE_ERROR_ERRNO_ENOPKG = 0x80010041,
SCE_ERROR_ERRNO_EREMOTE = 0x80010042,
SCE_ERROR_ERRNO_ENOLINK = 0x80010043,
SCE_ERROR_ERRNO_EADV = 0x80010044,
SCE_ERROR_ERRNO_ESRMNT = 0x80010045,
SCE_ERROR_ERRNO_ECOMM = 0x80010046,
SCE_ERROR_ERRNO_EPROTO = 0x80010047,
SCE_ERROR_ERRNO_EMULTIHOP = 0x8001004A,
SCE_ERROR_ERRNO_ELBIN = 0x8001004B,
SCE_ERROR_ERRNO_EDOTDOT = 0x8001004C,
SCE_ERROR_ERRNO_EBADMSG = 0x8001004D,
SCE_ERROR_ERRNO_EFTYPE = 0x8001004F,
SCE_ERROR_ERRNO_ENOTUNIQ = 0x80010050,
SCE_ERROR_ERRNO_EBADFD = 0x80010051,
SCE_ERROR_ERRNO_EREMCHG = 0x80010052,
SCE_ERROR_ERRNO_ELIBACC = 0x80010053,
SCE_ERROR_ERRNO_ELIBBAD = 0x80010054,
SCE_ERROR_ERRNO_ELIBSCN = 0x80010055,
SCE_ERROR_ERRNO_ELIBMAX = 0x80010056,
SCE_ERROR_ERRNO_ELIBEXEC = 0x80010057,
SCE_ERROR_ERRNO_ENOSYS = 0x80010058,
SCE_ERROR_ERRNO_ENMFILE = 0x80010059,
SCE_ERROR_ERRNO_ENOTEMPTY = 0x8001005A,
SCE_ERROR_ERRNO_ENAMETOOLONG = 0x8001005B,
SCE_ERROR_ERRNO_ELOOP = 0x8001005C,
SCE_ERROR_ERRNO_EOPNOTSUPP = 0x8001005F,
SCE_ERROR_ERRNO_EPFNOSUPPORT = 0x80010060,
SCE_ERROR_ERRNO_ECONNRESET = 0x80010068,
SCE_ERROR_ERRNO_ENOBUFS = 0x80010069,
SCE_ERROR_ERRNO_EAFNOSUPPORT = 0x8001006A,
SCE_ERROR_ERRNO_EPROTOTYPE = 0x8001006B,
SCE_ERROR_ERRNO_ENOTSOCK = 0x8001006C,
SCE_ERROR_ERRNO_ENOPROTOOPT = 0x8001006D,
SCE_ERROR_ERRNO_ESHUTDOWN = 0x8001006E,
SCE_ERROR_ERRNO_ECONNREFUSED = 0x8001006F,
SCE_ERROR_ERRNO_EADDRINUSE = 0x80010070,
SCE_ERROR_ERRNO_ECONNABORTED = 0x80010071,
SCE_ERROR_ERRNO_ENETUNREACH = 0x80010072,
SCE_ERROR_ERRNO_ENETDOWN = 0x80010073,
SCE_ERROR_ERRNO_ETIMEDOUT = 0x80010074,
SCE_ERROR_ERRNO_EHOSTDOWN = 0x80010075,
SCE_ERROR_ERRNO_EHOSTUNREACH = 0x80010076,
SCE_ERROR_ERRNO_EINPROGRESS = 0x80010077,
SCE_ERROR_ERRNO_EALREADY = 0x80010078,
SCE_ERROR_ERRNO_EDESTADDRREQ = 0x80010079,
SCE_ERROR_ERRNO_EMSGSIZE = 0x8001007A,
SCE_ERROR_ERRNO_EPROTONOSUPPORT = 0x8001007B,
SCE_ERROR_ERRNO_ESOCKTNOSUPPORT = 0x8001007C,
SCE_ERROR_ERRNO_EADDRNOTAVAIL = 0x8001007D,
SCE_ERROR_ERRNO_ENETRESET = 0x8001007E,
SCE_ERROR_ERRNO_EISCONN = 0x8001007F,
SCE_ERROR_ERRNO_ENOTCONN = 0x80010080,
SCE_ERROR_ERRNO_ETOOMANYREFS = 0x80010081,
SCE_ERROR_ERRNO_EPROCLIM = 0x80010082,
SCE_ERROR_ERRNO_EUSERS = 0x80010083,
SCE_ERROR_ERRNO_EDQUOT = 0x80010084,
SCE_ERROR_ERRNO_ESTALE = 0x80010085,
SCE_ERROR_ERRNO_ENOTSUP = 0x80010086,
SCE_ERROR_ERRNO_ENOMEDIUM = 0x80010087,
SCE_ERROR_ERRNO_ENOSHARE = 0x80010088,
SCE_ERROR_ERRNO_ECASECLASH = 0x80010089,
SCE_ERROR_ERRNO_EILSEQ = 0x8001008A,
SCE_ERROR_ERRNO_EOVERFLOW = 0x8001008B,
SCE_ERROR_ERRNO_ECANCELED = 0x8001008C,
SCE_ERROR_ERRNO_ENOTRECOVERABLE = 0x8001008D,
SCE_ERROR_ERRNO_EOWNERDEAD = 0x8001008E,
SCE_KERNEL_ERROR_ERROR = 0x80020001,
SCE_KERNEL_ERROR_NOT_IMPLEMENTED = 0x80020002,
SCE_KERNEL_ERROR_INVALID_ARGUMENT = 0x80020003,
SCE_KERNEL_ERROR_INVALID_ARGUMENT_SIZE = 0x80020004,
SCE_KERNEL_ERROR_INVALID_FLAGS = 0x80020005,
SCE_KERNEL_ERROR_ILLEGAL_SIZE = 0x80020006,
SCE_KERNEL_ERROR_ILLEGAL_ADDR = 0x80020007,
SCE_KERNEL_ERROR_UNSUP = 0x80020008,
SCE_KERNEL_ERROR_ILLEGAL_MODE = 0x80020009,
SCE_KERNEL_ERROR_ILLEGAL_ALIGNMENT = 0x8002000A,
SCE_KERNEL_ERROR_NOSYS = 0x8002000B,
SCE_KERNEL_ERROR_DEBUG_ERROR = 0x80021000,
SCE_KERNEL_ERROR_ILLEGAL_DIPSW_NUMBER = 0x80021001,
SCE_KERNEL_ERROR_CPU_ERROR = 0x80022000,
SCE_KERNEL_ERROR_MMU_ILLEGAL_L1_TYPE = 0x80022001,
SCE_KERNEL_ERROR_MMU_L2_INDEX_OVERFLOW = 0x80022002,
SCE_KERNEL_ERROR_MMU_L2_SIZE_OVERFLOW = 0x80022003,
SCE_KERNEL_ERROR_INVALID_CPU_AFFINITY = 0x80022004,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS = 0x80022005,
SCE_KERNEL_ERROR_INVALID_MEMORY_ACCESS_PERMISSION = 0x80022006,
SCE_KERNEL_ERROR_VA2PA_FAULT = 0x80022007,
SCE_KERNEL_ERROR_VA2PA_MAPPED = 0x80022008,
SCE_KERNEL_ERROR_VALIDATION_CHECK_FAILED = 0x80022009,
SCE_KERNEL_ERROR_SYSMEM_ERROR = 0x80024000,
SCE_KERNEL_ERROR_INVALID_PROCESS_CONTEXT = 0x80024001,
SCE_KERNEL_ERROR_UID_NAME_TOO_LONG = 0x80024002,
SCE_KERNEL_ERROR_VARANGE_IS_NOT_PHYSICAL_CONTINUOUS = 0x80024003,
SCE_KERNEL_ERROR_PHYADDR_ERROR = 0x80024100,
SCE_KERNEL_ERROR_NO_PHYADDR = 0x80024101,
SCE_KERNEL_ERROR_PHYADDR_USED = 0x80024102,
SCE_KERNEL_ERROR_PHYADDR_NOT_USED = 0x80024103,
SCE_KERNEL_ERROR_NO_IOADDR = 0x80024104,
SCE_KERNEL_ERROR_PHYMEM_ERROR = 0x80024300,
SCE_KERNEL_ERROR_ILLEGAL_PHYPAGE_STATUS = 0x80024301,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE = 0x80024302,
SCE_KERNEL_ERROR_NO_FREE_PHYSICAL_PAGE_UNIT = 0x80024303,
SCE_KERNEL_ERROR_PHYMEMPART_NOT_EMPTY = 0x80024304,
SCE_KERNEL_ERROR_NO_PHYMEMPART_LPDDR2 = 0x80024305,
SCE_KERNEL_ERROR_NO_PHYMEMPART_CDRAM = 0x80024306,
SCE_KERNEL_ERROR_FIXEDHEAP_ERROR = 0x80024400,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_SIZE = 0x80024401,
SCE_KERNEL_ERROR_FIXEDHEAP_ILLEGAL_INDEX = 0x80024402,
SCE_KERNEL_ERROR_FIXEDHEAP_INDEX_OVERFLOW = 0x80024403,
SCE_KERNEL_ERROR_FIXEDHEAP_NO_CHUNK = 0x80024404,
SCE_KERNEL_ERROR_UID_ERROR = 0x80024500,
SCE_KERNEL_ERROR_INVALID_UID = 0x80024501,
SCE_KERNEL_ERROR_SYSMEM_UID_INVALID_ARGUMENT = 0x80024502,
SCE_KERNEL_ERROR_SYSMEM_INVALID_UID_RANGE = 0x80024503,
SCE_KERNEL_ERROR_SYSMEM_NO_VALID_UID = 0x80024504,
SCE_KERNEL_ERROR_SYSMEM_CANNOT_ALLOCATE_UIDENTRY = 0x80024505,
SCE_KERNEL_ERROR_NOT_PROCESS_UID = 0x80024506,
SCE_KERNEL_ERROR_NOT_KERNEL_UID = 0x80024507,
SCE_KERNEL_ERROR_INVALID_UID_CLASS = 0x80024508,
SCE_KERNEL_ERROR_INVALID_UID_SUBCLASS = 0x80024509,
SCE_KERNEL_ERROR_UID_CANNOT_FIND_BY_NAME = 0x8002450A,
SCE_KERNEL_ERROR_VIRPAGE_ERROR = 0x80024600,
SCE_KERNEL_ERROR_ILLEGAL_VIRPAGE_TYPE = 0x80024601,
SCE_KERNEL_ERROR_BLOCK_ERROR = 0x80024700,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_ID = 0x80024701,
SCE_KERNEL_ERROR_ILLEGAL_BLOCK_TYPE = 0x80024702,
SCE_KERNEL_ERROR_BLOCK_IN_USE = 0x80024703,
SCE_KERNEL_ERROR_PARTITION_ERROR = 0x80024800,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_ID = 0x80024801,
SCE_KERNEL_ERROR_ILLEGAL_PARTITION_INDEX = 0x80024802,
SCE_KERNEL_ERROR_NO_L2PAGETABLE = 0x80024803,
SCE_KERNEL_ERROR_HEAPLIB_ERROR = 0x80024900,
SCE_KERNEL_ERROR_ILLEGAL_HEAP_ID = 0x80024901,
SCE_KERNEL_ERROR_OUT_OF_RANG = 0x80024902,
SCE_KERNEL_ERROR_HEAPLIB_NOMEM = 0x80024903,
SCE_KERNEL_ERROR_SYSMEM_ADDRESS_SPACE_ERROR = 0x80024A00,
SCE_KERNEL_ERROR_INVALID_ADDRESS_SPACE_ID = 0x80024A01,
SCE_KERNEL_ERROR_INVALID_PARTITION_INDEX = 0x80024A02,
SCE_KERNEL_ERROR_ADDRESS_SPACE_CANNOT_FIND_PARTITION_BY_ADDR = 0x80024A03,
SCE_KERNEL_ERROR_SYSMEM_MEMBLOCK_ERROR = 0x80024B00,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_TYPE = 0x80024B01,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_REMAP_TYPE = 0x80024B02,
SCE_KERNEL_ERROR_NOT_PHY_CONT_MEMBLOCK = 0x80024B03,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_CODE = 0x80024B04,
SCE_KERNEL_ERROR_ILLEGAL_MEMBLOCK_SIZE = 0x80024B05,
SCE_KERNEL_ERROR_ILLEGAL_USERMAP_SIZE = 0x80024B06,
SCE_KERNEL_ERROR_MEMBLOCK_TYPE_FOR_KERNEL_PROCESS = 0x80024B07,
SCE_KERNEL_ERROR_PROCESS_CANNOT_REMAP_MEMBLOCK = 0x80024B08,
SCE_KERNEL_ERROR_SYSMEM_PHYMEMLOW_ERROR = 0x80024C00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_PHYMEMLOW = 0x80024C01,
SCE_KERNEL_ERROR_UNKNOWN_PHYMEMLOW_TYPE = 0x80024C02,
SCE_KERNEL_ERROR_SYSMEM_BITHEAP_ERROR = 0x80024D00,
SCE_KERNEL_ERROR_CANNOT_ALLOC_BITHEAP = 0x80024D01,
SCE_KERNEL_ERROR_LOADCORE_ERROR = 0x80025000,
SCE_KERNEL_ERROR_ILLEGAL_ELF_HEADER = 0x80025001,
SCE_KERNEL_ERROR_ILLEGAL_SELF_HEADER = 0x80025002,
SCE_KERNEL_ERROR_EXCPMGR_ERROR = 0x80027000,
SCE_KERNEL_ERROR_ILLEGAL_EXCPCODE = 0x80027001,
SCE_KERNEL_ERROR_ILLEGAL_EXCPHANDLER = 0x80027002,
SCE_KERNEL_ERROR_NOTFOUND_EXCPHANDLER = 0x80027003,
SCE_KERNEL_ERROR_CANNOT_RELEASE_EXCPHANDLER = 0x80027004,
SCE_KERNEL_ERROR_INTRMGR_ERROR = 0x80027100,
SCE_KERNEL_ERROR_ILLEGAL_CONTEXT = 0x80027101,
SCE_KERNEL_ERROR_ILLEGAL_INTRCODE = 0x80027102,
SCE_KERNEL_ERROR_ILLEGAL_INTRPARAM = 0x80027103,
SCE_KERNEL_ERROR_ILLEGAL_INTRPRIORITY = 0x80027104,
SCE_KERNEL_ERROR_ILLEGAL_TARGET_CPU = 0x80027105,
SCE_KERNEL_ERROR_ILLEGAL_INTRFILTER = 0x80027106,
SCE_KERNEL_ERROR_ILLEGAL_INTRTYPE = 0x80027107,
SCE_KERNEL_ERROR_ILLEGAL_HANDLER = 0x80027108,
SCE_KERNEL_ERROR_FOUND_HANDLER = 0x80027109,
SCE_KERNEL_ERROR_NOTFOUND_HANDLER = 0x8002710A,
SCE_KERNEL_ERROR_NO_MEMORY = 0x8002710B,
SCE_KERNEL_ERROR_DMACMGR_ERROR = 0x80027200,
SCE_KERNEL_ERROR_ALREADY_QUEUED = 0x80027201,
SCE_KERNEL_ERROR_NOT_QUEUED = 0x80027202,
SCE_KERNEL_ERROR_NOT_SETUP = 0x80027203,
SCE_KERNEL_ERROR_ON_TRANSFERRING = 0x80027204,
SCE_KERNEL_ERROR_NOT_INITIALIZED = 0x80027205,
SCE_KERNEL_ERROR_TRANSFERRED = 0x80027206,
SCE_KERNEL_ERROR_NOT_UNDER_CONTROL = 0x80027207,
SCE_KERNEL_ERROR_SYSTIMER_ERROR = 0x80027300,
SCE_KERNEL_ERROR_NO_FREE_TIMER = 0x80027301,
SCE_KERNEL_ERROR_TIMER_NOT_ALLOCATED = 0x80027302,
SCE_KERNEL_ERROR_TIMER_COUNTING = 0x80027303,
SCE_KERNEL_ERROR_TIMER_STOPPED = 0x80027304,
SCE_KERNEL_ERROR_THREADMGR_ERROR = 0x80028000,
SCE_KERNEL_ERROR_DORMANT = 0x80028001,
SCE_KERNEL_ERROR_NOT_DORMANT = 0x80028002,
SCE_KERNEL_ERROR_UNKNOWN_THID = 0x80028003,
SCE_KERNEL_ERROR_CAN_NOT_WAIT = 0x80028004,
SCE_KERNEL_ERROR_ILLEGAL_THID = 0x80028005,
SCE_KERNEL_ERROR_THREAD_TERMINATED = 0x80028006,
SCE_KERNEL_ERROR_DELETED = 0x80028007,
SCE_KERNEL_ERROR_WAIT_TIMEOUT = 0x80028008,
SCE_KERNEL_ERROR_NOTIFY_CALLBACK = 0x80028009,
SCE_KERNEL_ERROR_WAIT_DELETE = 0x8002800A,
SCE_KERNEL_ERROR_ILLEGAL_ATTR = 0x8002800B,
SCE_KERNEL_ERROR_EVF_MULTI = 0x8002800C,
SCE_KERNEL_ERROR_WAIT_CANCEL = 0x8002800D,
SCE_KERNEL_ERROR_EVF_COND = 0x8002800E,
SCE_KERNEL_ERROR_ILLEGAL_COUNT = 0x8002800F,
SCE_KERNEL_ERROR_ILLEGAL_PRIORITY = 0x80028010,
SCE_KERNEL_ERROR_MUTEX_RECURSIVE = 0x80028011,
SCE_KERNEL_ERROR_MUTEX_LOCK_OVF = 0x80028012,
SCE_KERNEL_ERROR_MUTEX_NOT_OWNED = 0x80028013,
SCE_KERNEL_ERROR_MUTEX_UNLOCK_UDF = 0x80028014,
SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN = 0x80028015,
SCE_KERNEL_ERROR_FAST_MUTEX_RECURSIVE = 0x80028016,
SCE_KERNEL_ERROR_FAST_MUTEX_LOCK_OVF = 0x80028017,
SCE_KERNEL_ERROR_FAST_MUTEX_FAILED_TO_OWN = 0x80028018,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_OWNED = 0x80028019,
SCE_KERNEL_ERROR_FAST_MUTEX_OWNED = 0x8002801A,
SCE_KERNEL_ERROR_ALARM_CAN_NOT_CANCEL = 0x8002801B,
SCE_KERNEL_ERROR_INVALID_OBJECT_TYPE = 0x8002801C,
SCE_KERNEL_ERROR_KERNEL_TLS_FULL = 0x8002801D,
SCE_KERNEL_ERROR_ILLEGAL_KERNEL_TLS_INDEX = 0x8002801E,
SCE_KERNEL_ERROR_KERNEL_TLS_BUSY = 0x8002801F,
SCE_KERNEL_ERROR_DIFFERENT_UID_CLASS = 0x80028020,
SCE_KERNEL_ERROR_UNKNOWN_UID = 0x80028021,
SCE_KERNEL_ERROR_SEMA_ZERO = 0x80028022,
SCE_KERNEL_ERROR_SEMA_OVF = 0x80028023,
SCE_KERNEL_ERROR_PMON_NOT_THREAD_MODE = 0x80028024,
SCE_KERNEL_ERROR_PMON_NOT_CPU_MODE = 0x80028025,
SCE_KERNEL_ERROR_ALREADY_REGISTERED = 0x80028026,
SCE_KERNEL_ERROR_INVALID_THREAD_ID = 0x80028027,
SCE_KERNEL_ERROR_ALREADY_DEBUG_SUSPENDED = 0x80028028,
SCE_KERNEL_ERROR_NOT_DEBUG_SUSPENDED = 0x80028029,
SCE_KERNEL_ERROR_CAN_NOT_USE_VFP = 0x8002802A,
SCE_KERNEL_ERROR_RUNNING = 0x8002802B,
SCE_KERNEL_ERROR_EVENT_COND = 0x8002802C,
SCE_KERNEL_ERROR_MSG_PIPE_FULL = 0x8002802D,
SCE_KERNEL_ERROR_MSG_PIPE_EMPTY = 0x8002802E,
SCE_KERNEL_ERROR_ALREADY_SENT = 0x8002802F,
SCE_KERNEL_ERROR_CAN_NOT_SUSPEND = 0x80028030,
SCE_KERNEL_ERROR_FAST_MUTEX_ALREADY_INITIALIZED = 0x80028031,
SCE_KERNEL_ERROR_FAST_MUTEX_NOT_INITIALIZED = 0x80028032,
SCE_KERNEL_ERROR_THREAD_STOPPED = 0x80028033,
SCE_KERNEL_ERROR_THREAD_SUSPENDED = 0x80028034,
SCE_KERNEL_ERROR_NOT_SUSPENDED = 0x80028035,
SCE_KERNEL_ERROR_WAIT_DELETE_MUTEX = 0x80028036,
SCE_KERNEL_ERROR_WAIT_CANCEL_MUTEX = 0x80028037,
SCE_KERNEL_ERROR_WAIT_DELETE_COND = 0x80028038,
SCE_KERNEL_ERROR_WAIT_CANCEL_COND = 0x80028039,
SCE_KERNEL_ERROR_LW_MUTEX_NOT_OWNED = 0x8002803A,
SCE_KERNEL_ERROR_LW_MUTEX_LOCK_OVF = 0x8002803B,
SCE_KERNEL_ERROR_LW_MUTEX_UNLOCK_UDF = 0x8002803C,
SCE_KERNEL_ERROR_LW_MUTEX_RECURSIVE = 0x8002803D,
SCE_KERNEL_ERROR_LW_MUTEX_FAILED_TO_OWN = 0x8002803E,
SCE_KERNEL_ERROR_WAIT_DELETE_LW_MUTEX = 0x8002803F,
SCE_KERNEL_ERROR_ILLEGAL_STACK_SIZE = 0x80028040,
SCE_KERNEL_ERROR_RW_LOCK_RECURSIVE = 0x80028041,
SCE_KERNEL_ERROR_RW_LOCK_LOCK_OVF = 0x80028042,
SCE_KERNEL_ERROR_RW_LOCK_NOT_OWNED = 0x80028043,
SCE_KERNEL_ERROR_RW_LOCK_UNLOCK_UDF = 0x80028044,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_LOCK = 0x80028045,
SCE_KERNEL_ERROR_RW_LOCK_FAILED_TO_UNLOCK = 0x80028046,
SCE_KERNEL_ERROR_PROCESSMGR_ERROR = 0x80029000,
SCE_KERNEL_ERROR_INVALID_PID = 0x80029001,
SCE_KERNEL_ERROR_INVALID_PROCESS_TYPE = 0x80029002,
SCE_KERNEL_ERROR_PLS_FULL = 0x80029003,
SCE_KERNEL_ERROR_INVALID_PROCESS_STATUS = 0x80029004,
SCE_KERNEL_ERROR_INVALID_BUDGET_ID = 0x80029005,
SCE_KERNEL_ERROR_INVALID_BUDGET_SIZE = 0x80029006,
SCE_KERNEL_ERROR_CP14_DISABLED = 0x80029007,
SCE_KERNEL_ERROR_EXCEEDED_MAX_PROCESSES = 0x80029008,
SCE_KERNEL_ERROR_PROCESS_REMAINING = 0x80029009,
SCE_KERNEL_ERROR_IOFILEMGR_ERROR = 0x8002A000,
SCE_KERNEL_ERROR_IO_NAME_TOO_LONG = 0x8002A001,
SCE_KERNEL_ERROR_IO_REG_DEV = 0x8002A002,
SCE_KERNEL_ERROR_IO_ALIAS_USED = 0x8002A003,
SCE_KERNEL_ERROR_IO_DEL_DEV = 0x8002A004,
SCE_KERNEL_ERROR_IO_WOULD_BLOCK = 0x8002A005,
SCE_KERNEL_ERROR_MODULEMGR_START_FAILED = 0x8002D000,
SCE_KERNEL_ERROR_MODULEMGR_STOP_FAIL = 0x8002D001,
SCE_KERNEL_ERROR_MODULEMGR_IN_USE = 0x8002D002,
SCE_KERNEL_ERROR_MODULEMGR_NO_LIB = 0x8002D003,
SCE_KERNEL_ERROR_MODULEMGR_SYSCALL_REG = 0x8002D004,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_LIB = 0x8002D005,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_STUB = 0x8002D006,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM_SELF = 0x8002D007,
SCE_KERNEL_ERROR_MODULEMGR_NOMEM = 0x8002D008,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_LIB = 0x8002D009,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_STUB = 0x8002D00A,
SCE_KERNEL_ERROR_MODULEMGR_NO_FUNC_NID = 0x8002D00B,
SCE_KERNEL_ERROR_MODULEMGR_NO_VAR_NID = 0x8002D00C,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_TYPE = 0x8002D00D,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD_ENTRY = 0x8002D00E,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROC_PARAM = 0x8002D00F,
SCE_KERNEL_ERROR_MODULEMGR_NO_MODOBJ = 0x8002D010,
SCE_KERNEL_ERROR_MODULEMGR_NO_MOD = 0x8002D011,
SCE_KERNEL_ERROR_MODULEMGR_NO_PROCESS = 0x8002D012,
SCE_KERNEL_ERROR_MODULEMGR_OLD_LIB = 0x8002D013,
SCE_KERNEL_ERROR_MODULEMGR_STARTED = 0x8002D014,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STARTED = 0x8002D015,
SCE_KERNEL_ERROR_MODULEMGR_NOT_STOPPED = 0x8002D016,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_PROCESS_UID = 0x8002D017,
SCE_KERNEL_ERROR_MODULEMGR_CANNOT_EXPORT_LIB_TO_SHARED = 0x8002D018,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REL_INFO = 0x8002D019,
SCE_KERNEL_ERROR_MODULEMGR_INVALID_REF_INFO = 0x8002D01A,
SCE_KERNEL_ERROR_MODULEMGR_ELINK = 0x8002D01B,
SCE_KERNEL_ERROR_MODULEMGR_NOENT = 0x8002D01C,
SCE_KERNEL_ERROR_MODULEMGR_BUSY = 0x8002D01D,
SCE_KERNEL_ERROR_MODULEMGR_NOEXEC = 0x8002D01E,
SCE_KERNEL_ERROR_MODULEMGR_NAMETOOLONG = 0x8002D01F,
SCE_KERNEL_ERROR_LIBRARYDB_NOENT = 0x8002D080,
SCE_KERNEL_ERROR_LIBRARYDB_NO_LIB = 0x8002D081,
SCE_KERNEL_ERROR_LIBRARYDB_NO_MOD = 0x8002D082,
SCE_KERNEL_ERROR_AUTHFAIL = 0x8002F000,
SCE_KERNEL_ERROR_NO_AUTH = 0x8002F001,
};
// Abstract HLE function caller base class
class psv_func_caller
{
public:
@ -417,6 +41,7 @@ public:
virtual ~psv_func_caller(){};
};
// Utilities for binding ARMv7Context to C++ function arguments received by HLE functions or sent to callbacks
namespace psv_func_detail
{
enum bind_arg_type
@ -448,6 +73,39 @@ namespace psv_func_detail
}
};
template<int g_count, int f_count, int v_count>
struct bind_arg<u64, ARG_GENERAL, g_count, f_count, v_count>
{
// first u64 argument is passed in r0-r1, second one is passed in r2-r3 (if g_count = 3)
static_assert(g_count == 1 || g_count == 3, "Wrong u64 argument position");
__forceinline static u64 get_arg(ARMv7Context& context)
{
return context.GPR_D[g_count >> 1];
}
__forceinline static void put_arg(ARMv7Context& context, u64 arg)
{
context.GPR_D[g_count >> 1] = arg;
}
};
template<int g_count, int f_count, int v_count>
struct bind_arg<s64, ARG_GENERAL, g_count, f_count, v_count>
{
static_assert(g_count == 1 || g_count == 3, "Wrong s64 argument position");
__forceinline static s64 get_arg(ARMv7Context& context)
{
return context.GPR_D[g_count >> 1];
}
__forceinline static void put_arg(ARMv7Context& context, s64 arg)
{
context.GPR_D[g_count >> 1] = arg;
}
};
template<typename T, int g_count, int f_count, int v_count>
struct bind_arg<T, ARG_FLOAT, g_count, f_count, v_count>
{
@ -488,7 +146,7 @@ namespace psv_func_detail
__forceinline static T get_arg(ARMv7Context& context)
{
// TODO: check
return cast_from_armv7_gpr<T>(context.get_stack_arg(g_count));
return cast_from_armv7_gpr<T>(vm::psv::read32(context.SP + sizeof(u32) * (g_count - 5)));
}
__forceinline static void put_arg(ARMv7Context& context, const T& arg)
@ -497,7 +155,45 @@ namespace psv_func_detail
const int stack_pos = (g_count - 5) * 4 - FIXED_STACK_FRAME_SIZE;
static_assert(stack_pos < 0, "TODO: Increase fixed stack frame size (arg count limit broken)");
context.put_stack_arg(stack_pos, cast_to_armv7_gpr<T>(arg));
vm::psv::write32(context.SP + stack_pos, cast_to_armv7_gpr<T>(arg));
}
};
template<int g_count, int f_count, int v_count>
struct bind_arg<u64, ARG_STACK, g_count, f_count, v_count>
{
__forceinline static u64 get_arg(ARMv7Context& context)
{
// TODO: check
return vm::psv::read64(context.SP + sizeof(u32) * (g_count - 5));
}
__forceinline static void put_arg(ARMv7Context& context, u64 arg)
{
// TODO: check
const int stack_pos = (g_count - 5) * 4 - FIXED_STACK_FRAME_SIZE;
static_assert(stack_pos < -4, "TODO: Increase fixed stack frame size (arg count limit broken)");
vm::psv::write64(context.SP + stack_pos, arg);
}
};
template<int g_count, int f_count, int v_count>
struct bind_arg<s64, ARG_STACK, g_count, f_count, v_count>
{
__forceinline static s64 get_arg(ARMv7Context& context)
{
// TODO: check
return vm::psv::read64(context.SP + sizeof(u32) * (g_count - 5));
}
__forceinline static void put_arg(ARMv7Context& context, s64 arg)
{
// TODO: check
const int stack_pos = (g_count - 5) * 4 - FIXED_STACK_FRAME_SIZE;
static_assert(stack_pos < -4, "TODO: Increase fixed stack frame size (arg count limit broken)");
vm::psv::write64(context.SP + stack_pos, arg);
}
};
@ -520,6 +216,34 @@ namespace psv_func_detail
}
};
template<>
struct bind_result<u64, ARG_GENERAL>
{
__forceinline static u64 get_result(ARMv7Context& context)
{
return context.GPR_D[0];
}
__forceinline static void put_result(ARMv7Context& context, u64 result)
{
context.GPR_D[0] = result;
}
};
template<>
struct bind_result<s64, ARG_GENERAL>
{
__forceinline static s64 get_result(ARMv7Context& context)
{
return context.GPR_D[0];
}
__forceinline static void put_result(ARMv7Context& context, s64 result)
{
context.GPR_D[0] = result;
}
};
//template<typename T>
//struct bind_result<T, ARG_FLOAT>
//{
@ -558,12 +282,14 @@ namespace psv_func_detail
// TODO: check calculations
static const bool is_float = std::is_floating_point<T>::value;
static const bool is_vector = std::is_same<T, u128>::value;
static const int g_align = __alignof(T) > 4 ? __alignof(T) >> 2 : 1;
static const int g_pos = (is_float || is_vector) ? g_count : ((g_count + (g_align - 1)) & ~(g_align - 1)) + 1;
static const int g_next = g_pos + g_align - 1;
static const int f_value = !is_float ? f_count : f_count + 1;
static const int v_value = !is_vector ? v_count : v_count + 1;
static const bind_arg_type value = is_float
? ((f_count >= 4) ? ARG_STACK : ARG_FLOAT)
: (is_vector ? ((v_count >= 4) ? ARG_STACK : ARG_VECTOR) : ((g_count >= 4) ? ARG_STACK : ARG_GENERAL));
static const int g_value = g_count + (is_float || is_vector ? 0 : 1);
static const int f_value = f_count + (is_float ? 1 : 0);
static const int v_value = v_count + (is_vector ? 1 : 0);
? ((f_value > 9000) ? ARG_STACK : ARG_FLOAT)
: (is_vector ? ((v_value > 9000) ? ARG_STACK : ARG_VECTOR) : ((g_pos > 4) ? ARG_STACK : ARG_GENERAL));
};
template <typename RT, typename F, typename Tuple, bool Done, int Total, int... N>
@ -603,11 +329,12 @@ namespace psv_func_detail
{
typedef arg_type<T, g_count, f_count, v_count> type;
const bind_arg_type t = type::value;
const int g = type::g_value;
const int g0 = type::g_pos;
const int g1 = type::g_next;
const int f = type::f_value;
const int v = type::v_value;
return std::tuple_cat(std::tuple<T>(bind_arg<T, t, g, f, v>::get_arg(context)), get_func_args<g, f, v, A...>(context));
return std::tuple_cat(std::tuple<T>(bind_arg<T, t, g0, f, v>::get_arg(context)), get_func_args<g1, f, v, A...>(context));
}
template<int g_count, int f_count, int v_count>
@ -622,14 +349,15 @@ namespace psv_func_detail
{
typedef arg_type<T1, g_count, f_count, v_count> type;
const bind_arg_type t = type::value;
const int g = type::g_value;
const int g0 = type::g_pos;
const int g1 = type::g_next;
const int f = type::f_value;
const int v = type::v_value;
bind_arg<T1, t, g, f, v>::put_arg(context, arg);
bind_arg<T1, t, g0, f, v>::put_arg(context, arg);
// return true if stack was used
return put_func_args<g, f, v>(context, args...) || (t == ARG_STACK);
return put_func_args<g1, f, v>(context, args...) || (t == ARG_STACK);
}
template<typename RT, typename... T>
@ -741,18 +469,19 @@ namespace psv_func_detail
};
}
// Basic information about the HLE function
struct psv_func
{
u32 nid;
const char* name;
std::shared_ptr<psv_func_caller> func;
psv_log_base* module;
u32 nid; // Unique function ID only for old PSV executables (should be generated individually for each elf loaded)
const char* name; // Function name for information
std::shared_ptr<psv_func_caller> func; // Function caller instance
psv_log_base* module; // Module for information
};
// Do not call directly
void add_psv_func(psv_func& data);
template<typename RT, typename... T>
void reg_psv_func(u32 nid, psv_log_base* module, const char* name, RT(*func)(T...))
// Do not call directly
template<typename RT, typename... T> void reg_psv_func(u32 nid, psv_log_base* module, const char* name, RT(*func)(T...))
{
psv_func f;
f.nid = nid;
@ -762,10 +491,159 @@ void reg_psv_func(u32 nid, psv_log_base* module, const char* name, RT(*func)(T..
add_psv_func(f);
}
// Find registered HLE function by its ID
psv_func* get_psv_func_by_nid(u32 nid);
// Get index of registered HLE function
u32 get_psv_func_index(psv_func* func);
// Execute registered HLE function by its index
void execute_psv_func_by_index(ARMv7Context& context, u32 index);
// Register all HLE functions
void initialize_psv_modules();
// Unregister all HLE functions
void finalize_psv_modules();
// General definitions
enum psv_error_codes
{
SCE_OK = 0,
SCE_ERROR_ERRNO_EPERM = 0x80010001,
SCE_ERROR_ERRNO_ENOENT = 0x80010002,
SCE_ERROR_ERRNO_ESRCH = 0x80010003,
SCE_ERROR_ERRNO_EINTR = 0x80010004,
SCE_ERROR_ERRNO_EIO = 0x80010005,
SCE_ERROR_ERRNO_ENXIO = 0x80010006,
SCE_ERROR_ERRNO_E2BIG = 0x80010007,
SCE_ERROR_ERRNO_ENOEXEC = 0x80010008,
SCE_ERROR_ERRNO_EBADF = 0x80010009,
SCE_ERROR_ERRNO_ECHILD = 0x8001000A,
SCE_ERROR_ERRNO_EAGAIN = 0x8001000B,
SCE_ERROR_ERRNO_ENOMEM = 0x8001000C,
SCE_ERROR_ERRNO_EACCES = 0x8001000D,
SCE_ERROR_ERRNO_EFAULT = 0x8001000E,
SCE_ERROR_ERRNO_ENOTBLK = 0x8001000F,
SCE_ERROR_ERRNO_EBUSY = 0x80010010,
SCE_ERROR_ERRNO_EEXIST = 0x80010011,
SCE_ERROR_ERRNO_EXDEV = 0x80010012,
SCE_ERROR_ERRNO_ENODEV = 0x80010013,
SCE_ERROR_ERRNO_ENOTDIR = 0x80010014,
SCE_ERROR_ERRNO_EISDIR = 0x80010015,
SCE_ERROR_ERRNO_EINVAL = 0x80010016,
SCE_ERROR_ERRNO_ENFILE = 0x80010017,
SCE_ERROR_ERRNO_EMFILE = 0x80010018,
SCE_ERROR_ERRNO_ENOTTY = 0x80010019,
SCE_ERROR_ERRNO_ETXTBSY = 0x8001001A,
SCE_ERROR_ERRNO_EFBIG = 0x8001001B,
SCE_ERROR_ERRNO_ENOSPC = 0x8001001C,
SCE_ERROR_ERRNO_ESPIPE = 0x8001001D,
SCE_ERROR_ERRNO_EROFS = 0x8001001E,
SCE_ERROR_ERRNO_EMLINK = 0x8001001F,
SCE_ERROR_ERRNO_EPIPE = 0x80010020,
SCE_ERROR_ERRNO_EDOM = 0x80010021,
SCE_ERROR_ERRNO_ERANGE = 0x80010022,
SCE_ERROR_ERRNO_ENOMSG = 0x80010023,
SCE_ERROR_ERRNO_EIDRM = 0x80010024,
SCE_ERROR_ERRNO_ECHRNG = 0x80010025,
SCE_ERROR_ERRNO_EL2NSYNC = 0x80010026,
SCE_ERROR_ERRNO_EL3HLT = 0x80010027,
SCE_ERROR_ERRNO_EL3RST = 0x80010028,
SCE_ERROR_ERRNO_ELNRNG = 0x80010029,
SCE_ERROR_ERRNO_EUNATCH = 0x8001002A,
SCE_ERROR_ERRNO_ENOCSI = 0x8001002B,
SCE_ERROR_ERRNO_EL2HLT = 0x8001002C,
SCE_ERROR_ERRNO_EDEADLK = 0x8001002D,
SCE_ERROR_ERRNO_ENOLCK = 0x8001002E,
SCE_ERROR_ERRNO_EFORMAT = 0x8001002F,
SCE_ERROR_ERRNO_EUNSUP = 0x80010030,
SCE_ERROR_ERRNO_EBADE = 0x80010032,
SCE_ERROR_ERRNO_EBADR = 0x80010033,
SCE_ERROR_ERRNO_EXFULL = 0x80010034,
SCE_ERROR_ERRNO_ENOANO = 0x80010035,
SCE_ERROR_ERRNO_EBADRQC = 0x80010036,
SCE_ERROR_ERRNO_EBADSLT = 0x80010037,
SCE_ERROR_ERRNO_EDEADLOCK = 0x80010038,
SCE_ERROR_ERRNO_EBFONT = 0x80010039,
SCE_ERROR_ERRNO_ENOSTR = 0x8001003C,
SCE_ERROR_ERRNO_ENODATA = 0x8001003D,
SCE_ERROR_ERRNO_ETIME = 0x8001003E,
SCE_ERROR_ERRNO_ENOSR = 0x8001003F,
SCE_ERROR_ERRNO_ENONET = 0x80010040,
SCE_ERROR_ERRNO_ENOPKG = 0x80010041,
SCE_ERROR_ERRNO_EREMOTE = 0x80010042,
SCE_ERROR_ERRNO_ENOLINK = 0x80010043,
SCE_ERROR_ERRNO_EADV = 0x80010044,
SCE_ERROR_ERRNO_ESRMNT = 0x80010045,
SCE_ERROR_ERRNO_ECOMM = 0x80010046,
SCE_ERROR_ERRNO_EPROTO = 0x80010047,
SCE_ERROR_ERRNO_EMULTIHOP = 0x8001004A,
SCE_ERROR_ERRNO_ELBIN = 0x8001004B,
SCE_ERROR_ERRNO_EDOTDOT = 0x8001004C,
SCE_ERROR_ERRNO_EBADMSG = 0x8001004D,
SCE_ERROR_ERRNO_EFTYPE = 0x8001004F,
SCE_ERROR_ERRNO_ENOTUNIQ = 0x80010050,
SCE_ERROR_ERRNO_EBADFD = 0x80010051,
SCE_ERROR_ERRNO_EREMCHG = 0x80010052,
SCE_ERROR_ERRNO_ELIBACC = 0x80010053,
SCE_ERROR_ERRNO_ELIBBAD = 0x80010054,
SCE_ERROR_ERRNO_ELIBSCN = 0x80010055,
SCE_ERROR_ERRNO_ELIBMAX = 0x80010056,
SCE_ERROR_ERRNO_ELIBEXEC = 0x80010057,
SCE_ERROR_ERRNO_ENOSYS = 0x80010058,
SCE_ERROR_ERRNO_ENMFILE = 0x80010059,
SCE_ERROR_ERRNO_ENOTEMPTY = 0x8001005A,
SCE_ERROR_ERRNO_ENAMETOOLONG = 0x8001005B,
SCE_ERROR_ERRNO_ELOOP = 0x8001005C,
SCE_ERROR_ERRNO_EOPNOTSUPP = 0x8001005F,
SCE_ERROR_ERRNO_EPFNOSUPPORT = 0x80010060,
SCE_ERROR_ERRNO_ECONNRESET = 0x80010068,
SCE_ERROR_ERRNO_ENOBUFS = 0x80010069,
SCE_ERROR_ERRNO_EAFNOSUPPORT = 0x8001006A,
SCE_ERROR_ERRNO_EPROTOTYPE = 0x8001006B,
SCE_ERROR_ERRNO_ENOTSOCK = 0x8001006C,
SCE_ERROR_ERRNO_ENOPROTOOPT = 0x8001006D,
SCE_ERROR_ERRNO_ESHUTDOWN = 0x8001006E,
SCE_ERROR_ERRNO_ECONNREFUSED = 0x8001006F,
SCE_ERROR_ERRNO_EADDRINUSE = 0x80010070,
SCE_ERROR_ERRNO_ECONNABORTED = 0x80010071,
SCE_ERROR_ERRNO_ENETUNREACH = 0x80010072,
SCE_ERROR_ERRNO_ENETDOWN = 0x80010073,
SCE_ERROR_ERRNO_ETIMEDOUT = 0x80010074,
SCE_ERROR_ERRNO_EHOSTDOWN = 0x80010075,
SCE_ERROR_ERRNO_EHOSTUNREACH = 0x80010076,
SCE_ERROR_ERRNO_EINPROGRESS = 0x80010077,
SCE_ERROR_ERRNO_EALREADY = 0x80010078,
SCE_ERROR_ERRNO_EDESTADDRREQ = 0x80010079,
SCE_ERROR_ERRNO_EMSGSIZE = 0x8001007A,
SCE_ERROR_ERRNO_EPROTONOSUPPORT = 0x8001007B,
SCE_ERROR_ERRNO_ESOCKTNOSUPPORT = 0x8001007C,
SCE_ERROR_ERRNO_EADDRNOTAVAIL = 0x8001007D,
SCE_ERROR_ERRNO_ENETRESET = 0x8001007E,
SCE_ERROR_ERRNO_EISCONN = 0x8001007F,
SCE_ERROR_ERRNO_ENOTCONN = 0x80010080,
SCE_ERROR_ERRNO_ETOOMANYREFS = 0x80010081,
SCE_ERROR_ERRNO_EPROCLIM = 0x80010082,
SCE_ERROR_ERRNO_EUSERS = 0x80010083,
SCE_ERROR_ERRNO_EDQUOT = 0x80010084,
SCE_ERROR_ERRNO_ESTALE = 0x80010085,
SCE_ERROR_ERRNO_ENOTSUP = 0x80010086,
SCE_ERROR_ERRNO_ENOMEDIUM = 0x80010087,
SCE_ERROR_ERRNO_ENOSHARE = 0x80010088,
SCE_ERROR_ERRNO_ECASECLASH = 0x80010089,
SCE_ERROR_ERRNO_EILSEQ = 0x8001008A,
SCE_ERROR_ERRNO_EOVERFLOW = 0x8001008B,
SCE_ERROR_ERRNO_ECANCELED = 0x8001008C,
SCE_ERROR_ERRNO_ENOTRECOVERABLE = 0x8001008D,
SCE_ERROR_ERRNO_EOWNERDEAD = 0x8001008E,
};
struct SceDateTime
{
u16 year;
u16 month;
u16 day;
u16 hour;
u16 minute;
u16 second;
u32 microsecond;
};

4
rpcs3/Emu/Audio/XAudio2/XAudio2Thread.cpp
View File

@ -15,7 +15,7 @@ void XAudio2Thread::Init()
{
HRESULT hr = S_OK;
#if (_WIN32_WINNT < 0x0602)
#if (FORCED_WINVER < 0x0602)
hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
if (FAILED(hr))
{
@ -53,7 +53,7 @@ void XAudio2Thread::Quit()
m_xaudio2_instance->Release();
m_xaudio2_instance = nullptr;
#if (_WIN32_WINNT < 0x0602)
#if (FORCED_WINVER < 0x0602)
CoUninitialize();
#endif
}

5
rpcs3/Emu/Audio/XAudio2/XAudio2Thread.h
View File

@ -4,10 +4,9 @@
#if defined (_WIN32)
// forced define Win7, delete this for using XAudio2 2.8
#define WINVER 0x0601
#define _WIN32_WINNT 0x0601
#define FORCED_WINVER 0x0601
#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
#if (FORCED_WINVER >= 0x0602 /*_WIN32_WINNT_WIN8*/)
#include <xaudio2.h>
#pragma comment(lib,"xaudio2.lib")
#else

1
rpcs3/Emu/CPU/CPUDecoder.h
View File

@ -1,6 +1,5 @@
#pragma once
#include "CPUInstrTable.h"
#pragma warning( disable : 4800 )
class CPUDecoder
{

13
rpcs3/Emu/CPU/CPUThreadManager.cpp
View File

@ -117,6 +117,19 @@ std::shared_ptr<CPUThread> CPUThreadManager::GetThread(u32 id)
return res;
}
std::shared_ptr<CPUThread> CPUThreadManager::GetThread(u32 id, CPUThreadType type)
{
std::shared_ptr<CPUThread> res;
if (!id) return nullptr;
if (!Emu.GetIdManager().GetIDData(id, res)) return nullptr;
if (res->GetType() != type) return nullptr;
return res;
}
RawSPUThread* CPUThreadManager::GetRawSPUThread(u32 num)
{
if (num < sizeof(Memory.RawSPUMem) / sizeof(Memory.RawSPUMem[0]))

1
rpcs3/Emu/CPU/CPUThreadManager.h
View File

@ -21,6 +21,7 @@ public:
//std::vector<std::shared_ptr<CPUThread>>& GetThreads() { return m_threads; }
s32 GetThreadNumById(CPUThreadType type, u32 id);
std::shared_ptr<CPUThread> GetThread(u32 id);
std::shared_ptr<CPUThread> GetThread(u32 id, CPUThreadType type);
RawSPUThread* GetRawSPUThread(u32 num);
void Exec();

4
rpcs3/Emu/FS/VFS.cpp
View File

@ -325,7 +325,7 @@ vfsDevice* VFS::GetDevice(const std::string& ps3_path, std::string& path) const
path = m_devices[max_i]->GetLocalPath();
for (u32 i = max_eq; i < ps3_path_blocks.size(); i++)
for (size_t i = max_eq; i < ps3_path_blocks.size(); i++)
{
path += "/" + ps3_path_blocks[i];
}
@ -382,7 +382,7 @@ vfsDevice* VFS::GetDeviceLocal(const std::string& local_path, std::string& path)
path = m_devices[max_i]->GetPs3Path();
for (u32 i = max_eq; i < local_path_blocks.size(); i++)
for (size_t i = max_eq; i < local_path_blocks.size(); i++)
{
path += "/" + local_path_blocks[i];
}

20
rpcs3/Emu/FS/vfsStreamMemory.cpp
View File

@ -6,15 +6,15 @@ vfsStreamMemory::vfsStreamMemory() : vfsStream()
{
}
vfsStreamMemory::vfsStreamMemory(u64 addr, u64 size) : vfsStream()
vfsStreamMemory::vfsStreamMemory(u32 addr, u32 size) : vfsStream()
{
Open(addr, size);
}
void vfsStreamMemory::Open(u64 addr, u64 size)
void vfsStreamMemory::Open(u32 addr, u32 size)
{
m_addr = addr;
m_size = size ? size : ~0ULL;
m_size = size ? size : 0x100000000ull - addr; // determine max possible size
vfsStream::Reset();
}
@ -26,24 +26,24 @@ u64 vfsStreamMemory::GetSize()
u64 vfsStreamMemory::Write(const void* src, u64 size)
{
if(Tell() + size > GetSize())
assert(Tell() < m_size);
if (Tell() + size > m_size)
{
size = GetSize() - Tell();
size = m_size - Tell();
}
memcpy(vm::get_ptr<void>(m_addr + Tell()), src, size);
memcpy(vm::get_ptr<void>(vm::cast(m_addr + Tell())), src, size);
return vfsStream::Write(src, size);
}
u64 vfsStreamMemory::Read(void* dst, u64 size)
{
if(Tell() + size > GetSize())
assert(Tell() < GetSize());
if (Tell() + size > GetSize())
{
size = GetSize() - Tell();
}
memcpy(dst, vm::get_ptr<void>(m_addr + Tell()), size);
memcpy(dst, vm::get_ptr<void>(vm::cast(m_addr + Tell())), size);
return vfsStream::Read(dst, size);
}

6
rpcs3/Emu/FS/vfsStreamMemory.h
View File

@ -3,14 +3,14 @@
struct vfsStreamMemory : public vfsStream
{
u64 m_addr;
u32 m_addr;
u64 m_size;
public:
vfsStreamMemory();
vfsStreamMemory(u64 addr, u64 size = 0);
vfsStreamMemory(u32 addr, u32 size = 0);
void Open(u64 addr, u64 size = 0);
void Open(u32 addr, u32 size = 0);
virtual u64 GetSize() override;

1
rpcs3/emucore.vcxproj
View File

@ -274,6 +274,7 @@
<ClInclude Include="Emu\ARMv7\ARMv7Interpreter.h" />
<ClInclude Include="Emu\ARMv7\ARMv7Opcodes.h" />
<ClInclude Include="Emu\ARMv7\ARMv7Thread.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
<ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
<ClInclude Include="Emu\Audio\AL\OpenALThread.h" />
<ClInclude Include="Emu\Audio\AudioDumper.h" />

3
rpcs3/emucore.vcxproj.filters
View File

@ -1291,5 +1291,8 @@
<ClInclude Include="Emu\ARMv7\ARMv7Callback.h">
<Filter>Emu\CPU\ARMv7</Filter>
</ClInclude>
<ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h">
<Filter>Emu\CPU\ARMv7\Modules</Filter>
</ClInclude>
</ItemGroup>
</Project>

2
rpcs3/stdafx.h
View File

@ -14,6 +14,8 @@
#endif
// This header should be frontend-agnostic, so don't assume wx includes everything
#pragma warning( disable : 4800 )
#include <cstdio>
#include <cstring>
#include <cassert>