ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #855 from Nekotekina/master 

Various progress
This commit is contained in:
B1ackDaemon 2014-11-06 20:39:31 +02:00
parent a4e5751cff 0503f08f67
commit 2fb0911e2a
53 changed files with 10359 additions and 843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Utilities/Log.h
View File

@ -24,6 +24,7 @@ namespace Log
HLE,
PPU,
SPU,
ARMv7,
TTY,
};
@ -35,7 +36,7 @@ namespace Log
};
//well I'd love make_array() but alas manually counting is not the end of the world
static const std::array<LogTypeName, 8> gTypeNameTable = { {
static const std::array<LogTypeName, 9> gTypeNameTable = { {
{ GENERAL, "G: " },
{ LOADER, "LDR: " },
{ MEMORY, "MEM: " },
@ -43,6 +44,7 @@ namespace Log
{ HLE, "HLE: " },
{ PPU, "PPU: " },
{ SPU, "SPU: " },
{ ARMv7, "ARM: " },
{ TTY, "TTY: " }
} };
@ -121,6 +123,7 @@ static struct { inline operator Log::LogType() { return Log::LogType::RSX; } } R
static struct { inline operator Log::LogType() { return Log::LogType::HLE; } } HLE;
static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU;
static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU;
static struct { inline operator Log::LogType() { return Log::LogType::ARMv7; } } ARMv7;
static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY;
inline void log_message(Log::LogType type, Log::LogSeverity sev, const char* text)

6
Utilities/SQueue.h
View File

@ -28,7 +28,7 @@ public:
{
if (m_count >= SQSize)
{
if (Emu.IsStopped() || do_exit && *do_exit)
if (Emu.IsStopped() || (do_exit && *do_exit))
{
return false;
}
@ -55,7 +55,7 @@ public:
{
if (!m_count)
{
if (Emu.IsStopped() || do_exit && *do_exit)
if (Emu.IsStopped() || (do_exit && *do_exit))
{
return false;
}
@ -90,7 +90,7 @@ public:
{
if (m_count <= pos)
{
if (Emu.IsStopped() || do_exit && *do_exit)
if (Emu.IsStopped() || (do_exit && *do_exit))
{
return false;
}

30
Utilities/rFile.cpp
View File

@ -21,6 +21,12 @@ std::wstring ConvertUTF8ToWString(const std::string &source) {
}
#endif
#ifdef _WIN32
#define GET_API_ERROR GetLastError()
#else
#define GET_API_ERROR err
#endif
bool getFileInfo(const char *path, FileInfo *fileInfo) {
// TODO: Expand relative paths?
fileInfo->fullName = path;
@ -103,14 +109,15 @@ bool rMkpath(const std::string &path)
bool rRmdir(const std::string &dir)
{
#ifdef _WIN32
if (!RemoveDirectory(ConvertUTF8ToWString(dir).c_str())) {
LOG_ERROR(GENERAL, "Error deleting directory %s: %i", dir.c_str(), GetLastError());
if (!RemoveDirectory(ConvertUTF8ToWString(dir).c_str()))
#else
if (int err = rmdir(dir.c_str()))
#endif
{
LOG_ERROR(GENERAL, "Error deleting directory %s: %i", dir.c_str(), GET_API_ERROR);
return false;
}
return true;
#else
rmdir(dir.c_str());
#endif
}
bool rRename(const std::string &from, const std::string &to)
@ -137,17 +144,14 @@ bool rExists(const std::string &file)
bool rRemoveFile(const std::string &file)
{
#ifdef _WIN32
if (!DeleteFile(ConvertUTF8ToWString(file).c_str())) {
LOG_ERROR(GENERAL, "Error deleting %s: %i", file.c_str(), GetLastError());
return false;
}
if (!DeleteFile(ConvertUTF8ToWString(file).c_str()))
#else
int err = unlink(file.c_str());
if (err) {
LOG_ERROR(GENERAL, "Error unlinking %s: %i", file.c_str(), err);
if (int err = unlink(file.c_str()))
#endif
{
LOG_ERROR(GENERAL, "Error deleting %s: %i", file.c_str(), GET_API_ERROR);
return false;
}
#endif
return true;
}

6
rpcs3.sln
View File

@ -1,5 +1,5 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Express 2013 for Windows Desktop
# Visual Studio 2013
VisualStudioVersion = 12.0.30723.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rpcs3", "rpcs3\rpcs3.vcxproj", "{70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12}"
@ -21,6 +21,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "rpcs3", "rpcs3\rpcs3.vcxpro
{7047EE97-7F80-A70D-6147-BC11102DB6F4} = {7047EE97-7F80-A70D-6147-BC11102DB6F4}
{87B42A9C-3F5C-53D7-9017-2B1CAE39457D} = {87B42A9C-3F5C-53D7-9017-2B1CAE39457D}
{6FCB55A5-563F-4039-1D79-1EB6ED8AAB82} = {6FCB55A5-563F-4039-1D79-1EB6ED8AAB82}
{8BC303AB-25BE-4276-8E57-73F171B2D672} = {8BC303AB-25BE-4276-8E57-73F171B2D672}
{949C6DB8-E638-6EC6-AB31-BCCFD1379E01} = {949C6DB8-E638-6EC6-AB31-BCCFD1379E01}
{74827EBD-93DC-5110-BA95-3F2AB029B6B0} = {74827EBD-93DC-5110-BA95-3F2AB029B6B0}
{46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2} = {46333DC3-B4A5-3DCC-E8BF-A3F20ADC56D2}
@ -138,9 +139,6 @@ EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "asmjit", "asmjit", "{E2A982F2-4B1A-48B1-8D77-A17A589C58D7}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "emucore", "rpcs3\emucore.vcxproj", "{C4A10229-4712-4BD2-B63E-50D93C67A038}"
ProjectSection(ProjectDependencies) = postProject
{8BC303AB-25BE-4276-8E57-73F171B2D672} = {8BC303AB-25BE-4276-8E57-73F171B2D672}
EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "llvm", "llvm", "{C8068CE9-D626-4FEA-BEE7-893F06A25BF3}"
EndProject

122
rpcs3/Emu/ARMv7/ARMv7Decoder.h
View File

@ -13,125 +13,23 @@ public:
{
}
u32 branchTarget(u32 imm)
{
return imm << 1;
}
virtual u8 DecodeMemory(const u32 address)
{
using namespace ARMv7_opcodes;
const u16 code0 = vm::psv::read16(address);
const u16 code1 = vm::psv::read16(address + 2);
const u32 code0 = vm::psv::read16(address & ~1);
const u32 code1 = vm::psv::read16(address + 2 & ~1);
const u32 data = code0 << 16 | code1;
const u32 arg = address & 1 ? code1 << 16 | code0 : data;
switch(code0 >> 12) //15 - 12
for (auto& opcode : ARMv7_opcode_table)
{
case T1_CBZ:
switch((code0 >> 10) & 0x1)
if ((opcode.type < A1) == ((address & 1) == 0) && (arg & opcode.mask) == opcode.code)
{
case 0:
switch((code0 >> 8) & 0x1)
{
case 1:
m_op.CBZ((code0 >> 11) & 0x1, branchTarget((((code0 >> 9) & 0x1) << 5) | ((code0 >> 3) & 0x1f)), code0 & 0x7, 2);
return 2;
}
break;
}
break;
case T1_B:
m_op.B((code0 >> 8) & 0xf, branchTarget(code0 & 0xff), 2);
return 2;
}
switch(code0 >> 11) //15 - 11
{
case T2_B:
m_op.B(0xf, branchTarget(code0 & 0xfff), 2);
return 2;
case T3_B:
{
u8 S = (code0 >> 10) & 0x1;
u8 J1 = (code1 >> 13) & 0x1;
u8 J2 = (code1 >> 11) & 0x1;
u8 I1 = 1 - (J1 ^ S);
u8 I2 = 1 - (J2 ^ S);
u16 imm11 = code1 & 0x7ff;
u32 imm32 = 0;
switch(code1 >> 14)
{
case 2: //B
{
u8 cond;
switch((code1 >> 12) & 0x1)
{
case 0:
{
cond = (code0 >> 6) & 0xf;
u32 imm6 = code0 & 0x3f;
imm32 = sign<19, u32>((S << 19) | (I1 << 18) | (I2 << 17) | (imm6 << 11) | imm11);
}
break;
case 1:
cond = 0xf;
u32 imm10 = code0 & 0x7ff;
imm32 = sign<23, u32>((S << 23) | (I1 << 22) | (I2 << 21) | (imm10 << 11) | imm11);
break;
}
m_op.B(cond, branchTarget(imm32), 4);
}
return 4;
case 3: //BL
switch((code1 >> 12) & 0x1)
{
case 0:
break;
case 1:
u32 imm10 = code0 & 0x7ff;
imm32 = sign<23, u32>((S << 23) | (I1 << 22) | (I2 << 21) | (imm10 << 11) | imm11);
m_op.BL(branchTarget(imm32), 4);
return 4;
}
break;
(m_op.*opcode.func)(opcode.length == 2 ? code0 : arg, opcode.type);
return opcode.length;
}
}
break;
}
switch(code0 >> 9)
{
case T1_PUSH:
m_op.PUSH((((code0 >> 8) & 0x1) << 14) | (code0 & 0xff));
return 2;
case T1_POP:
m_op.POP((((code0 >> 8) & 0x1) << 15) | (code0 & 0xff));
return 2;
}
switch(code0)
{
case T2_PUSH:
m_op.PUSH(code1);
return 4;
case T2_POP:
m_op.POP(code1);
return 4;
case T1_NOP:
m_op.NOP();
return 2;
}
m_op.UNK(code0, code1);
return 2;
m_op.UNK(data);
return address & 1 ? 4 : 2;
}
};

1122
rpcs3/Emu/ARMv7/ARMv7DisAsm.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

304
rpcs3/Emu/ARMv7/ARMv7DisAsm.h
View File

@ -45,50 +45,276 @@ protected:
return regs_str;
}
void NULL_OP()
{
Write("null");
}
virtual void UNK(const u32 data);
void PUSH(u16 regs_list)
{
Write(fmt::Format("push {%s}", GetRegsListString(regs_list).c_str()));
}
virtual void NULL_OP(const u32 data, const ARMv7_encoding type);
void POP(u16 regs_list)
{
Write(fmt::Format("pop {%s}", GetRegsListString(regs_list).c_str()));
}
virtual void HACK(const u32 data, const ARMv7_encoding type);
void NOP()
{
Write("nop");
}
virtual void ADC_IMM(const u32 data, const ARMv7_encoding type);
virtual void ADC_REG(const u32 data, const ARMv7_encoding type);
virtual void ADC_RSR(const u32 data, const ARMv7_encoding type);
void B(u8 cond, u32 imm, u8 intstr_size)
{
if((cond & 0xe) == 0xe)
{
Write(fmt::Format("b 0x%x", DisAsmBranchTarget(imm) + intstr_size));
}
else
{
Write(fmt::Format("b[%s] 0x%x", g_arm_cond_name[cond], DisAsmBranchTarget(imm) + intstr_size));
}
}
virtual void ADD_IMM(const u32 data, const ARMv7_encoding type);
virtual void ADD_REG(const u32 data, const ARMv7_encoding type);
virtual void ADD_RSR(const u32 data, const ARMv7_encoding type);
virtual void ADD_SPI(const u32 data, const ARMv7_encoding type);
virtual void ADD_SPR(const u32 data, const ARMv7_encoding type);
virtual void CBZ(u8 op, u32 imm, u8 rn, u8 intstr_size)
{
Write(fmt::Format("cb%sz 0x%x,%s", (op ? "n" : ""), DisAsmBranchTarget(imm) + intstr_size, g_arm_reg_name[rn]));
}
virtual void ADR(const u32 data, const ARMv7_encoding type);
void BL(u32 imm, u8 intstr_size)
{
Write(fmt::Format("bl 0x%x", DisAsmBranchTarget(imm) + intstr_size));
}
virtual void AND_IMM(const u32 data, const ARMv7_encoding type);
virtual void AND_REG(const u32 data, const ARMv7_encoding type);
virtual void AND_RSR(const u32 data, const ARMv7_encoding type);
void UNK(const u16 code0, const u16 code1)
{
Write(fmt::Format("Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1));
}
virtual void ASR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ASR_REG(const u32 data, const ARMv7_encoding type);
virtual void B(const u32 data, const ARMv7_encoding type);
virtual void BFC(const u32 data, const ARMv7_encoding type);
virtual void BFI(const u32 data, const ARMv7_encoding type);
virtual void BIC_IMM(const u32 data, const ARMv7_encoding type);
virtual void BIC_REG(const u32 data, const ARMv7_encoding type);
virtual void BIC_RSR(const u32 data, const ARMv7_encoding type);
virtual void BKPT(const u32 data, const ARMv7_encoding type);
virtual void BL(const u32 data, const ARMv7_encoding type);
virtual void BLX(const u32 data, const ARMv7_encoding type);
virtual void BX(const u32 data, const ARMv7_encoding type);
virtual void CB_Z(const u32 data, const ARMv7_encoding type);
virtual void CLZ(const u32 data, const ARMv7_encoding type);
virtual void CMN_IMM(const u32 data, const ARMv7_encoding type);
virtual void CMN_REG(const u32 data, const ARMv7_encoding type);
virtual void CMN_RSR(const u32 data, const ARMv7_encoding type);
virtual void CMP_IMM(const u32 data, const ARMv7_encoding type);
virtual void CMP_REG(const u32 data, const ARMv7_encoding type);
virtual void CMP_RSR(const u32 data, const ARMv7_encoding type);
virtual void EOR_IMM(const u32 data, const ARMv7_encoding type);
virtual void EOR_REG(const u32 data, const ARMv7_encoding type);
virtual void EOR_RSR(const u32 data, const ARMv7_encoding type);
virtual void IT(const u32 data, const ARMv7_encoding type);
virtual void LDM(const u32 data, const ARMv7_encoding type);
virtual void LDMDA(const u32 data, const ARMv7_encoding type);
virtual void LDMDB(const u32 data, const ARMv7_encoding type);
virtual void LDMIB(const u32 data, const ARMv7_encoding type);
virtual void LDR_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDR_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDR_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRB_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRB_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRB_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRD_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRD_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRD_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRH_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRH_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRH_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_REG(const u32 data, const ARMv7_encoding type);
virtual void LSL_IMM(const u32 data, const ARMv7_encoding type);
virtual void LSL_REG(const u32 data, const ARMv7_encoding type);
virtual void LSR_IMM(const u32 data, const ARMv7_encoding type);
virtual void LSR_REG(const u32 data, const ARMv7_encoding type);
virtual void MLA(const u32 data, const ARMv7_encoding type);
virtual void MLS(const u32 data, const ARMv7_encoding type);
virtual void MOV_IMM(const u32 data, const ARMv7_encoding type);
virtual void MOV_REG(const u32 data, const ARMv7_encoding type);
virtual void MOVT(const u32 data, const ARMv7_encoding type);
virtual void MRS(const u32 data, const ARMv7_encoding type);
virtual void MSR_IMM(const u32 data, const ARMv7_encoding type);
virtual void MSR_REG(const u32 data, const ARMv7_encoding type);
virtual void MUL(const u32 data, const ARMv7_encoding type);
virtual void MVN_IMM(const u32 data, const ARMv7_encoding type);
virtual void MVN_REG(const u32 data, const ARMv7_encoding type);
virtual void MVN_RSR(const u32 data, const ARMv7_encoding type);
virtual void NOP(const u32 data, const ARMv7_encoding type);
virtual void ORN_IMM(const u32 data, const ARMv7_encoding type);
virtual void ORN_REG(const u32 data, const ARMv7_encoding type);
virtual void ORR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ORR_REG(const u32 data, const ARMv7_encoding type);
virtual void ORR_RSR(const u32 data, const ARMv7_encoding type);
virtual void PKH(const u32 data, const ARMv7_encoding type);
virtual void POP(const u32 data, const ARMv7_encoding type);
virtual void PUSH(const u32 data, const ARMv7_encoding type);
virtual void QADD(const u32 data, const ARMv7_encoding type);
virtual void QADD16(const u32 data, const ARMv7_encoding type);
virtual void QADD8(const u32 data, const ARMv7_encoding type);
virtual void QASX(const u32 data, const ARMv7_encoding type);
virtual void QDADD(const u32 data, const ARMv7_encoding type);
virtual void QDSUB(const u32 data, const ARMv7_encoding type);
virtual void QSAX(const u32 data, const ARMv7_encoding type);
virtual void QSUB(const u32 data, const ARMv7_encoding type);
virtual void QSUB16(const u32 data, const ARMv7_encoding type);
virtual void QSUB8(const u32 data, const ARMv7_encoding type);
virtual void RBIT(const u32 data, const ARMv7_encoding type);
virtual void REV(const u32 data, const ARMv7_encoding type);
virtual void REV16(const u32 data, const ARMv7_encoding type);
virtual void REVSH(const u32 data, const ARMv7_encoding type);
virtual void ROR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ROR_REG(const u32 data, const ARMv7_encoding type);
virtual void RRX(const u32 data, const ARMv7_encoding type);
virtual void RSB_IMM(const u32 data, const ARMv7_encoding type);
virtual void RSB_REG(const u32 data, const ARMv7_encoding type);
virtual void RSB_RSR(const u32 data, const ARMv7_encoding type);
virtual void RSC_IMM(const u32 data, const ARMv7_encoding type);
virtual void RSC_REG(const u32 data, const ARMv7_encoding type);
virtual void RSC_RSR(const u32 data, const ARMv7_encoding type);
virtual void SADD16(const u32 data, const ARMv7_encoding type);
virtual void SADD8(const u32 data, const ARMv7_encoding type);
virtual void SASX(const u32 data, const ARMv7_encoding type);
virtual void SBC_IMM(const u32 data, const ARMv7_encoding type);
virtual void SBC_REG(const u32 data, const ARMv7_encoding type);
virtual void SBC_RSR(const u32 data, const ARMv7_encoding type);
virtual void SBFX(const u32 data, const ARMv7_encoding type);
virtual void SDIV(const u32 data, const ARMv7_encoding type);
virtual void SEL(const u32 data, const ARMv7_encoding type);
virtual void SHADD16(const u32 data, const ARMv7_encoding type);
virtual void SHADD8(const u32 data, const ARMv7_encoding type);
virtual void SHASX(const u32 data, const ARMv7_encoding type);
virtual void SHSAX(const u32 data, const ARMv7_encoding type);
virtual void SHSUB16(const u32 data, const ARMv7_encoding type);
virtual void SHSUB8(const u32 data, const ARMv7_encoding type);
virtual void SMLA__(const u32 data, const ARMv7_encoding type);
virtual void SMLAD(const u32 data, const ARMv7_encoding type);
virtual void SMLAL(const u32 data, const ARMv7_encoding type);
virtual void SMLAL__(const u32 data, const ARMv7_encoding type);
virtual void SMLALD(const u32 data, const ARMv7_encoding type);
virtual void SMLAW_(const u32 data, const ARMv7_encoding type);
virtual void SMLSD(const u32 data, const ARMv7_encoding type);
virtual void SMLSLD(const u32 data, const ARMv7_encoding type);
virtual void SMMLA(const u32 data, const ARMv7_encoding type);
virtual void SMMLS(const u32 data, const ARMv7_encoding type);
virtual void SMMUL(const u32 data, const ARMv7_encoding type);
virtual void SMUAD(const u32 data, const ARMv7_encoding type);
virtual void SMUL__(const u32 data, const ARMv7_encoding type);
virtual void SMULL(const u32 data, const ARMv7_encoding type);
virtual void SMULW_(const u32 data, const ARMv7_encoding type);
virtual void SMUSD(const u32 data, const ARMv7_encoding type);
virtual void SSAT(const u32 data, const ARMv7_encoding type);
virtual void SSAT16(const u32 data, const ARMv7_encoding type);
virtual void SSAX(const u32 data, const ARMv7_encoding type);
virtual void SSUB16(const u32 data, const ARMv7_encoding type);
virtual void SSUB8(const u32 data, const ARMv7_encoding type);
virtual void STM(const u32 data, const ARMv7_encoding type);
virtual void STMDA(const u32 data, const ARMv7_encoding type);
virtual void STMDB(const u32 data, const ARMv7_encoding type);
virtual void STMIB(const u32 data, const ARMv7_encoding type);
virtual void STR_IMM(const u32 data, const ARMv7_encoding type);
virtual void STR_REG(const u32 data, const ARMv7_encoding type);
virtual void STRB_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRB_REG(const u32 data, const ARMv7_encoding type);
virtual void STRD_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRD_REG(const u32 data, const ARMv7_encoding type);
virtual void STRH_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRH_REG(const u32 data, const ARMv7_encoding type);
virtual void SUB_IMM(const u32 data, const ARMv7_encoding type);
virtual void SUB_REG(const u32 data, const ARMv7_encoding type);
virtual void SUB_RSR(const u32 data, const ARMv7_encoding type);
virtual void SUB_SPI(const u32 data, const ARMv7_encoding type);
virtual void SUB_SPR(const u32 data, const ARMv7_encoding type);
virtual void SVC(const u32 data, const ARMv7_encoding type);
virtual void SXTAB(const u32 data, const ARMv7_encoding type);
virtual void SXTAB16(const u32 data, const ARMv7_encoding type);
virtual void SXTAH(const u32 data, const ARMv7_encoding type);
virtual void SXTB(const u32 data, const ARMv7_encoding type);
virtual void SXTB16(const u32 data, const ARMv7_encoding type);
virtual void SXTH(const u32 data, const ARMv7_encoding type);
virtual void TB_(const u32 data, const ARMv7_encoding type);
virtual void TEQ_IMM(const u32 data, const ARMv7_encoding type);
virtual void TEQ_REG(const u32 data, const ARMv7_encoding type);
virtual void TEQ_RSR(const u32 data, const ARMv7_encoding type);
virtual void TST_IMM(const u32 data, const ARMv7_encoding type);
virtual void TST_REG(const u32 data, const ARMv7_encoding type);
virtual void TST_RSR(const u32 data, const ARMv7_encoding type);
virtual void UADD16(const u32 data, const ARMv7_encoding type);
virtual void UADD8(const u32 data, const ARMv7_encoding type);
virtual void UASX(const u32 data, const ARMv7_encoding type);
virtual void UBFX(const u32 data, const ARMv7_encoding type);
virtual void UDIV(const u32 data, const ARMv7_encoding type);
virtual void UHADD16(const u32 data, const ARMv7_encoding type);
virtual void UHADD8(const u32 data, const ARMv7_encoding type);
virtual void UHASX(const u32 data, const ARMv7_encoding type);
virtual void UHSAX(const u32 data, const ARMv7_encoding type);
virtual void UHSUB16(const u32 data, const ARMv7_encoding type);
virtual void UHSUB8(const u32 data, const ARMv7_encoding type);
virtual void UMAAL(const u32 data, const ARMv7_encoding type);
virtual void UMLAL(const u32 data, const ARMv7_encoding type);
virtual void UMULL(const u32 data, const ARMv7_encoding type);
virtual void UQADD16(const u32 data, const ARMv7_encoding type);
virtual void UQADD8(const u32 data, const ARMv7_encoding type);
virtual void UQASX(const u32 data, const ARMv7_encoding type);
virtual void UQSAX(const u32 data, const ARMv7_encoding type);
virtual void UQSUB16(const u32 data, const ARMv7_encoding type);
virtual void UQSUB8(const u32 data, const ARMv7_encoding type);
virtual void USAD8(const u32 data, const ARMv7_encoding type);
virtual void USADA8(const u32 data, const ARMv7_encoding type);
virtual void USAT(const u32 data, const ARMv7_encoding type);
virtual void USAT16(const u32 data, const ARMv7_encoding type);
virtual void USAX(const u32 data, const ARMv7_encoding type);
virtual void USUB16(const u32 data, const ARMv7_encoding type);
virtual void USUB8(const u32 data, const ARMv7_encoding type);
virtual void UXTAB(const u32 data, const ARMv7_encoding type);
virtual void UXTAB16(const u32 data, const ARMv7_encoding type);
virtual void UXTAH(const u32 data, const ARMv7_encoding type);
virtual void UXTB(const u32 data, const ARMv7_encoding type);
virtual void UXTB16(const u32 data, const ARMv7_encoding type);
virtual void UXTH(const u32 data, const ARMv7_encoding type);
};

2765
rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

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

@ -10,7 +10,7 @@ public:
{
}
enum SRType
enum SRType : u32
{
SRType_None,
SRType_LSL,
@ -93,7 +93,7 @@ public:
return len - 1 - HighestSetBit(x, len);
}
SRType DecodeImmShift(u8 type, u8 imm5, uint* shift_n)
SRType DecodeImmShift(u32 type, u32 imm5, u32* shift_n)
{
SRType shift_t = SRType_None;
@ -217,7 +217,7 @@ public:
return value;
}
template<typename T> T Shift(T value, SRType type, uint amount, bool carry_in)
template<typename T> T Shift(T value, SRType type, u32 amount, bool carry_in)
{
bool carry_out;
return Shift_C(value, type, amount, carry_in, carry_out);
@ -225,15 +225,50 @@ public:
template<typename T> T AddWithCarry(T x, T y, bool carry_in, bool& carry_out, bool& overflow)
{
uint unsigned_sum = (uint)x + (uint)y + (uint)carry_in;
int signed_sum = (int)x + (int)y + (int)carry_in;
T result = unsigned_sum & ~(T(1) << (sizeof(T) - 1));
carry_out = (uint)result != unsigned_sum;
overflow = (int)result != signed_sum;
const T sign_mask = (T)1 << (sizeof(T) - 1);
T result = x + y;
carry_out = ((x & y) | ((x ^ y) & ~result)) & sign_mask;
overflow = (x ^ result) & (y ^ result) & sign_mask;
if (carry_in)
{
result += 1;
carry_out ^= (result == 0);
overflow ^= (result == sign_mask);
}
return result;
}
bool ConditionPassed(u8 cond) const
u32 ThumbExpandImm_C(u32 imm12, bool carry_in, bool& carry_out)
{
if ((imm12 & 0xc00) >> 10)
{
u32 unrotated_value = (imm12 & 0x7f) | 0x80;
return ROR_C(unrotated_value, (imm12 & 0xf80) >> 7, carry_out);
}
else
{
carry_out = carry_in;
u32 imm8 = imm12 & 0xff;
switch ((imm12 & 0x300) >> 8)
{
case 0: return imm8;
case 1: return imm8 << 16 | imm8;
case 2: return imm8 << 24 | imm8 << 8;
default: return imm8 << 24 | imm8 << 16 | imm8 << 8 | imm8;
}
}
}
u32 ThumbExpandImm(u32 imm12)
{
bool carry = CPU.APSR.C;
return ThumbExpandImm_C(imm12, carry, carry);
}
bool ConditionPassed(u32 cond) const
{
bool result = false;
@ -258,65 +293,276 @@ public:
}
protected:
void NULL_OP()
{
LOG_ERROR(HLE, "null");
Emu.Pause();
}
virtual void UNK(const u32 data);
void NOP()
{
}
virtual void NULL_OP(const u32 data, const ARMv7_encoding type);
void PUSH(u16 regs_list)
{
for(u16 mask=0x1, i=0; mask; mask <<= 1, i++)
{
if(regs_list & mask)
{
CPU.SP -= 4;
vm::psv::write32(CPU.SP, CPU.read_gpr(i));
}
}
}
virtual void HACK(const u32 data, const ARMv7_encoding type);
void POP(u16 regs_list)
{
for(u16 mask=(0x1 << 15), i=15; mask; mask >>= 1, i--)
{
if(regs_list & mask)
{
CPU.write_gpr(i, vm::psv::read32(CPU.SP));
CPU.SP += 4;
}
}
}
virtual void ADC_IMM(const u32 data, const ARMv7_encoding type);
virtual void ADC_REG(const u32 data, const ARMv7_encoding type);
virtual void ADC_RSR(const u32 data, const ARMv7_encoding type);
void B(u8 cond, u32 imm, u8 intstr_size)
{
if(ConditionPassed(cond))
{
CPU.SetBranch(CPU.PC + intstr_size + imm);
}
}
virtual void ADD_IMM(const u32 data, const ARMv7_encoding type);
virtual void ADD_REG(const u32 data, const ARMv7_encoding type);
virtual void ADD_RSR(const u32 data, const ARMv7_encoding type);
virtual void ADD_SPI(const u32 data, const ARMv7_encoding type);
virtual void ADD_SPR(const u32 data, const ARMv7_encoding type);
void CBZ(u8 op, u32 imm, u8 rn, u8 intstr_size)
{
if((CPU.GPR[rn] == 0) ^ op)
{
CPU.SetBranch(CPU.PC + intstr_size + imm);
}
}
virtual void ADR(const u32 data, const ARMv7_encoding type);
void BL(u32 imm, u8 intstr_size)
{
CPU.LR = (CPU.PC + intstr_size) | 1;
CPU.SetBranch(CPU.PC + intstr_size + imm);
}
virtual void AND_IMM(const u32 data, const ARMv7_encoding type);
virtual void AND_REG(const u32 data, const ARMv7_encoding type);
virtual void AND_RSR(const u32 data, const ARMv7_encoding type);
void UNK(const u16 code0, const u16 code1)
{
LOG_ERROR(HLE, "Unknown/Illegal opcode! (0x%04x : 0x%04x)", code0, code1);
Emu.Pause();
}
virtual void ASR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ASR_REG(const u32 data, const ARMv7_encoding type);
virtual void B(const u32 data, const ARMv7_encoding type);
virtual void BFC(const u32 data, const ARMv7_encoding type);
virtual void BFI(const u32 data, const ARMv7_encoding type);
virtual void BIC_IMM(const u32 data, const ARMv7_encoding type);
virtual void BIC_REG(const u32 data, const ARMv7_encoding type);
virtual void BIC_RSR(const u32 data, const ARMv7_encoding type);
virtual void BKPT(const u32 data, const ARMv7_encoding type);
virtual void BL(const u32 data, const ARMv7_encoding type);
virtual void BLX(const u32 data, const ARMv7_encoding type);
virtual void BX(const u32 data, const ARMv7_encoding type);
virtual void CB_Z(const u32 data, const ARMv7_encoding type);
virtual void CLZ(const u32 data, const ARMv7_encoding type);
virtual void CMN_IMM(const u32 data, const ARMv7_encoding type);
virtual void CMN_REG(const u32 data, const ARMv7_encoding type);
virtual void CMN_RSR(const u32 data, const ARMv7_encoding type);
virtual void CMP_IMM(const u32 data, const ARMv7_encoding type);
virtual void CMP_REG(const u32 data, const ARMv7_encoding type);
virtual void CMP_RSR(const u32 data, const ARMv7_encoding type);
virtual void EOR_IMM(const u32 data, const ARMv7_encoding type);
virtual void EOR_REG(const u32 data, const ARMv7_encoding type);
virtual void EOR_RSR(const u32 data, const ARMv7_encoding type);
virtual void IT(const u32 data, const ARMv7_encoding type);
virtual void LDM(const u32 data, const ARMv7_encoding type);
virtual void LDMDA(const u32 data, const ARMv7_encoding type);
virtual void LDMDB(const u32 data, const ARMv7_encoding type);
virtual void LDMIB(const u32 data, const ARMv7_encoding type);
virtual void LDR_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDR_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDR_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRB_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRB_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRB_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRD_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRD_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRD_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRH_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRH_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRH_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRSB_REG(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_IMM(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_LIT(const u32 data, const ARMv7_encoding type);
virtual void LDRSH_REG(const u32 data, const ARMv7_encoding type);
virtual void LSL_IMM(const u32 data, const ARMv7_encoding type);
virtual void LSL_REG(const u32 data, const ARMv7_encoding type);
virtual void LSR_IMM(const u32 data, const ARMv7_encoding type);
virtual void LSR_REG(const u32 data, const ARMv7_encoding type);
virtual void MLA(const u32 data, const ARMv7_encoding type);
virtual void MLS(const u32 data, const ARMv7_encoding type);
virtual void MOV_IMM(const u32 data, const ARMv7_encoding type);
virtual void MOV_REG(const u32 data, const ARMv7_encoding type);
virtual void MOVT(const u32 data, const ARMv7_encoding type);
virtual void MRS(const u32 data, const ARMv7_encoding type);
virtual void MSR_IMM(const u32 data, const ARMv7_encoding type);
virtual void MSR_REG(const u32 data, const ARMv7_encoding type);
virtual void MUL(const u32 data, const ARMv7_encoding type);
virtual void MVN_IMM(const u32 data, const ARMv7_encoding type);
virtual void MVN_REG(const u32 data, const ARMv7_encoding type);
virtual void MVN_RSR(const u32 data, const ARMv7_encoding type);
virtual void NOP(const u32 data, const ARMv7_encoding type);
virtual void ORN_IMM(const u32 data, const ARMv7_encoding type);
virtual void ORN_REG(const u32 data, const ARMv7_encoding type);
virtual void ORR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ORR_REG(const u32 data, const ARMv7_encoding type);
virtual void ORR_RSR(const u32 data, const ARMv7_encoding type);
virtual void PKH(const u32 data, const ARMv7_encoding type);
virtual void POP(const u32 data, const ARMv7_encoding type);
virtual void PUSH(const u32 data, const ARMv7_encoding type);
virtual void QADD(const u32 data, const ARMv7_encoding type);
virtual void QADD16(const u32 data, const ARMv7_encoding type);
virtual void QADD8(const u32 data, const ARMv7_encoding type);
virtual void QASX(const u32 data, const ARMv7_encoding type);
virtual void QDADD(const u32 data, const ARMv7_encoding type);
virtual void QDSUB(const u32 data, const ARMv7_encoding type);
virtual void QSAX(const u32 data, const ARMv7_encoding type);
virtual void QSUB(const u32 data, const ARMv7_encoding type);
virtual void QSUB16(const u32 data, const ARMv7_encoding type);
virtual void QSUB8(const u32 data, const ARMv7_encoding type);
virtual void RBIT(const u32 data, const ARMv7_encoding type);
virtual void REV(const u32 data, const ARMv7_encoding type);
virtual void REV16(const u32 data, const ARMv7_encoding type);
virtual void REVSH(const u32 data, const ARMv7_encoding type);
virtual void ROR_IMM(const u32 data, const ARMv7_encoding type);
virtual void ROR_REG(const u32 data, const ARMv7_encoding type);
virtual void RRX(const u32 data, const ARMv7_encoding type);
virtual void RSB_IMM(const u32 data, const ARMv7_encoding type);
virtual void RSB_REG(const u32 data, const ARMv7_encoding type);
virtual void RSB_RSR(const u32 data, const ARMv7_encoding type);
virtual void RSC_IMM(const u32 data, const ARMv7_encoding type);
virtual void RSC_REG(const u32 data, const ARMv7_encoding type);
virtual void RSC_RSR(const u32 data, const ARMv7_encoding type);
virtual void SADD16(const u32 data, const ARMv7_encoding type);
virtual void SADD8(const u32 data, const ARMv7_encoding type);
virtual void SASX(const u32 data, const ARMv7_encoding type);
virtual void SBC_IMM(const u32 data, const ARMv7_encoding type);
virtual void SBC_REG(const u32 data, const ARMv7_encoding type);
virtual void SBC_RSR(const u32 data, const ARMv7_encoding type);
virtual void SBFX(const u32 data, const ARMv7_encoding type);
virtual void SDIV(const u32 data, const ARMv7_encoding type);
virtual void SEL(const u32 data, const ARMv7_encoding type);
virtual void SHADD16(const u32 data, const ARMv7_encoding type);
virtual void SHADD8(const u32 data, const ARMv7_encoding type);
virtual void SHASX(const u32 data, const ARMv7_encoding type);
virtual void SHSAX(const u32 data, const ARMv7_encoding type);
virtual void SHSUB16(const u32 data, const ARMv7_encoding type);
virtual void SHSUB8(const u32 data, const ARMv7_encoding type);
virtual void SMLA__(const u32 data, const ARMv7_encoding type);
virtual void SMLAD(const u32 data, const ARMv7_encoding type);
virtual void SMLAL(const u32 data, const ARMv7_encoding type);
virtual void SMLAL__(const u32 data, const ARMv7_encoding type);
virtual void SMLALD(const u32 data, const ARMv7_encoding type);
virtual void SMLAW_(const u32 data, const ARMv7_encoding type);
virtual void SMLSD(const u32 data, const ARMv7_encoding type);
virtual void SMLSLD(const u32 data, const ARMv7_encoding type);
virtual void SMMLA(const u32 data, const ARMv7_encoding type);
virtual void SMMLS(const u32 data, const ARMv7_encoding type);
virtual void SMMUL(const u32 data, const ARMv7_encoding type);
virtual void SMUAD(const u32 data, const ARMv7_encoding type);
virtual void SMUL__(const u32 data, const ARMv7_encoding type);
virtual void SMULL(const u32 data, const ARMv7_encoding type);
virtual void SMULW_(const u32 data, const ARMv7_encoding type);
virtual void SMUSD(const u32 data, const ARMv7_encoding type);
virtual void SSAT(const u32 data, const ARMv7_encoding type);
virtual void SSAT16(const u32 data, const ARMv7_encoding type);
virtual void SSAX(const u32 data, const ARMv7_encoding type);
virtual void SSUB16(const u32 data, const ARMv7_encoding type);
virtual void SSUB8(const u32 data, const ARMv7_encoding type);
virtual void STM(const u32 data, const ARMv7_encoding type);
virtual void STMDA(const u32 data, const ARMv7_encoding type);
virtual void STMDB(const u32 data, const ARMv7_encoding type);
virtual void STMIB(const u32 data, const ARMv7_encoding type);
virtual void STR_IMM(const u32 data, const ARMv7_encoding type);
virtual void STR_REG(const u32 data, const ARMv7_encoding type);
virtual void STRB_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRB_REG(const u32 data, const ARMv7_encoding type);
virtual void STRD_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRD_REG(const u32 data, const ARMv7_encoding type);
virtual void STRH_IMM(const u32 data, const ARMv7_encoding type);
virtual void STRH_REG(const u32 data, const ARMv7_encoding type);
virtual void SUB_IMM(const u32 data, const ARMv7_encoding type);
virtual void SUB_REG(const u32 data, const ARMv7_encoding type);
virtual void SUB_RSR(const u32 data, const ARMv7_encoding type);
virtual void SUB_SPI(const u32 data, const ARMv7_encoding type);
virtual void SUB_SPR(const u32 data, const ARMv7_encoding type);
virtual void SVC(const u32 data, const ARMv7_encoding type);
virtual void SXTAB(const u32 data, const ARMv7_encoding type);
virtual void SXTAB16(const u32 data, const ARMv7_encoding type);
virtual void SXTAH(const u32 data, const ARMv7_encoding type);
virtual void SXTB(const u32 data, const ARMv7_encoding type);
virtual void SXTB16(const u32 data, const ARMv7_encoding type);
virtual void SXTH(const u32 data, const ARMv7_encoding type);
virtual void TB_(const u32 data, const ARMv7_encoding type);
virtual void TEQ_IMM(const u32 data, const ARMv7_encoding type);
virtual void TEQ_REG(const u32 data, const ARMv7_encoding type);
virtual void TEQ_RSR(const u32 data, const ARMv7_encoding type);
virtual void TST_IMM(const u32 data, const ARMv7_encoding type);
virtual void TST_REG(const u32 data, const ARMv7_encoding type);
virtual void TST_RSR(const u32 data, const ARMv7_encoding type);
virtual void UADD16(const u32 data, const ARMv7_encoding type);
virtual void UADD8(const u32 data, const ARMv7_encoding type);
virtual void UASX(const u32 data, const ARMv7_encoding type);
virtual void UBFX(const u32 data, const ARMv7_encoding type);
virtual void UDIV(const u32 data, const ARMv7_encoding type);
virtual void UHADD16(const u32 data, const ARMv7_encoding type);
virtual void UHADD8(const u32 data, const ARMv7_encoding type);
virtual void UHASX(const u32 data, const ARMv7_encoding type);
virtual void UHSAX(const u32 data, const ARMv7_encoding type);
virtual void UHSUB16(const u32 data, const ARMv7_encoding type);
virtual void UHSUB8(const u32 data, const ARMv7_encoding type);
virtual void UMAAL(const u32 data, const ARMv7_encoding type);
virtual void UMLAL(const u32 data, const ARMv7_encoding type);
virtual void UMULL(const u32 data, const ARMv7_encoding type);
virtual void UQADD16(const u32 data, const ARMv7_encoding type);
virtual void UQADD8(const u32 data, const ARMv7_encoding type);
virtual void UQASX(const u32 data, const ARMv7_encoding type);
virtual void UQSAX(const u32 data, const ARMv7_encoding type);
virtual void UQSUB16(const u32 data, const ARMv7_encoding type);
virtual void UQSUB8(const u32 data, const ARMv7_encoding type);
virtual void USAD8(const u32 data, const ARMv7_encoding type);
virtual void USADA8(const u32 data, const ARMv7_encoding type);
virtual void USAT(const u32 data, const ARMv7_encoding type);
virtual void USAT16(const u32 data, const ARMv7_encoding type);
virtual void USAX(const u32 data, const ARMv7_encoding type);
virtual void USUB16(const u32 data, const ARMv7_encoding type);
virtual void USUB8(const u32 data, const ARMv7_encoding type);
virtual void UXTAB(const u32 data, const ARMv7_encoding type);
virtual void UXTAB16(const u32 data, const ARMv7_encoding type);
virtual void UXTAH(const u32 data, const ARMv7_encoding type);
virtual void UXTB(const u32 data, const ARMv7_encoding type);
virtual void UXTB16(const u32 data, const ARMv7_encoding type);
virtual void UXTH(const u32 data, const ARMv7_encoding type);
};

684
rpcs3/Emu/ARMv7/ARMv7Opcodes.h
View File

@ -32,18 +32,686 @@ namespace ARMv7_opcodes
};
}
enum ARMv7_encoding
{
T1,
T2,
T3,
T4,
A1,
A2,
};
class ARMv7Opcodes
{
public:
virtual void NULL_OP() = 0;
virtual void NOP() = 0;
virtual void UNK(const u32 data) = 0;
virtual void PUSH(u16 regs_list) = 0;
virtual void POP(u16 regs_list) = 0;
virtual void NULL_OP(const u32 data, const ARMv7_encoding type) = 0;
virtual void B(u8 cond, u32 imm, u8 intstr_size) = 0;
virtual void CBZ(u8 op, u32 imm, u8 rn, u8 intstr_size) = 0;
virtual void BL(u32 imm, u8 intstr_size)=0;
virtual void HACK(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADC_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADC_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADC_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADD_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADD_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADD_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADD_SPI(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADD_SPR(const u32 data, const ARMv7_encoding type) = 0;
virtual void ADR(const u32 data, const ARMv7_encoding type) = 0;
virtual void AND_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void AND_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void AND_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void ASR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ASR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void B(const u32 data, const ARMv7_encoding type) = 0;
virtual void BFC(const u32 data, const ARMv7_encoding type) = 0;
virtual void BFI(const u32 data, const ARMv7_encoding type) = 0;
virtual void BIC_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void BIC_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void BIC_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void BKPT(const u32 data, const ARMv7_encoding type) = 0;
virtual void BL(const u32 data, const ARMv7_encoding type) = 0;
virtual void BLX(const u32 data, const ARMv7_encoding type) = 0;
virtual void BX(const u32 data, const ARMv7_encoding type) = 0;
virtual void CB_Z(const u32 data, const ARMv7_encoding type) = 0;
virtual void CLZ(const u32 data, const ARMv7_encoding type) = 0;
virtual void UNK(const u16 code0, const u16 code1) = 0;
virtual void CMN_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void CMN_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void CMN_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void CMP_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void CMP_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void CMP_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void EOR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void EOR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void EOR_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void IT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDMDA(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDMDB(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDMIB(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDR_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRB_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRB_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRB_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRD_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRD_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRD_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRH_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRH_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRH_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSB_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSB_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSB_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSH_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSH_LIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void LDRSH_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LSL_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LSL_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void LSR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void LSR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void MLA(const u32 data, const ARMv7_encoding type) = 0;
virtual void MLS(const u32 data, const ARMv7_encoding type) = 0;
virtual void MOV_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void MOV_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void MOVT(const u32 data, const ARMv7_encoding type) = 0;
virtual void MRS(const u32 data, const ARMv7_encoding type) = 0;
virtual void MSR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void MSR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void MUL(const u32 data, const ARMv7_encoding type) = 0;
virtual void MVN_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void MVN_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void MVN_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void NOP(const u32 data, const ARMv7_encoding type) = 0;
virtual void ORN_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ORN_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void ORR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ORR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void ORR_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void PKH(const u32 data, const ARMv7_encoding type) = 0;
virtual void POP(const u32 data, const ARMv7_encoding type) = 0;
virtual void PUSH(const u32 data, const ARMv7_encoding type) = 0;
virtual void QADD(const u32 data, const ARMv7_encoding type) = 0;
virtual void QADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void QADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void QASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void QDADD(const u32 data, const ARMv7_encoding type) = 0;
virtual void QDSUB(const u32 data, const ARMv7_encoding type) = 0;
virtual void QSAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void QSUB(const u32 data, const ARMv7_encoding type) = 0;
virtual void QSUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void QSUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void RBIT(const u32 data, const ARMv7_encoding type) = 0;
virtual void REV(const u32 data, const ARMv7_encoding type) = 0;
virtual void REV16(const u32 data, const ARMv7_encoding type) = 0;
virtual void REVSH(const u32 data, const ARMv7_encoding type) = 0;
virtual void ROR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void ROR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void RRX(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSB_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSB_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSB_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSC_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSC_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void RSC_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void SADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void SASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void SBC_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void SBC_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void SBC_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void SBFX(const u32 data, const ARMv7_encoding type) = 0;
virtual void SDIV(const u32 data, const ARMv7_encoding type) = 0;
virtual void SEL(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHSAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHSUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SHSUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLA__(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLAD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLAL(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLAL__(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLALD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLAW_(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLSD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMLSLD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMMLA(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMMLS(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMMUL(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMUAD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMUL__(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMULL(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMULW_(const u32 data, const ARMv7_encoding type) = 0;
virtual void SMUSD(const u32 data, const ARMv7_encoding type) = 0;
virtual void SSAT(const u32 data, const ARMv7_encoding type) = 0;
virtual void SSAT16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SSAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void SSUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SSUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void STM(const u32 data, const ARMv7_encoding type) = 0;
virtual void STMDA(const u32 data, const ARMv7_encoding type) = 0;
virtual void STMDB(const u32 data, const ARMv7_encoding type) = 0;
virtual void STMIB(const u32 data, const ARMv7_encoding type) = 0;
virtual void STR_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void STR_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRB_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRB_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRD_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRD_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRH_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void STRH_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void SUB_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void SUB_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void SUB_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void SUB_SPI(const u32 data, const ARMv7_encoding type) = 0;
virtual void SUB_SPR(const u32 data, const ARMv7_encoding type) = 0;
virtual void SVC(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTAB(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTAB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTAH(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTB(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void SXTH(const u32 data, const ARMv7_encoding type) = 0;
virtual void TB_(const u32 data, const ARMv7_encoding type) = 0;
virtual void TEQ_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void TEQ_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void TEQ_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void TST_IMM(const u32 data, const ARMv7_encoding type) = 0;
virtual void TST_REG(const u32 data, const ARMv7_encoding type) = 0;
virtual void TST_RSR(const u32 data, const ARMv7_encoding type) = 0;
virtual void UADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void UASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UBFX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UDIV(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHSAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHSUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UHSUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void UMAAL(const u32 data, const ARMv7_encoding type) = 0;
virtual void UMLAL(const u32 data, const ARMv7_encoding type) = 0;
virtual void UMULL(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQADD16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQADD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQASX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQSAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQSUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UQSUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void USAD8(const u32 data, const ARMv7_encoding type) = 0;
virtual void USADA8(const u32 data, const ARMv7_encoding type) = 0;
virtual void USAT(const u32 data, const ARMv7_encoding type) = 0;
virtual void USAT16(const u32 data, const ARMv7_encoding type) = 0;
virtual void USAX(const u32 data, const ARMv7_encoding type) = 0;
virtual void USUB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void USUB8(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTAB(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTAB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTAH(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTB(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTB16(const u32 data, const ARMv7_encoding type) = 0;
virtual void UXTH(const u32 data, const ARMv7_encoding type) = 0;
// TODO: vector ops + something
};
struct ARMv7_opcode_t
{
u32 mask;
u32 code;
u32 length; // 2 or 4
const char* name;
ARMv7_encoding type;
void (ARMv7Opcodes::*func)(const u32 data, const ARMv7_encoding type);
};
// single 16-bit value
#define ARMv7_OP2(mask, code, type, name) { (u32)((mask) << 16), (u32)((code) << 16), 2, #name "_" #type, type, &ARMv7Opcodes::name }
// two 16-bit values
#define ARMv7_OP4(mask0, mask1, code0, code1, type, name) { (u32)((mask0) << 16) | (mask1), (u32)((code0) << 16) | (code1), 4, #name "_" #type, type, &ARMv7Opcodes::name }
static const ARMv7_opcode_t ARMv7_opcode_table[] =
{
ARMv7_OP2(0xffff, 0x0000, T1, NULL_OP), // ???
ARMv7_OP4(0xffff, 0x0000, 0xf870, 0x0000, T1, HACK), // "Undefined" Thumb opcode
ARMv7_OP4(0x0ff0, 0x00f0, 0x0070, 0x0090, A1, HACK), // "Undefined" ARM opcode
ARMv7_OP4(0xfbe0, 0x8000, 0xf140, 0x0000, T1, ADC_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x02a0, 0x0000, A1, ADC_IMM),
ARMv7_OP2(0xffc0, 0x4040, T1, ADC_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xeb40, 0x0000, T2, ADC_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x00a0, 0x0000, A1, ADC_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x00a0, 0x0010, A1, ADC_RSR),
ARMv7_OP2(0xfe00, 0x1c00, T1, ADD_IMM),
ARMv7_OP2(0xf800, 0x3000, T2, ADD_IMM),
ARMv7_OP4(0xfbe0, 0x8000, 0xf100, 0x0000, T3, ADD_IMM),
ARMv7_OP4(0xfbf0, 0x8000, 0xf200, 0x0000, T4, ADD_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0280, 0x0000, A1, ADD_IMM),
ARMv7_OP2(0xfe00, 0x1800, T1, ADD_REG),
ARMv7_OP2(0xff00, 0x4400, T2, ADD_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xeb00, 0x0000, T3, ADD_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0080, 0x0000, A1, ADD_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0080, 0x0010, A1, ADD_RSR),
ARMv7_OP2(0xf800, 0xa800, T1, ADD_SPI),
ARMv7_OP2(0xff80, 0xb000, T2, ADD_SPI),
ARMv7_OP4(0xfbef, 0x8000, 0xf10d, 0x0000, T3, ADD_SPI),
ARMv7_OP4(0xfbff, 0x8000, 0xf20d, 0x0000, T4, ADD_SPI),
ARMv7_OP4(0x0fef, 0x0000, 0x028d, 0x0000, A1, ADD_SPI),
ARMv7_OP2(0xff78, 0x4468, T1, ADD_SPR),
ARMv7_OP2(0xff87, 0x4485, T2, ADD_SPR),
ARMv7_OP4(0xffef, 0x8000, 0xeb0d, 0x0000, T3, ADD_SPR),
ARMv7_OP4(0x0fef, 0x0010, 0x008d, 0x0000, A1, ADD_SPR),
ARMv7_OP2(0xf800, 0xa000, T1, ADR),
ARMv7_OP4(0xfbff, 0x8000, 0xf2af, 0x0000, T2, ADR),
ARMv7_OP4(0xfbff, 0x8000, 0xf20f, 0x0000, T3, ADR),
ARMv7_OP4(0x0fff, 0x0000, 0x028f, 0x0000, A1, ADR),
ARMv7_OP4(0x0fff, 0x0000, 0x024f, 0x0000, A2, ADR),
ARMv7_OP4(0xfbe0, 0x8000, 0xf000, 0x0000, T1, AND_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0200, 0x0000, A1, AND_IMM),
ARMv7_OP2(0xffc0, 0x4000, T1, AND_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xea00, 0x0000, T2, AND_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0000, 0x0000, A1, AND_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0000, 0x0010, A1, AND_RSR),
ARMv7_OP2(0xf800, 0x1000, T1, ASR_IMM),
ARMv7_OP4(0xffef, 0x8030, 0xea4f, 0x0020, T2, ASR_IMM),
ARMv7_OP4(0x0fef, 0x0070, 0x01a0, 0x0040, A1, ASR_IMM),
ARMv7_OP2(0xffc0, 0x4100, T1, ASR_REG),
ARMv7_OP4(0xffe0, 0xf0f0, 0xfa40, 0xf000, T2, ASR_REG),
ARMv7_OP4(0x0fef, 0x00f0, 0x01a0, 0x0050, A1, ASR_REG),
ARMv7_OP2(0xf000, 0xd000, T1, B),
ARMv7_OP2(0xf800, 0xe000, T2, B),
ARMv7_OP4(0xf800, 0xd000, 0xf000, 0x8000, T3, B),
ARMv7_OP4(0xf800, 0xd000, 0xf000, 0x9000, T4, B),
ARMv7_OP4(0x0f00, 0x0000, 0x0a00, 0x0000, A1, B),
ARMv7_OP4(0xffff, 0x8020, 0xf36f, 0x0000, T1, BFC),
ARMv7_OP4(0x0fe0, 0x007f, 0x07c0, 0x001f, A1, BFC),
ARMv7_OP4(0xfff0, 0x8020, 0xf360, 0x0000, T1, BFI),
ARMv7_OP4(0x0fe0, 0x0070, 0x07c0, 0x0010, A1, BFI),
ARMv7_OP4(0xfbe0, 0x8000, 0xf020, 0x0000, T1, BIC_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x03c0, 0x0000, A1, BIC_IMM),
ARMv7_OP2(0xffc0, 0x4380, T1, BIC_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xea20, 0x0000, T2, BIC_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x01c0, 0x0000, A1, BIC_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x01c0, 0x0010, A1, BIC_RSR),
ARMv7_OP2(0xff00, 0xbe00, T1, BKPT),
ARMv7_OP4(0x0ff0, 0x00f0, 0x0120, 0x0070, A1, BKPT),
ARMv7_OP4(0xf800, 0xd000, 0xf000, 0xd000, T1, BL),
ARMv7_OP4(0x0f00, 0x0000, 0x0b00, 0x0000, A1, BL),
ARMv7_OP2(0xff80, 0x4780, T1, BLX),
ARMv7_OP4(0xf800, 0xc001, 0xf000, 0xc000, T2, BLX),
ARMv7_OP4(0x0fff, 0xfff0, 0x012f, 0xff30, A1, BLX),
ARMv7_OP4(0xfe00, 0x0000, 0xfa00, 0x0000, A2, BLX),
ARMv7_OP2(0xff87, 0x4700, T1, BX),
ARMv7_OP4(0x0fff, 0xfff0, 0x012f, 0xff10, A1, BX),
ARMv7_OP2(0xf500, 0xb100, T1, CB_Z),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfab0, 0xf080, T1, CLZ),
ARMv7_OP4(0x0fff, 0x0ff0, 0x016f, 0x0f10, A1, CLZ),
ARMv7_OP4(0xfbf0, 0x8f00, 0xf110, 0x0f00, T1, CMN_IMM),
ARMv7_OP4(0x0ff0, 0xf000, 0x0370, 0x0000, A1, CMN_IMM),
ARMv7_OP2(0xffc0, 0x42c0, T1, CMN_REG),
ARMv7_OP4(0xfff0, 0x8f00, 0xeb10, 0x0f00, T2, CMN_REG),
ARMv7_OP4(0x0ff0, 0xf010, 0x0170, 0x0000, A1, CMN_REG),
ARMv7_OP4(0x0ff0, 0xf090, 0x0170, 0x0010, A1, CMN_RSR),
ARMv7_OP2(0xf800, 0x2800, T1, CMP_IMM),
ARMv7_OP4(0xfbf0, 0x8f00, 0xf1b0, 0x0f00, T2, CMP_IMM),
ARMv7_OP4(0x0ff0, 0xf000, 0x0350, 0x0000, A1, CMP_IMM),
ARMv7_OP2(0xffc0, 0x4280, T1, CMP_REG),
ARMv7_OP2(0xff00, 0x4500, T2, CMP_REG),
ARMv7_OP4(0xfff0, 0x8f00, 0xebb0, 0x0f00, T3, CMP_REG),
ARMv7_OP4(0x0ff0, 0xf010, 0x0150, 0x0000, A1, CMP_REG),
ARMv7_OP4(0x0ff0, 0xf090, 0x0150, 0x0010, A1, CMP_RSR),
ARMv7_OP4(0xfbe0, 0x8000, 0xf080, 0x0000, T1, EOR_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0220, 0x0000, A1, EOR_IMM),
ARMv7_OP2(0xffc0, 0x4040, T1, EOR_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xea80, 0x0000, T2, EOR_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0020, 0x0000, A1, EOR_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0020, 0x0010, A1, EOR_RSR),
ARMv7_OP2(0xff00, 0xbf00, T1, IT),
ARMv7_OP2(0xf800, 0xc800, T1, LDM),
ARMv7_OP4(0xffd0, 0x2000, 0xe890, 0x0000, T2, LDM),
ARMv7_OP4(0x0fd0, 0x0000, 0x0890, 0x0000, A1, LDM),
ARMv7_OP4(0x0fd0, 0x0000, 0x0810, 0x0000, A1, LDMDA),
ARMv7_OP4(0xffd0, 0x2000, 0xe910, 0x0000, T1, LDMDB),
ARMv7_OP4(0x0fd0, 0x0000, 0x0910, 0x0000, A1, LDMDB),
ARMv7_OP4(0x0fd0, 0x0000, 0x0990, 0x0000, A1, LDMIB),
ARMv7_OP2(0xf800, 0x6800, T1, LDR_IMM),
ARMv7_OP2(0xf800, 0x9800, T2, LDR_IMM),
ARMv7_OP4(0xfff0, 0x0000, 0xf8d0, 0x0000, T3, LDR_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf850, 0x0800, T4, LDR_IMM),
ARMv7_OP4(0x0e50, 0x0000, 0x0410, 0x0000, A1, LDR_IMM),
ARMv7_OP2(0xf800, 0x4800, T1, LDR_LIT),
ARMv7_OP4(0xff7f, 0x0000, 0xf85f, 0x0000, T2, LDR_LIT),
ARMv7_OP4(0x0f7f, 0x0000, 0x051f, 0x0000, A1, LDR_LIT),
ARMv7_OP2(0xfe00, 0x5800, T1, LDR_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf850, 0x0000, T2, LDR_REG),
ARMv7_OP4(0x0e50, 0x0010, 0x0610, 0x0000, A1, LDR_REG),
ARMv7_OP2(0xf800, 0x7800, T1, LDRB_IMM),
ARMv7_OP4(0xfff0, 0x0000, 0xf890, 0x0000, T2, LDRB_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf810, 0x0800, T3, LDRB_IMM),
ARMv7_OP4(0x0e50, 0x0000, 0x0450, 0x0000, A1, LDRB_IMM),
ARMv7_OP4(0xff7f, 0x0000, 0xf81f, 0x0000, T1, LDRB_LIT),
ARMv7_OP4(0x0f7f, 0x0000, 0x055f, 0x0000, A1, LDRB_LIT),
ARMv7_OP2(0xfe00, 0x5c00, T1, LDRB_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf810, 0x0000, T2, LDRB_REG),
ARMv7_OP4(0x0e50, 0x0010, 0x0650, 0x0000, A1, LDRB_REG),
ARMv7_OP4(0xfe50, 0x0000, 0xe850, 0x0000, T1, LDRD_IMM),
ARMv7_OP4(0x0e50, 0x00f0, 0x0040, 0x00d0, A1, LDRD_IMM),
ARMv7_OP4(0xfe7f, 0x0000, 0xe85f, 0x0000, T1, LDRD_LIT),
ARMv7_OP4(0x0f7f, 0x00f0, 0x014f, 0x00d0, A1, LDRD_LIT),
ARMv7_OP4(0x0e50, 0x0ff0, 0x0000, 0x00d0, A1, LDRD_REG),
ARMv7_OP4(0xfff0, 0x0000, 0xf990, 0x0000, T1, LDRSB_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf910, 0x0800, T2, LDRSB_IMM),
ARMv7_OP4(0x0e50, 0x00f0, 0x0050, 0x00d0, A1, LDRSB_IMM),
ARMv7_OP4(0xff7f, 0x0000, 0xf91f, 0x0000, T1, LDRSB_LIT),
ARMv7_OP4(0x0f7f, 0x00f0, 0x015f, 0x00d0, A1, LDRSB_LIT),
ARMv7_OP2(0xfe00, 0x5600, T1, LDRSB_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf910, 0x0000, T2, LDRSB_REG),
ARMv7_OP4(0x0e50, 0x0ff0, 0x0010, 0x00d0, A1, LDRSB_REG),
ARMv7_OP4(0xfff0, 0x0000, 0xf9b0, 0x0000, T1, LDRSH_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf930, 0x0800, T2, LDRSH_IMM),
ARMv7_OP4(0x0e50, 0x00f0, 0x0050, 0x00f0, A1, LDRSH_IMM),
ARMv7_OP4(0xff7f, 0x0000, 0xf93f, 0x0000, T1, LDRSH_LIT),
ARMv7_OP4(0x0f7f, 0x00f0, 0x015f, 0x00f0, A1, LDRSH_LIT),
ARMv7_OP2(0xfe00, 0x5e00, T1, LDRSH_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf930, 0x0000, T2, LDRSH_REG),
ARMv7_OP4(0x0e50, 0x0ff0, 0x0010, 0x00f0, A1, LDRSH_REG),
ARMv7_OP2(0xf800, 0x0000, T1, LSL_IMM),
ARMv7_OP4(0xffef, 0x8030, 0xea4f, 0x0000, T2, LSL_IMM),
ARMv7_OP4(0x0fef, 0x0070, 0x01a0, 0x0000, A1, LSL_IMM),
ARMv7_OP2(0xffc0, 0x4080, T1, LSL_REG),
ARMv7_OP4(0xffe0, 0xf0f0, 0xfa00, 0xf000, T2, LSL_REG),
ARMv7_OP4(0x0fef, 0x00f0, 0x01a0, 0x0010, A1, LSL_REG),
ARMv7_OP2(0xf800, 0x0800, T1, LSR_IMM),
ARMv7_OP4(0xffef, 0x8030, 0xea4f, 0x0010, T2, LSR_IMM),
ARMv7_OP4(0x0fef, 0x0030, 0x01a0, 0x0020, A1, LSR_IMM),
ARMv7_OP2(0xffc0, 0x40c0, T1, LSR_REG),
ARMv7_OP4(0xffe0, 0xf0f0, 0xfa20, 0xf000, T2, LSR_REG),
ARMv7_OP4(0x0fef, 0x00f0, 0x01a0, 0x0030, A1, LSR_REG),
ARMv7_OP4(0xfff0, 0x00f0, 0xfb00, 0x0000, T1, MLA),
ARMv7_OP4(0x0fe0, 0x00f0, 0x0020, 0x0090, A1, MLA),
ARMv7_OP4(0xfff0, 0x00f0, 0xfb00, 0x0010, T1, MLS),
ARMv7_OP4(0x0ff0, 0x00f0, 0x0060, 0x0090, A1, MLS),
ARMv7_OP2(0xf800, 0x2000, T1, MOV_IMM),
ARMv7_OP4(0xfbef, 0x8000, 0xf04f, 0x0000, T2, MOV_IMM),
ARMv7_OP4(0xfbf0, 0x8000, 0xf240, 0x0000, T3, MOV_IMM),
ARMv7_OP4(0x0fef, 0x0000, 0x03a0, 0x0000, A1, MOV_IMM),
ARMv7_OP4(0x0ff0, 0x0000, 0x0300, 0x0000, A2, MOV_IMM),
ARMv7_OP2(0xff00, 0x4600, T1, MOV_REG),
ARMv7_OP2(0xffc0, 0x0000, T2, MOV_REG),
ARMv7_OP4(0xffef, 0xf0f0, 0xea4f, 0x0000, T3, MOV_REG),
ARMv7_OP4(0x0fef, 0x0ff0, 0x01a0, 0x0000, A1, MOV_REG),
ARMv7_OP4(0xfbf0, 0x8000, 0xf2c0, 0x0000, T1, MOVT),
ARMv7_OP4(0x0ff0, 0x0000, 0x0340, 0x0000, A1, MOVT),
ARMv7_OP4(0xffff, 0xf0ff, 0xf3ef, 0x8000, T1, MRS),
ARMv7_OP4(0x0fff, 0x0fff, 0x010f, 0x0000, A1, MRS),
ARMv7_OP4(0x0ff3, 0xf000, 0x0320, 0xf000, A1, MSR_IMM),
ARMv7_OP4(0xfff0, 0xf3ff, 0xf380, 0x8000, T1, MSR_REG),
ARMv7_OP4(0x0ff3, 0xfff0, 0x0120, 0xf000, A1, MSR_REG),
ARMv7_OP2(0xffc0, 0x4340, T1, MUL),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfb00, 0xf000, T2, MUL),
ARMv7_OP4(0x0fe0, 0xf0f0, 0x0000, 0x0090, A1, MUL),
ARMv7_OP4(0xfbef, 0x8000, 0xf06f, 0x0000, T1, MVN_IMM),
ARMv7_OP4(0x0fef, 0x0000, 0x03e0, 0x0000, A1, MVN_IMM),
ARMv7_OP2(0xffc0, 0x43c0, T1, MVN_REG),
ARMv7_OP4(0xffef, 0x8000, 0xea6f, 0x0000, T2, MVN_REG),
ARMv7_OP4(0xffef, 0x0010, 0x01e0, 0x0000, A1, MVN_REG),
ARMv7_OP4(0x0fef, 0x0090, 0x01e0, 0x0010, A1, MVN_RSR),
ARMv7_OP2(0xffff, 0xbf00, T1, NOP),
ARMv7_OP4(0xffff, 0xffff, 0xf3af, 0x8000, T2, NOP),
ARMv7_OP4(0x0fff, 0xffff, 0x0320, 0xf000, A1, NOP),
ARMv7_OP4(0xfbe0, 0x8000, 0xf060, 0x0000, T1, ORN_IMM),
ARMv7_OP4(0xffe0, 0x8000, 0xea60, 0x0000, T1, ORN_REG),
ARMv7_OP4(0xfbe0, 0x8000, 0xf040, 0x0000, T1, ORR_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0380, 0x0000, A1, ORR_IMM),
ARMv7_OP2(0xffc0, 0x4300, T1, ORR_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xea40, 0x0000, T2, ORR_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0180, 0x0000, A1, ORR_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0180, 0x0010, A1, ORR_RSR),
ARMv7_OP4(0xfff0, 0x8010, 0xeac0, 0x0000, T1, PKH),
ARMv7_OP4(0x0ff0, 0x0030, 0x0680, 0x0010, A1, PKH),
ARMv7_OP2(0xfe00, 0xbc00, T1, POP),
ARMv7_OP4(0xffff, 0x0000, 0xe8bd, 0x0000, T2, POP),
ARMv7_OP4(0xffff, 0x0fff, 0xf85d, 0x0b04, T3, POP),
ARMv7_OP4(0x0fff, 0x0000, 0x08bd, 0x0000, A1, POP),
ARMv7_OP4(0x0fff, 0x0fff, 0x049d, 0x0004, A2, POP),
ARMv7_OP2(0xfe00, 0xb400, T1, PUSH),
ARMv7_OP4(0xffff, 0x0000, 0xe92d, 0x0000, T2, PUSH), // had an error in arch ref
ARMv7_OP4(0xffff, 0x0fff, 0xf84d, 0x0d04, T3, PUSH),
ARMv7_OP4(0x0fff, 0x0000, 0x092d, 0x0000, A1, PUSH),
ARMv7_OP4(0x0fff, 0x0fff, 0x052d, 0x0004, A2, PUSH),
// TODO (Q*...)
ARMv7_OP4(0xfff0, 0xf0f0, 0xfa90, 0xf0a0, T1, RBIT),
ARMv7_OP4(0x0fff, 0x0ff0, 0x06ff, 0x0f30, A1, RBIT),
ARMv7_OP2(0xffc0, 0xba00, T1, REV),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfa90, 0xf080, T2, REV),
ARMv7_OP4(0x0fff, 0x0ff0, 0x06bf, 0x0f30, A1, REV),
ARMv7_OP2(0xffc0, 0xba40, T1, REV16),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfa90, 0xf090, T2, REV16),
ARMv7_OP4(0x0fff, 0x0ff0, 0x06bf, 0x0fb0, A1, REV16),
ARMv7_OP2(0xffc0, 0xbac0, T1, REVSH),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfa90, 0xf0b0, T2, REVSH),
ARMv7_OP4(0x0fff, 0x0ff0, 0x06ff, 0x0fb0, A1, REVSH),
ARMv7_OP4(0xffef, 0x8030, 0xea4f, 0x0030, T1, ROR_IMM),
ARMv7_OP4(0x0fef, 0x0070, 0x01a0, 0x0060, A1, ROR_IMM),
ARMv7_OP2(0xffc0, 0x41c0, T1, ROR_REG),
ARMv7_OP4(0xffe0, 0xf0f0, 0xfa60, 0xf000, T2, ROR_REG),
ARMv7_OP4(0x0fef, 0x00f0, 0x01a0, 0x0070, A1, ROR_REG),
ARMv7_OP4(0xffef, 0xf0f0, 0xea4f, 0x0030, T1, RRX),
ARMv7_OP4(0x0fef, 0x0ff0, 0x01a0, 0x0060, A1, RRX),
ARMv7_OP2(0xffc0, 0x4240, T1, RSB_IMM),
ARMv7_OP4(0xfbe0, 0x8000, 0xf1c0, 0x0000, T2, RSB_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0260, 0x0000, A1, RSB_IMM),
ARMv7_OP4(0xffe0, 0x8000, 0xebc0, 0x0000, T1, RSB_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0060, 0x0000, A1, RSB_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0060, 0x0010, A1, RSB_RSR),
ARMv7_OP4(0x0fe0, 0x0000, 0x02e0, 0x0000, A1, RSC_IMM),
ARMv7_OP4(0x0fe0, 0x0010, 0x00e0, 0x0000, A1, RSC_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x00e0, 0x0010, A1, RSC_RSR),
// TODO (SADD16, SADD8, SASX)
ARMv7_OP4(0xfbe0, 0x8000, 0xf160, 0x0000, T1, SBC_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x02c0, 0x0000, A1, SBC_IMM),
ARMv7_OP2(0xffc0, 0x4180, T1, SBC_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xeb60, 0x0000, T2, SBC_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x00c0, 0x0000, A1, SBC_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x00c0, 0x0010, A1, SBC_RSR),
ARMv7_OP4(0xfff0, 0x8020, 0xf340, 0x0000, T1, SBFX),
ARMv7_OP4(0x0fe0, 0x0070, 0x07a0, 0x0050, A1, SBFX),
ARMv7_OP4(0xfff0, 0xf0f0, 0xfb90, 0xf0f0, T1, SDIV), // ???
ARMv7_OP4(0xfff0, 0xf0f0, 0xfaa0, 0xf080, T1, SEL),
ARMv7_OP4(0x0ff0, 0x0ff0, 0x0680, 0x0fb0, A1, SEL),
// TODO (SH*, SM*, SS*)
ARMv7_OP2(0xf800, 0xc000, T1, STM),
ARMv7_OP4(0xffd0, 0xa000, 0xe880, 0x0000, T2, STM),
ARMv7_OP4(0x0fd0, 0x0000, 0x0880, 0x0000, A1, STM),
ARMv7_OP4(0x0fd0, 0x0000, 0x0800, 0x0000, A1, STMDA),
ARMv7_OP4(0xffd0, 0xa000, 0xe900, 0x0000, T1, STMDB),
ARMv7_OP4(0x0fd0, 0x0000, 0x0900, 0x0000, A1, STMDB),
ARMv7_OP4(0x0fd0, 0x0000, 0x0980, 0x0000, A1, STMIB),
ARMv7_OP2(0xf800, 0x6000, T1, STR_IMM),
ARMv7_OP2(0xf800, 0x9000, T2, STR_IMM),
ARMv7_OP4(0xfff0, 0x0000, 0xf8c0, 0x0000, T3, STR_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf840, 0x0800, T4, STR_IMM),
ARMv7_OP4(0x0e50, 0x0000, 0x0400, 0x0000, A1, STR_IMM),
ARMv7_OP2(0xfe00, 0x5000, T1, STR_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf840, 0x0000, T2, STR_REG),
ARMv7_OP4(0x0e50, 0x0010, 0x0600, 0x0000, A1, STR_REG),
ARMv7_OP2(0xf800, 0x7000, T1, STRB_IMM),
ARMv7_OP4(0xfff0, 0x0000, 0xf880, 0x0000, T2, STRB_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf800, 0x0800, T3, STRB_IMM),
ARMv7_OP4(0x0e50, 0x0000, 0x0440, 0x0000, A1, STRB_IMM),
ARMv7_OP2(0xfe00, 0x5400, T1, STRB_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf800, 0x0000, T2, STRB_REG),
ARMv7_OP4(0x0e50, 0x0010, 0x0640, 0x0000, A1, STRB_REG),
ARMv7_OP4(0xfe50, 0x0000, 0xe840, 0x0000, T1, STRD_IMM),
ARMv7_OP4(0x0e50, 0x00f0, 0x0040, 0x00f0, A1, STRD_IMM),
ARMv7_OP4(0x0e50, 0x0ff0, 0x0000, 0x00f0, A1, STRD_REG),
ARMv7_OP2(0xf800, 0x8000, T1, STRH_IMM),
ARMv7_OP4(0xfff0, 0x0000, 0xf8a0, 0x0000, T2, STRH_IMM),
ARMv7_OP4(0xfff0, 0x0800, 0xf820, 0x0800, T3, STRH_IMM),
ARMv7_OP4(0x0e50, 0x00f0, 0x0040, 0x00b0, A1, STRH_IMM),
ARMv7_OP2(0xfe00, 0x5200, T1, STRH_REG),
ARMv7_OP4(0xfff0, 0x0fc0, 0xf820, 0x0000, T2, STRH_REG),
ARMv7_OP4(0x0e50, 0x0ff0, 0x0000, 0x00b0, A1, STRH_REG),
ARMv7_OP2(0xff80, 0xb080, T1, SUB_SPI),
ARMv7_OP4(0xfbef, 0x8000, 0xf1ad, 0x0000, T2, SUB_SPI),
ARMv7_OP4(0xfbff, 0x8000, 0xf2ad, 0x0000, T3, SUB_SPI),
ARMv7_OP4(0x0fef, 0x0000, 0x024d, 0x0000, A1, SUB_SPI),
ARMv7_OP4(0xffef, 0x8000, 0xebad, 0x0000, T1, SUB_SPR),
ARMv7_OP4(0x0fef, 0x0010, 0x004d, 0x0000, A1, SUB_SPR),
ARMv7_OP2(0xfe00, 0x1e00, T1, SUB_IMM),
ARMv7_OP2(0xf800, 0x3800, T2, SUB_IMM),
ARMv7_OP4(0xfbe0, 0x8000, 0xf1a0, 0x0000, T3, SUB_IMM),
ARMv7_OP4(0xfbf0, 0x8000, 0xf2a0, 0x0000, T4, SUB_IMM),
ARMv7_OP4(0x0fe0, 0x0000, 0x0240, 0x0000, A1, SUB_IMM),
ARMv7_OP2(0xfe00, 0x1a00, T1, SUB_REG),
ARMv7_OP4(0xffe0, 0x8000, 0xeba0, 0x0000, T2, SUB_REG),
ARMv7_OP4(0x0fe0, 0x0010, 0x0040, 0x0000, A1, SUB_REG),
ARMv7_OP4(0x0fe0, 0x0090, 0x0040, 0x0010, A1, SUB_RSR),
ARMv7_OP2(0xff00, 0xdf00, T1, SVC),
ARMv7_OP4(0x0f00, 0x0000, 0x0f00, 0x0000, A1, SVC),
// TODO (SX*)
ARMv7_OP4(0xfff0, 0xffe0, 0xe8d0, 0xf000, T1, TB_),
ARMv7_OP4(0xfbf0, 0x8f00, 0xf090, 0x0f00, T1, TEQ_IMM),
ARMv7_OP4(0x0ff0, 0xf000, 0x0330, 0x0000, A1, TEQ_IMM),
ARMv7_OP4(0xfff0, 0x8f00, 0xea90, 0x0f00, T1, TEQ_REG),
ARMv7_OP4(0x0ff0, 0xf010, 0x0130, 0x0000, A1, TEQ_REG),
ARMv7_OP4(0x0ff0, 0xf090, 0x0130, 0x0010, A1, TEQ_RSR),
ARMv7_OP4(0xfbf0, 0x8f00, 0xf010, 0x0f00, T1, TST_IMM),
ARMv7_OP4(0x0ff0, 0xf000, 0x0310, 0x0000, A1, TST_IMM),
ARMv7_OP2(0xffc0, 0x4200, T1, TST_REG),
ARMv7_OP4(0xfff0, 0x8f00, 0xea10, 0x0f00, T2, TST_REG),
ARMv7_OP4(0x0ff0, 0xf010, 0x0110, 0x0000, A1, TST_REG),
ARMv7_OP4(0x0ff0, 0xf090, 0x0110, 0x0010, A1, TST_RSR),
// TODO (U*, V*)
};
#undef ARMv7_OP
#undef ARMv7_OPP

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

@ -18,6 +18,8 @@ void ARMv7Thread::InitRegs()
memset(GPR, 0, sizeof(GPR[0]) * 15);
APSR.APSR = 0;
IPSR.IPSR = 0;
ISET = Thumb;
ITSTATE.IT = 0;
SP = m_stack_addr + m_stack_size;
}
@ -30,9 +32,9 @@ void ARMv7Thread::InitStack()
}
}
void ARMv7Thread::SetArg(const uint pos, const u64 arg)
u32 ARMv7Thread::GetStackArg(u32 pos)
{
assert(0);
return vm::psv::read32(SP + sizeof(u32) * (pos - 5));
}
std::string ARMv7Thread::RegsToString()

48
rpcs3/Emu/ARMv7/ARMv7Thread.h
View File

@ -1,6 +1,14 @@
#pragma once
#include "Emu/CPU/CPUThread.h"
enum ARMv7InstructionSet
{
ARM,
Thumb,
Jazelle,
ThumbEE,
};
class ARMv7Thread : public CPUThread
{
public:
@ -38,6 +46,7 @@ public:
};
u32 APSR;
} APSR;
union
@ -49,8 +58,41 @@ public:
};
u32 IPSR;
} IPSR;
ARMv7InstructionSet ISET;
union
{
struct
{
u8 cond : 3;
u8 state : 5;
};
u8 IT;
u32 advance()
{
const u32 res = (state & 0xf) ? (cond << 1 | state >> 4) : 0xe /* true */;
state <<= 1;
if ((state & 0xf) == 0) // if no d
{
IT = 0; // clear ITSTATE
}
return res;
}
operator bool() const
{
return (state & 0xf) != 0;
}
} ITSTATE;
void write_gpr(u32 n, u32 value)
{
assert(n < 16);
@ -61,7 +103,7 @@ public:
}
else
{
SetBranch(value);
SetBranch(value & ~1);
}
}
@ -80,7 +122,7 @@ public:
public:
virtual void InitRegs();
virtual void InitStack();
virtual void SetArg(const uint pos, const u64 arg);
u32 GetStackArg(u32 pos);
public:
virtual std::string RegsToString();
@ -95,4 +137,4 @@ protected:
virtual void DoStop();
virtual void DoCode();
};
};

401
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp Normal file
View File

@ -0,0 +1,401 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibKernel;
typedef s32(*SceKernelThreadEntry)(u32 argSize, vm::psv::ptr<void> pArgBlock);
struct SceKernelThreadOptParam
{
u32 size;
u32 attr;
};
s32 sceKernelCreateThread(
vm::psv::ptr<const char> pName,
vm::psv::ptr<SceKernelThreadEntry> entry,
s32 initPriority,
u32 stackSize,
u32 attr,
s32 cpuAffinityMask,
vm::psv::ptr<const SceKernelThreadOptParam> pOptParam)
{
sceLibKernel.Todo("sceKernelCreateThread(pName_addr=0x%x ('%s'), entry_addr=0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam_addr=0x%x)",
pName.addr(), pName.get_ptr(), entry.addr(), initPriority, stackSize, attr, cpuAffinityMask, pOptParam.addr());
return SCE_OK;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibKernel, #name, &name)
psv_log_base sceLibKernel = []() -> psv_log_base
{
//REG_FUNC(0x23EAA62, sceKernelPuts);
//REG_FUNC(0xB0335388, sceClibToupper);
//REG_FUNC(0x4C5471BC, sceClibTolower);
//REG_FUNC(0xD8EBBB7E, sceClibLookCtypeTable);
//REG_FUNC(0x20EC3210, sceClibGetCtypeTable);
//REG_FUNC(0x407D6153, sceClibMemchr);
//REG_FUNC(0x9CC2BFDF, sceClibMemcmp);
//REG_FUNC(0x14E9DBD7, sceClibMemcpy);
//REG_FUNC(0x736753C8, sceClibMemmove);
//REG_FUNC(0x632980D7, sceClibMemset);
//REG_FUNC(0xFA26BC62, sceClibPrintf);
//REG_FUNC(0x5EA3B6CE, sceClibVprintf);
//REG_FUNC(0x8CBA03D5, sceClibSnprintf);
//REG_FUNC(0xFA6BE467, sceClibVsnprintf);
//REG_FUNC(0xA2FB4D9D, sceClibStrcmp);
//REG_FUNC(0x70CBC2D5, sceClibStrlcat);
//REG_FUNC(0x2CDFCD1C, sceClibStrlcpy);
//REG_FUNC(0xA37E6383, sceClibStrncat);
//REG_FUNC(0x660D1F6D, sceClibStrncmp);
//REG_FUNC(0xC458D60A, sceClibStrncpy);
//REG_FUNC(0xAC595E68, sceClibStrnlen);
//REG_FUNC(0x614076B7, sceClibStrchr);
//REG_FUNC(0x6E728AAE, sceClibStrrchr);
//REG_FUNC(0xE265498B, sceClibStrstr);
//REG_FUNC(0xB54C0BE4, sceClibStrncasecmp);
//REG_FUNC(0x2F2C6046, sceClibAbort);
//REG_FUNC(0x2E581B88, sceClibStrtoll);
//REG_FUNC(0x3B9E301A, sceClibMspaceCreate);
//REG_FUNC(0xAE1A21EC, sceClibMspaceDestroy);
//REG_FUNC(0x86EF7680, sceClibMspaceMalloc);
//REG_FUNC(0x9C56B4D1, sceClibMspaceFree);
//REG_FUNC(0x678374AD, sceClibMspaceCalloc);
//REG_FUNC(0x3C847D57, sceClibMspaceMemalign);
//REG_FUNC(0x774891D6, sceClibMspaceRealloc);
//REG_FUNC(0x586AC68D, sceClibMspaceReallocalign);
//REG_FUNC(0x46A02279, sceClibMspaceMallocUsableSize);
//REG_FUNC(0x8CC1D38E, sceClibMspaceMallocStats);
//REG_FUNC(0x738E0322, sceClibMspaceMallocStatsFast);
//REG_FUNC(0xD1D59701, sceClibMspaceIsHeapEmpty);
//REG_FUNC(0xE960FDA2, sceKernelAtomicSet8);
//REG_FUNC(0x450BFECF, sceKernelAtomicSet16);
//REG_FUNC(0xB69DA09B, sceKernelAtomicSet32);
//REG_FUNC(0xC8A4339C, sceKernelAtomicSet64);
//REG_FUNC(0x27A2AAFA, sceKernelAtomicGetAndAdd8);
//REG_FUNC(0x5674DB0C, sceKernelAtomicGetAndAdd16);
//REG_FUNC(0x2611CB0B, sceKernelAtomicGetAndAdd32);
//REG_FUNC(0x63DAF37D, sceKernelAtomicGetAndAdd64);
//REG_FUNC(0x8F7BD940, sceKernelAtomicAddAndGet8);
//REG_FUNC(0x495C52EC, sceKernelAtomicAddAndGet16);
//REG_FUNC(0x2E84A93B, sceKernelAtomicAddAndGet32);
//REG_FUNC(0xB6CE9B9A, sceKernelAtomicAddAndGet64);
//REG_FUNC(0xCDF5DF67, sceKernelAtomicGetAndSub8);
//REG_FUNC(0xAC51979C, sceKernelAtomicGetAndSub16);
//REG_FUNC(0x115C516F, sceKernelAtomicGetAndSub32);
//REG_FUNC(0x4AE9C8E6, sceKernelAtomicGetAndSub64);
//REG_FUNC(0x99E1796E, sceKernelAtomicSubAndGet8);
//REG_FUNC(0xC26BBBB1, sceKernelAtomicSubAndGet16);
//REG_FUNC(0x1C9CD92, sceKernelAtomicSubAndGet32);
//REG_FUNC(0x9BB4A94B, sceKernelAtomicSubAndGet64);
//REG_FUNC(0x53DCA02B, sceKernelAtomicGetAndAnd8);
//REG_FUNC(0x7A0CB056, sceKernelAtomicGetAndAnd16);
//REG_FUNC(0x8266595, sceKernelAtomicGetAndAnd32);
//REG_FUNC(0x4828BC43, sceKernelAtomicGetAndAnd64);
//REG_FUNC(0x86B9170F, sceKernelAtomicAndAndGet8);
//REG_FUNC(0xF9890F7E, sceKernelAtomicAndAndGet16);
//REG_FUNC(0x6709D30C, sceKernelAtomicAndAndGet32);
//REG_FUNC(0xAED2B370, sceKernelAtomicAndAndGet64);
//REG_FUNC(0x107A68DF, sceKernelAtomicGetAndOr8);
//REG_FUNC(0x31E49E73, sceKernelAtomicGetAndOr16);
//REG_FUNC(0x984AD276, sceKernelAtomicGetAndOr32);
//REG_FUNC(0xC39186CD, sceKernelAtomicGetAndOr64);
//REG_FUNC(0x51693931, sceKernelAtomicOrAndGet8);
//REG_FUNC(0x8E248EBD, sceKernelAtomicOrAndGet16);
//REG_FUNC(0xC3B2F7F8, sceKernelAtomicOrAndGet32);
//REG_FUNC(0x809BBC7D, sceKernelAtomicOrAndGet64);
//REG_FUNC(0x7350B2DF, sceKernelAtomicGetAndXor8);
//REG_FUNC(0x6E2D0B9E, sceKernelAtomicGetAndXor16);
//REG_FUNC(0x38739E2F, sceKernelAtomicGetAndXor32);
//REG_FUNC(0x6A19BBE9, sceKernelAtomicGetAndXor64);
//REG_FUNC(0x634AF062, sceKernelAtomicXorAndGet8);
//REG_FUNC(0x6F524195, sceKernelAtomicXorAndGet16);
//REG_FUNC(0x46940704, sceKernelAtomicXorAndGet32);
//REG_FUNC(0xDDC6866E, sceKernelAtomicXorAndGet64);
//REG_FUNC(0x327DB4C0, sceKernelAtomicCompareAndSet8);
//REG_FUNC(0xE8C01236, sceKernelAtomicCompareAndSet16);
//REG_FUNC(0x1124A1D4, sceKernelAtomicCompareAndSet32);
//REG_FUNC(0x1EBDFCCD, sceKernelAtomicCompareAndSet64);
//REG_FUNC(0xD7D49E36, sceKernelAtomicClearMask8);
//REG_FUNC(0x5FE7DFF8, sceKernelAtomicClearMask16);
//REG_FUNC(0xE3DF0CB3, sceKernelAtomicClearMask32);
//REG_FUNC(0x953D118A, sceKernelAtomicClearMask64);
//REG_FUNC(0x7FD94393, sceKernelAtomicAddUnless8);
//REG_FUNC(0x1CF4AA4B, sceKernelAtomicAddUnless16);
//REG_FUNC(0x4B33FD3C, sceKernelAtomicAddUnless32);
//REG_FUNC(0xFFCE7438, sceKernelAtomicAddUnless64);
//REG_FUNC(0x9DABE6C3, sceKernelAtomicDecIfPositive8);
//REG_FUNC(0x323718FB, sceKernelAtomicDecIfPositive16);
//REG_FUNC(0xCA3294F1, sceKernelAtomicDecIfPositive32);
//REG_FUNC(0x8BE2A007, sceKernelAtomicDecIfPositive64);
//REG_FUNC(0xBBE82155, sceKernelLoadModule);
//REG_FUNC(0x2DCC4AFA, sceKernelLoadStartModule);
//REG_FUNC(0x702425D5, sceKernelStartModule);
//REG_FUNC(0x3B2CBA09, sceKernelStopModule);
//REG_FUNC(0x1987920E, sceKernelUnloadModule);
//REG_FUNC(0x2415F8A4, sceKernelStopUnloadModule);
//REG_FUNC(0x15E2A45D, sceKernelCallModuleExit);
//REG_FUNC(0xD11A5103, sceKernelGetModuleInfoByAddr);
//REG_FUNC(0x4F2D8B15, sceKernelOpenModule);
//REG_FUNC(0x657FA50E, sceKernelCloseModule);
//REG_FUNC(0x7595D9AA, sceKernelExitProcess);
//REG_FUNC(0x4C7AD128, sceKernelPowerLock);
//REG_FUNC(0xAF8E9C11, sceKernelPowerUnlock);
//REG_FUNC(0xB295EB61, sceKernelGetTLSAddr);
//REG_FUNC(0xFB972F9, sceKernelGetThreadId);
//REG_FUNC(0xA37A6057, sceKernelGetCurrentThreadVfpException);
//REG_FUNC(0xCA71EA2, sceKernelSendMsgPipe);
//REG_FUNC(0xA5CA74AC, sceKernelSendMsgPipeCB);
//REG_FUNC(0xDFC670E0, sceKernelTrySendMsgPipe);
//REG_FUNC(0x4E81DD5C, sceKernelReceiveMsgPipe);
//REG_FUNC(0x33AF829B, sceKernelReceiveMsgPipeCB);
//REG_FUNC(0x5615B006, sceKernelTryReceiveMsgPipe);
//REG_FUNC(0xA7819967, sceKernelLockLwMutex);
//REG_FUNC(0x6F9C4CC1, sceKernelLockLwMutexCB);
//REG_FUNC(0x9EF798C1, sceKernelTryLockLwMutex);
//REG_FUNC(0x499EA781, sceKernelUnlockLwMutex);
//REG_FUNC(0xF7D8F1FC, sceKernelGetLwMutexInfo);
//REG_FUNC(0xDDB395A9, sceKernelWaitThreadEnd);
//REG_FUNC(0xC54941ED, sceKernelWaitThreadEndCB);
//REG_FUNC(0xD5DC26C4, sceKernelGetThreadExitStatus);
//REG_FUNC(0x4373B548, __sce_aeabi_idiv0);
//REG_FUNC(0xFB235848, __sce_aeabi_ldiv0);
//REG_FUNC(0xF08DE149, sceKernelStartThread);
//REG_FUNC(0x58DDAC4F, sceKernelDeleteThread);
//REG_FUNC(0x5150577B, sceKernelChangeThreadCpuAffinityMask);
//REG_FUNC(0x8C57AC2A, sceKernelGetThreadCpuAffinityMask);
//REG_FUNC(0xDF7E6EDA, sceKernelChangeThreadPriority);
//REG_FUNC(0xBCB63B66, sceKernelGetThreadStackFreeSize);
//REG_FUNC(0x8D9C5461, sceKernelGetThreadInfo);
//REG_FUNC(0xD6B01013, sceKernelGetThreadRunStatus);
//REG_FUNC(0xE0241FAA, sceKernelGetSystemInfo);
//REG_FUNC(0xF994FE65, sceKernelGetThreadmgrUIDClass);
//REG_FUNC(0xB4DE10C7, sceKernelGetActiveCpuMask);
//REG_FUNC(0x2C1321A3, sceKernelChangeThreadVfpException);
//REG_FUNC(0x3849359A, sceKernelCreateCallback);
//REG_FUNC(0x88DD1BC8, sceKernelGetCallbackInfo);
//REG_FUNC(0x464559D3, sceKernelDeleteCallback);
//REG_FUNC(0xBD9C8F2B, sceKernelNotifyCallback);
//REG_FUNC(0x3137A687, sceKernelCancelCallback);
//REG_FUNC(0x76A2EF81, sceKernelGetCallbackCount);
//REG_FUNC(0xD4F75281, sceKernelRegisterCallbackToEvent);
//REG_FUNC(0x8D3940DF, sceKernelUnregisterCallbackFromEvent);
//REG_FUNC(0x2BD1E682, sceKernelUnregisterCallbackFromEventAll);
//REG_FUNC(0x120F03AF, sceKernelWaitEvent);
//REG_FUNC(0xA0490795, sceKernelWaitEventCB);
//REG_FUNC(0x241F3634, sceKernelPollEvent);
//REG_FUNC(0x603AB770, sceKernelCancelEvent);
//REG_FUNC(0x10586418, sceKernelWaitMultipleEvents);
//REG_FUNC(0x4263DBC9, sceKernelWaitMultipleEventsCB);
//REG_FUNC(0x8516D040, sceKernelCreateEventFlag);
//REG_FUNC(0x11FE9B8B, sceKernelDeleteEventFlag);
//REG_FUNC(0xE04EC73A, sceKernelOpenEventFlag);
//REG_FUNC(0x9C0B8285, sceKernelCloseEventFlag);
//REG_FUNC(0x83C0E2AF, sceKernelWaitEventFlag);
//REG_FUNC(0xE737B1DF, sceKernelWaitEventFlagCB);
//REG_FUNC(0x1FBB0FE1, sceKernelPollEventFlag);
//REG_FUNC(0x2A12D9B7, sceKernelCancelEventFlag);
//REG_FUNC(0x8BA4C0C1, sceKernelGetEventFlagInfo);
//REG_FUNC(0x9EF9C0C5, sceKernelSetEventFlag);
//REG_FUNC(0xD018793F, sceKernelClearEventFlag);
//REG_FUNC(0x297AA2AE, sceKernelCreateSema);
//REG_FUNC(0xC08F5BC5, sceKernelDeleteSema);
//REG_FUNC(0xB028AB78, sceKernelOpenSema);
//REG_FUNC(0x817707AB, sceKernelCloseSema);
//REG_FUNC(0xC7B834B, sceKernelWaitSema);
//REG_FUNC(0x174692B4, sceKernelWaitSemaCB);
//REG_FUNC(0x66D6BF05, sceKernelCancelSema);
//REG_FUNC(0x595D3FA6, sceKernelGetSemaInfo);
//REG_FUNC(0x3012A9C6, sceKernelPollSema);
//REG_FUNC(0x2053A496, sceKernelSignalSema);
//REG_FUNC(0xED53334A, sceKernelCreateMutex);
//REG_FUNC(0x12D11F65, sceKernelDeleteMutex);
//REG_FUNC(0x16B85235, sceKernelOpenMutex);
//REG_FUNC(0x43DDC9CC, sceKernelCloseMutex);
//REG_FUNC(0x1D8D7945, sceKernelLockMutex);
//REG_FUNC(0x2BDAA524, sceKernelLockMutexCB);
//REG_FUNC(0x2144890D, sceKernelCancelMutex);
//REG_FUNC(0x9A6C43CA, sceKernelGetMutexInfo);
//REG_FUNC(0xE5901FF9, sceKernelTryLockMutex);
//REG_FUNC(0x34746309, sceKernelUnlockMutex);
//REG_FUNC(0x50572FDA, sceKernelCreateCond);
//REG_FUNC(0xFD295414, sceKernelDeleteCond);
//REG_FUNC(0xCB2A73A9, sceKernelOpenCond);
//REG_FUNC(0x4FB91A89, sceKernelCloseCond);
//REG_FUNC(0xC88D44AD, sceKernelWaitCond);
//REG_FUNC(0x4CE42CE2, sceKernelWaitCondCB);
//REG_FUNC(0x6864DCE2, sceKernelGetCondInfo);
//REG_FUNC(0x10A4976F, sceKernelSignalCond);
//REG_FUNC(0x2EB86929, sceKernelSignalCondAll);
//REG_FUNC(0x87629E6, sceKernelSignalCondTo);
//REG_FUNC(0xA10C1C8, sceKernelCreateMsgPipe);
//REG_FUNC(0x69F6575D, sceKernelDeleteMsgPipe);
//REG_FUNC(0x230691DA, sceKernelOpenMsgPipe);
//REG_FUNC(0x7E5C0C16, sceKernelCloseMsgPipe);
//REG_FUNC(0x94D506F7, sceKernelSendMsgPipeVector);
//REG_FUNC(0x9C6F7F79, sceKernelSendMsgPipeVectorCB);
//REG_FUNC(0x60DB346F, sceKernelTrySendMsgPipeVector);
//REG_FUNC(0x9F899087, sceKernelReceiveMsgPipeVector);
//REG_FUNC(0xBE5B3E27, sceKernelReceiveMsgPipeVectorCB);
//REG_FUNC(0x86ECC0FF, sceKernelTryReceiveMsgPipeVector);
//REG_FUNC(0xEF14BA37, sceKernelCancelMsgPipe);
//REG_FUNC(0x4046D16B, sceKernelGetMsgPipeInfo);
//REG_FUNC(0xDA6EC8EF, sceKernelCreateLwMutex);
//REG_FUNC(0x244E76D2, sceKernelDeleteLwMutex);
//REG_FUNC(0x4846613D, sceKernelGetLwMutexInfoById);
//REG_FUNC(0x48C7EAE6, sceKernelCreateLwCond);
//REG_FUNC(0x721F6CB3, sceKernelDeleteLwCond);
//REG_FUNC(0xE1878282, sceKernelWaitLwCond);
//REG_FUNC(0x8FA54B07, sceKernelWaitLwCondCB);
//REG_FUNC(0x3AC63B9A, sceKernelSignalLwCond);
//REG_FUNC(0xE5241A0C, sceKernelSignalLwCondAll);
//REG_FUNC(0xFC1A48EB, sceKernelSignalLwCondTo);
//REG_FUNC(0xE4DF36A0, sceKernelGetLwCondInfo);
//REG_FUNC(0x971F1DE8, sceKernelGetLwCondInfoById);
//REG_FUNC(0x2255B2A5, sceKernelCreateTimer);
//REG_FUNC(0x746F3290, sceKernelDeleteTimer);
//REG_FUNC(0x2F3D35A3, sceKernelOpenTimer);
//REG_FUNC(0x17283DE6, sceKernelCloseTimer);
//REG_FUNC(0x1478249B, sceKernelStartTimer);
//REG_FUNC(0x75B1329, sceKernelStopTimer);
//REG_FUNC(0x1F59E04D, sceKernelGetTimerBase);
//REG_FUNC(0x3223CCD1, sceKernelGetTimerBaseWide);
//REG_FUNC(0x381DC300, sceKernelGetTimerTime);
//REG_FUNC(0x53C5D833, sceKernelGetTimerTimeWide);
//REG_FUNC(0xFFAD717F, sceKernelSetTimerTime);
//REG_FUNC(0xAF67678B, sceKernelSetTimerTimeWide);
//REG_FUNC(0x621D293B, sceKernelSetTimerEvent);
//REG_FUNC(0x9CCF768C, sceKernelCancelTimer);
//REG_FUNC(0x7E35E10A, sceKernelGetTimerInfo);
//REG_FUNC(0x8667951D, sceKernelCreateRWLock);
//REG_FUNC(0x3D750204, sceKernelDeleteRWLock);
//REG_FUNC(0xBA4DAC9A, sceKernelOpenRWLock);
//REG_FUNC(0xA7F94E64, sceKernelCloseRWLock);
//REG_FUNC(0xFA670F0F, sceKernelLockReadRWLock);
//REG_FUNC(0x2D4A62B7, sceKernelLockReadRWLockCB);
//REG_FUNC(0x1B8586C0, sceKernelTryLockReadRWLock);
//REG_FUNC(0x675D10A8, sceKernelUnlockReadRWLock);
//REG_FUNC(0x67A187BB, sceKernelLockWriteRWLock);
//REG_FUNC(0xA4777082, sceKernelLockWriteRWLockCB);
//REG_FUNC(0x597D4607, sceKernelTryLockWriteRWLock);
//REG_FUNC(0xD9369DF2, sceKernelUnlockWriteRWLock);
//REG_FUNC(0x190CA94B, sceKernelCancelRWLock);
//REG_FUNC(0x79A573B, sceKernelGetRWLockInfo);
//REG_FUNC(0x8AF15B5F, sceKernelGetSystemTime);
//REG_FUNC(0x99B2BF15, sceKernelPMonThreadGetCounter);
//REG_FUNC(0x7C21C961, sceKernelPMonCpuGetCounter);
//REG_FUNC(0xADCA94E5, sceKernelWaitSignal);
//REG_FUNC(0x24460BB3, sceKernelWaitSignalCB);
//REG_FUNC(0x7BE9C4C8, sceKernelSendSignal);
REG_FUNC(0xC5C11EE7, sceKernelCreateThread);
//REG_FUNC(0x6C60AC61, sceIoOpen);
//REG_FUNC(0xF5C6F098, sceIoClose);
//REG_FUNC(0x713523E1, sceIoRead);
//REG_FUNC(0x11FED231, sceIoWrite);
//REG_FUNC(0x99BA173E, sceIoLseek);
//REG_FUNC(0x5CC983AC, sceIoLseek32);
//REG_FUNC(0xE20ED0F3, sceIoRemove);
//REG_FUNC(0xF737E369, sceIoRename);
//REG_FUNC(0x9670D39F, sceIoMkdir);
//REG_FUNC(0xE9F91EC8, sceIoRmdir);
//REG_FUNC(0xA9283DD0, sceIoDopen);
//REG_FUNC(0x9DFF9C59, sceIoDclose);
//REG_FUNC(0x9C8B6624, sceIoDread);
//REG_FUNC(0xBCA5B623, sceIoGetstat);
//REG_FUNC(0x29482F7F, sceIoChstat);
//REG_FUNC(0x98ACED6D, sceIoSync);
//REG_FUNC(0x4B30CB2, sceIoDevctl);
//REG_FUNC(0x54ABACFA, sceIoIoctl);
//REG_FUNC(0x6A7EA9FD, sceIoOpenAsync);
//REG_FUNC(0x84201C9B, sceIoCloseAsync);
//REG_FUNC(0x7B3BE857, sceIoReadAsync);
//REG_FUNC(0x21329B20, sceIoWriteAsync);
//REG_FUNC(0xCAC5D672, sceIoLseekAsync);
//REG_FUNC(0x99C54B9, sceIoIoctlAsync);
//REG_FUNC(0x446A60AC, sceIoRemoveAsync);
//REG_FUNC(0x73FC184B, sceIoDopenAsync);
//REG_FUNC(0x4D0597D7, sceIoDcloseAsync);
//REG_FUNC(0xCE32490D, sceIoDreadAsync);
//REG_FUNC(0x8E5FCBB1, sceIoMkdirAsync);
//REG_FUNC(0x9694D00F, sceIoRmdirAsync);
//REG_FUNC(0xEE9857CD, sceIoRenameAsync);
//REG_FUNC(0x9739A5E2, sceIoChstatAsync);
//REG_FUNC(0x82B20B41, sceIoGetstatAsync);
//REG_FUNC(0x950F78EB, sceIoDevctlAsync);
//REG_FUNC(0xF7C7FBFE, sceIoSyncAsync);
//REG_FUNC(0xEC96EA71, sceIoCancel);
//REG_FUNC(0x857E0C71, sceIoComplete);
//REG_FUNC(0x52315AD7, sceIoPread);
//REG_FUNC(0x8FFFF5A8, sceIoPwrite);
//REG_FUNC(0xA010141E, sceIoPreadAsync);
//REG_FUNC(0xED25BEEF, sceIoPwriteAsync);
//REG_FUNC(0xA792C404, sceIoCompleteMultiple);
//REG_FUNC(0x894037E8, sceKernelBacktrace);
//REG_FUNC(0x20E2D4B7, sceKernelPrintBacktrace);
//REG_FUNC(0x963F4A99, sceSblACMgrIsGameProgram);
//REG_FUNC(0x261E2C34, sceKernelGetOpenPsId);
/* SceModulemgr */
//REG_FUNC(0x36585DAF, sceKernelGetModuleInfo);
//REG_FUNC(0x2EF2581F, sceKernelGetModuleList);
//REG_FUNC(0xF5798C7C, sceKernelGetModuleIdByAddr);
/* SceProcessmgr */
//REG_FUNC(0xCD248267, sceKernelGetCurrentProcess);
//REG_FUNC(0x2252890C, sceKernelPowerTick);
//REG_FUNC(0x9E45DA09, sceKernelLibcClock);
//REG_FUNC(0x39BE45, sceKernelLibcTime);
//REG_FUNC(0x4B879059, sceKernelLibcGettimeofday);
//REG_FUNC(0xC1727F59, sceKernelGetStdin);
//REG_FUNC(0xE5AA625C, sceKernelGetStdout);
//REG_FUNC(0xFA5E3ADA, sceKernelGetStderr);
//REG_FUNC(0xE6E9FCA3, sceKernelGetRemoteProcessTime);
//REG_FUNC(0xD37A8437, sceKernelGetProcessTime);
//REG_FUNC(0xF5D0D4C6, sceKernelGetProcessTimeLow);
//REG_FUNC(0x89DA0967, sceKernelGetProcessTimeWide);
//REG_FUNC(0x2BE3E066, sceKernelGetProcessParam);
/* SceStdio */
//REG_FUNC(0x54237407, sceKernelStdin);
//REG_FUNC(0x9033E9BD, sceKernelStdout);
//REG_FUNC(0x35EE7CF5, sceKernelStderr);
/* SceSysmem */
//REG_FUNC(0xB9D5EBDE, sceKernelAllocMemBlock);
//REG_FUNC(0xA91E15EE, sceKernelFreeMemBlock);
//REG_FUNC(0xB8EF5818, sceKernelGetMemBlockBase);
//REG_FUNC(0x3B29E0F5, sceKernelRemapMemBlock);
//REG_FUNC(0xA33B99D1, sceKernelFindMemBlockByAddr);
//REG_FUNC(0x4010AD65, sceKernelGetMemBlockInfoByAddr);
/* SceCpu */
//REG_FUNC(0x2704CFEE, sceKernelCpuId);
/* SceDipsw */
//REG_FUNC(0x1C783FB2, sceKernelCheckDipsw);
//REG_FUNC(0x817053D4, sceKernelSetDipsw);
//REG_FUNC(0x800EDCC1, sceKernelClearDipsw);
/* SceThreadmgr */
//REG_FUNC(0xC8A38E1, sceKernelExitThread);
//REG_FUNC(0x1D17DECF, sceKernelExitDeleteThread);
//REG_FUNC(0x4B675D05, sceKernelDelayThread);
//REG_FUNC(0x9C0180E1, sceKernelDelayThreadCB);
//REG_FUNC(0x1173F8, sceKernelChangeActiveCpuMask);
//REG_FUNC(0x1414F0B, sceKernelGetThreadCurrentPriority);
//REG_FUNC(0x751C9B7A, sceKernelChangeCurrentThreadAttr);
//REG_FUNC(0xD9BD74EB, sceKernelCheckWaitableStatus);
//REG_FUNC(0x9DCB4B7A, sceKernelGetProcessId);
//REG_FUNC(0xE53E41F6, sceKernelCheckCallback);
//REG_FUNC(0xF4EE4FA9, sceKernelGetSystemTimeWide);
//REG_FUNC(0x47F6DE49, sceKernelGetSystemTimeLow);
//REG_FUNC(0xC0FAF6A3, sceKernelCreateThreadForUser);
/* SceDebugLed */
//REG_FUNC(0x78E702D3, sceKernelSetGPO);
return psv_log_base("sceLibKernel");
}();

352
rpcs3/Emu/ARMv7/Modules/sceLibc.cpp Normal file
View File

@ -0,0 +1,352 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibc;
namespace sce_libc_func
{
void __cxa_atexit()
{
sceLibc.Todo(__FUNCTION__);
Emu.Pause();
}
void exit()
{
sceLibc.Error("exit()");
Emu.Pause();
sceLibc.Success("Process finished");
CallAfter([]()
{
Emu.Stop();
});
}
void printf(vm::psv::ptr<const char> fmt)
{
sceLibc.Error("printf(fmt_addr=0x%x)", fmt.addr());
LOG_NOTICE(TTY, "%s", fmt.get_ptr());
}
void __cxa_set_dso_handle_main()
{
sceLibc.Error("__cxa_set_dso_handle_main()");
}
void memcpy(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 size)
{
sceLibc.Error("memcpy(dst_addr=0x%x, src_addr=0x%x, size=0x%x)", dst.addr(), src.addr(), size);
::memcpy(dst.get_ptr(), src.get_ptr(), size);
}
void _Assert()
{
sceLibc.Todo(__FUNCTION__);
Emu.Pause();
}
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibc, #name, &sce_libc_func::name)
psv_log_base sceLibc = []() -> psv_log_base
{
REG_FUNC(0xE4531F85, _Assert);
//REG_FUNC(0xE71C5CDE, _Stoul);
//REG_FUNC(0x7A5CA6A3, _Stoulx);
//REG_FUNC(0x6794B3C6, _Stoull);
//REG_FUNC(0xD00F68FD, _Stoullx);
//REG_FUNC(0xBF94193B, _Stod);
//REG_FUNC(0x6798AA28, _Stodx);
//REG_FUNC(0x784D8D95, _Stof);
//REG_FUNC(0x99A49A62, _Stofx);
//REG_FUNC(0x5AE9FFD8, _Stold);
//REG_FUNC(0x448A3CBE, _Stoldx);
//REG_FUNC(0x6B9E23FE, _Stoll);
//REG_FUNC(0x0D9E3B1C, _Stollx);
//REG_FUNC(0x52DDCDAF, _Stolx);
//REG_FUNC(0x76904D60, _Wctomb);
//REG_FUNC(0x5E56EA4E, _Mbtowc);
//REG_FUNC(0xDEC462AB, _FCbuild);
//REG_FUNC(0x9E248B76, _sceLibcErrnoLoc);
//REG_FUNC(0xA2F50E9E, _Fltrounds);
//REG_FUNC(0x7CC1B964, isalnum);
//REG_FUNC(0x94A89A00, isalpha);
//REG_FUNC(0xF894ECCB, isblank);
//REG_FUNC(0x13F4A8C8, iscntrl);
//REG_FUNC(0xEB93BC93, isdigit);
//REG_FUNC(0xDFEEFB1A, isgraph);
//REG_FUNC(0x465B93F1, islower);
//REG_FUNC(0xB7F87C4D, isprint);
//REG_FUNC(0x82C1E3FD, ispunct);
//REG_FUNC(0x18F2A715, isspace);
//REG_FUNC(0xF2012814, isupper);
//REG_FUNC(0x3B561695, isxdigit);
//REG_FUNC(0x83F73C88, tolower);
//REG_FUNC(0x1218642B, toupper);
//REG_FUNC(0x1118B49F, imaxabs);
//REG_FUNC(0x5766B4A8, imaxdiv);
//REG_FUNC(0xB45FD61E, strtoimax);
//REG_FUNC(0xB318952F, strtoumax);
//REG_FUNC(0x3F2D104F, wcstoimax);
//REG_FUNC(0xB9E511B4, wcstoumax);
//REG_FUNC(0xCEF7C575, mspace_create);
//REG_FUNC(0x30CBBC66, mspace_destroy);
//REG_FUNC(0xE080B96E, mspace_malloc);
//REG_FUNC(0x3CDFD2A3, mspace_free);
//REG_FUNC(0x30470BBA, mspace_calloc);
//REG_FUNC(0x52F780DD, mspace_memalign);
//REG_FUNC(0x4633134A, mspace_realloc);
//REG_FUNC(0x915DA59E, mspace_reallocalign);
//REG_FUNC(0x7AD7A737, mspace_malloc_usable_size);
//REG_FUNC(0x8D2A14C4, mspace_malloc_stats);
//REG_FUNC(0x2FF5D5BB, mspace_malloc_stats_fast);
//REG_FUNC(0xF355F381, mspace_is_heap_empty);
//REG_FUNC(0x50B326CE, setjmp);
//REG_FUNC(0x2D81C8C8, longjmp);
//REG_FUNC(0x72BA4468, clearerr);
//REG_FUNC(0xEC97321C, fclose);
//REG_FUNC(0xB2F318FE, fdopen);
//REG_FUNC(0xBF96AD71, feof);
//REG_FUNC(0xB724BFC1, ferror);
//REG_FUNC(0x5AAD2996, fflush);
//REG_FUNC(0x672C58E0, fgetc);
//REG_FUNC(0x3CDA3118, fgetpos);
//REG_FUNC(0xBA14322F, fgets);
//REG_FUNC(0xFEC1502E, fileno);
//REG_FUNC(0xFFFBE239, fopen);
//REG_FUNC(0xE0C79764, fprintf);
//REG_FUNC(0x7E6A6108, fputc);
//REG_FUNC(0xC8FF13E5, fputs);
//REG_FUNC(0xB31C73A9, fread);
//REG_FUNC(0x715C4395, freopen);
//REG_FUNC(0x505601C6, fscanf);
//REG_FUNC(0xC3A7CDE1, fseek);
//REG_FUNC(0xDC1BDBD7, fsetpos);
//REG_FUNC(0x41C2AF95, ftell);
//REG_FUNC(0x8BCDCC4E, fwrite);
//REG_FUNC(0x4BD5212E, getc);
//REG_FUNC(0x4790BF1E, getchar);
//REG_FUNC(0xF97B8CA3, gets);
//REG_FUNC(0x4696E7BE, perror);
REG_FUNC(0x9a004680, printf);
//REG_FUNC(0x995708A6, putc);
//REG_FUNC(0x7CDAC89C, putchar);
//REG_FUNC(0x59C3E171, puts);
//REG_FUNC(0x40293B75, remove);
//REG_FUNC(0x6FE983A3, rename);
//REG_FUNC(0x6CA5BAB9, rewind);
//REG_FUNC(0x9CB9D899, scanf);
//REG_FUNC(0x395490DA, setbuf);
//REG_FUNC(0x2CA980A0, setvbuf);
//REG_FUNC(0xA1BFF606, snprintf);
//REG_FUNC(0x7449B359, sprintf);
//REG_FUNC(0xEC585241, sscanf);
//REG_FUNC(0x2BCB3F01, ungetc);
//REG_FUNC(0xF7915685, vfprintf);
//REG_FUNC(0xF137771A, vfscanf);
//REG_FUNC(0xE7B5E23E, vprintf);
//REG_FUNC(0x0E9BD318, vscanf);
//REG_FUNC(0xFE83F2E4, vsnprintf);
//REG_FUNC(0x802FDDF9, vsprintf);
//REG_FUNC(0xA9889307, vsscanf);
//REG_FUNC(0x20FE0FFF, abort);
//REG_FUNC(0x8E5A06C5, abs);
//REG_FUNC(0xD500DE27, atof);
//REG_FUNC(0x21493BE7, atoi);
//REG_FUNC(0xA1DBEE9F, atol);
//REG_FUNC(0x875994F3, atoll);
//REG_FUNC(0xD1BC28E7, bsearch);
//REG_FUNC(0xE9F823C0, div);
REG_FUNC(0x826bbbaf, exit);
//REG_FUNC(0xB53B345B, _Exit);
//REG_FUNC(0xBCEA304B, labs);
//REG_FUNC(0x9D2D17CD, llabs);
//REG_FUNC(0xD63330DA, ldiv);
//REG_FUNC(0x3F887699, lldiv);
//REG_FUNC(0x3E347849, mblen);
//REG_FUNC(0x2F75CF9B, mbstowcs);
//REG_FUNC(0xD791A952, mbtowc);
//REG_FUNC(0xA7CBE4A6, qsort);
//REG_FUNC(0x6CA88B08, strtod);
//REG_FUNC(0x6CB8540E, strtof);
//REG_FUNC(0x181827ED, strtol);
//REG_FUNC(0x48C684B2, strtold);
//REG_FUNC(0x39B7E681, strtoll);
//REG_FUNC(0xF34AE312, strtoul);
//REG_FUNC(0xE0E12333, strtoull);
//REG_FUNC(0x9A8F7FC0, wcstombs);
//REG_FUNC(0x6489B5E4, wctomb);
//REG_FUNC(0xC0883865, rand);
//REG_FUNC(0x3AAD41B0, srand);
//REG_FUNC(0x962097AA, rand_r);
//REG_FUNC(0x775A0CB2, malloc);
//REG_FUNC(0xE7EC3D0B, calloc);
//REG_FUNC(0x006B54BA, realloc);
//REG_FUNC(0x5B9BB802, free);
//REG_FUNC(0xA9363E6B, memalign);
//REG_FUNC(0x608AC135, reallocalign);
//REG_FUNC(0x57A729DB, malloc_stats);
//REG_FUNC(0xB3D29DE1, malloc_stats_fast);
//REG_FUNC(0x54A54EB1, malloc_usable_size);
//REG_FUNC(0x2F3E5B16, memchr);
//REG_FUNC(0x7747F6D7, memcmp);
REG_FUNC(0x7205BFDB, memcpy);
//REG_FUNC(0xAF5C218D, memmove);
//REG_FUNC(0x6DC1F0D8, memset);
//REG_FUNC(0x1434FA46, strcat);
//REG_FUNC(0xB9336E16, strchr);
//REG_FUNC(0x1B58FA3B, strcmp);
//REG_FUNC(0x46AE2311, strcoll);
//REG_FUNC(0x85B924B7, strcpy);
//REG_FUNC(0x0E29D27A, strcspn);
//REG_FUNC(0x1E9D6335, strerror);
//REG_FUNC(0x8AECC873, strlen);
//REG_FUNC(0xFBA69BC2, strncat);
//REG_FUNC(0xE4299DCB, strncmp);
//REG_FUNC(0x9F87712D, strncpy);
//REG_FUNC(0x68C307B6, strpbrk);
//REG_FUNC(0xCEFDD143, strrchr);
//REG_FUNC(0x4203B663, strspn);
//REG_FUNC(0x0D5200CB, strstr);
//REG_FUNC(0x0289B8B3, strtok);
//REG_FUNC(0x4D023DE9, strxfrm);
//REG_FUNC(0xEB31926D, strtok_r);
//REG_FUNC(0xFF6F77C7, strdup);
//REG_FUNC(0x184C4B07, strcasecmp);
//REG_FUNC(0xAF1CA2F1, strncasecmp);
//REG_FUNC(0xC94AE948, asctime);
//REG_FUNC(0xC082CA03, clock);
//REG_FUNC(0x1EA1CA8D, ctime);
//REG_FUNC(0x33AD70A0, difftime);
//REG_FUNC(0xF283CFE3, gmtime);
//REG_FUNC(0xF4A2E0BF, localtime);
//REG_FUNC(0xD1A2DFC3, mktime);
//REG_FUNC(0xEEB76FED, strftime);
//REG_FUNC(0xDAE8D60F, time);
//REG_FUNC(0xEFB3BC61, btowc);
//REG_FUNC(0x1D1DA5AD, _Btowc);
//REG_FUNC(0x89541CA5, fgetwc);
//REG_FUNC(0x982AFA4D, fgetws);
//REG_FUNC(0xA597CDC8, fputwc);
//REG_FUNC(0xB755927C, fputws);
//REG_FUNC(0xA77327D2, fwide);
//REG_FUNC(0xE52278E8, fwprintf);
//REG_FUNC(0x7BFC75C6, fwscanf);
//REG_FUNC(0x23E0F442, getwc);
//REG_FUNC(0x55DB4E32, getwchar);
//REG_FUNC(0x1927CAE8, mbrlen);
//REG_FUNC(0x910664C3, mbrtowc);
//REG_FUNC(0x961D12F8, mbsinit);
//REG_FUNC(0x9C14D58E, mbsrtowcs);
//REG_FUNC(0x247C71A6, putwc);
//REG_FUNC(0x3E04AB1C, putwchar);
//REG_FUNC(0x1B581BEB, swprintf);
//REG_FUNC(0xE1D2AE42, swscanf);
//REG_FUNC(0x39334D9C, ungetwc);
//REG_FUNC(0x36BF1E06, vfwprintf);
//REG_FUNC(0x37A563BE, vfwscanf);
//REG_FUNC(0x572DAB57, vswprintf);
//REG_FUNC(0x9451EE20, vswscanf);
//REG_FUNC(0x0A451B11, vwprintf);
//REG_FUNC(0xAD0C43DC, vwscanf);
//REG_FUNC(0xD9FF289D, wcrtomb);
//REG_FUNC(0x2F990FF9, wcscat);
//REG_FUNC(0xC1587971, wcschr);
//REG_FUNC(0xF42128B9, wcscmp);
//REG_FUNC(0x8EC70609, wcscoll);
//REG_FUNC(0x8AAADD56, wcscpy);
//REG_FUNC(0x25F7E46A, wcscspn);
//REG_FUNC(0x74136BC1, wcsftime);
//REG_FUNC(0xA778A14B, wcslen);
//REG_FUNC(0x196AB9F2, wcsncat);
//REG_FUNC(0xAAA6AAA2, wcsncmp);
//REG_FUNC(0x62E9B2D5, wcsncpy);
//REG_FUNC(0x07F229DB, wcspbrk);
//REG_FUNC(0xDF806521, wcsrchr);
//REG_FUNC(0xD8889FC8, wcsrtombs);
//REG_FUNC(0x5F5AA692, wcsspn);
//REG_FUNC(0x5BE328EE, wcsstr);
//REG_FUNC(0x35D7F1B1, wcstod);
//REG_FUNC(0x322243A8, _WStod);
//REG_FUNC(0x64123137, wcstof);
//REG_FUNC(0x340AF0F7, _WStof);
//REG_FUNC(0xA17C24A3, wcstok);
//REG_FUNC(0xFBEB657E, wcstol);
//REG_FUNC(0x2D7C3A7A, wcstold);
//REG_FUNC(0x1EDA8F09, _WStold);
//REG_FUNC(0x6EEFB7D7, wcstoll);
//REG_FUNC(0xACF13D54, wcstoul);
//REG_FUNC(0x87C94271, _WStoul);
//REG_FUNC(0xCBFF8200, wcstoull);
//REG_FUNC(0xF6069AFD, wcsxfrm);
//REG_FUNC(0x704321CC, wctob);
//REG_FUNC(0x2F0C81A6, _Wctob);
//REG_FUNC(0x7A08BE70, wmemchr);
//REG_FUNC(0x9864C99F, wmemcmp);
//REG_FUNC(0xD9F9DDCD, wmemcpy);
//REG_FUNC(0x53F7EB4B, wmemmove);
//REG_FUNC(0x4D04A480, wmemset);
//REG_FUNC(0xBF2F5FCE, wprintf);
//REG_FUNC(0xADC32204, wscanf);
//REG_FUNC(0x7E811AF2, iswalnum);
//REG_FUNC(0xC5ECB7B6, iswalpha);
//REG_FUNC(0xC8FC4BBE, iswblank);
//REG_FUNC(0xC30AE3C7, iswcntrl);
//REG_FUNC(0x9E348712, iswctype);
//REG_FUNC(0xC37DB2C2, iswdigit);
//REG_FUNC(0x70632234, iswgraph);
//REG_FUNC(0x40F84B7D, iswlower);
//REG_FUNC(0xF52F9241, iswprint);
//REG_FUNC(0x3922B91A, iswpunct);
//REG_FUNC(0x2BDA4905, iswspace);
//REG_FUNC(0x9939E1AD, iswupper);
//REG_FUNC(0x82FCEFA4, iswxdigit);
//REG_FUNC(0x09C38DE4, towlower);
//REG_FUNC(0xCF77D465, towctrans);
//REG_FUNC(0xCACE34B9, towupper);
//REG_FUNC(0xE8270951, wctrans);
//REG_FUNC(0xA967B88D, wctype);
//REG_FUNC(0x9D885076, _Towctrans);
//REG_FUNC(0xE980110A, _Iswctype);
REG_FUNC(0x33b83b70, __cxa_atexit);
//REG_FUNC(0xEDC939E1, __aeabi_atexit);
//REG_FUNC(0xB538BF48, __cxa_finalize);
//REG_FUNC(0xD0310E31, __cxa_guard_acquire);
//REG_FUNC(0x4ED1056F, __cxa_guard_release);
//REG_FUNC(0xD18E461D, __cxa_guard_abort);
REG_FUNC(0xbfe02b3a, __cxa_set_dso_handle_main);
//REG_FUNC(0x64DA2C47, _Unlocksyslock);
//REG_FUNC(0x7DBC0575, _Locksyslock);
//REG_FUNC(0x5044FC32, _Lockfilelock);
//REG_FUNC(0xFD5DD98C, _Unlockfilelock);
//REG_FUNC(0x1EFFBAC2, __set_exidx_main);
//REG_FUNC(0x855FC605, _Files);
//REG_FUNC(0x66B7406C, _Stdin);
//REG_FUNC(0x5D8C1282, _Stdout);
//REG_FUNC(0xDDF9BB09, _Stderr);
//REG_FUNC(0x3CE6109D, _Ctype);
//REG_FUNC(0x36878958, _Touptab);
//REG_FUNC(0xD662E07C, _Tolotab);
//REG_FUNC(0xE5620A03, _Flt);
//REG_FUNC(0x338FE545, _Dbl);
//REG_FUNC(0x94CE931C, _Ldbl);
//REG_FUNC(0xF708906E, _Denorm);
//REG_FUNC(0x01B05132, _FDenorm);
//REG_FUNC(0x2C8DBEB7, _LDenorm);
//REG_FUNC(0x710B5F33, _Inf);
//REG_FUNC(0x8A0F308C, _FInf);
//REG_FUNC(0x5289BBC0, _LInf);
//REG_FUNC(0x116F3DA9, _Nan);
//REG_FUNC(0x415162DD, _FNan);
//REG_FUNC(0x036D0F07, _LNan);
//REG_FUNC(0x677CDE35, _Snan);
//REG_FUNC(0x7D35108B, _FSnan);
//REG_FUNC(0x48AEEF2A, _LSnan);
return psv_log_base("SceLibc");
}();

217
rpcs3/Emu/ARMv7/Modules/sceLibm.cpp Normal file
View File

@ -0,0 +1,217 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceLibm;
namespace sce_libm_func
{
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLibm, #name, &sce_libm_func::name)
psv_log_base sceLibm = []() -> psv_log_base
{
//REG_FUNC(0xC73FE76D, _Exp);
//REG_FUNC(0xFF4EAE04, _FExp);
//REG_FUNC(0xB363D7D4, _LExp);
//REG_FUNC(0xD72B5ACB, acos);
//REG_FUNC(0x27EAB8C1, acosf);
//REG_FUNC(0x1C053D0F, acosh);
//REG_FUNC(0x568ECFB0, acoshf);
//REG_FUNC(0xD3D6D36E, acoshl);
//REG_FUNC(0x3210F395, acosl);
//REG_FUNC(0x4016B2E6, asin);
//REG_FUNC(0x3A3E5424, asinf);
//REG_FUNC(0x7C93F1DD, asinh);
//REG_FUNC(0x285AEDEA, asinhf);
//REG_FUNC(0x9496E15E, asinhl);
//REG_FUNC(0x1724A81D, asinl);
//REG_FUNC(0x516D9970, atan);
//REG_FUNC(0xC9BE3F05, atan2);
//REG_FUNC(0x4E09DD53, atan2f);
//REG_FUNC(0xCE325597, atan2l);
//REG_FUNC(0xD78FC94E, atanf);
//REG_FUNC(0x434BCE01, atanh);
//REG_FUNC(0xC7B0AFBA, atanhf);
//REG_FUNC(0x6A6881A6, atanhl);
//REG_FUNC(0xD423A4AB, atanl);
//REG_FUNC(0xACC0DC5A, cbrt);
//REG_FUNC(0xD1699F4D, cbrtf);
//REG_FUNC(0x342F9501, cbrtl);
//REG_FUNC(0x63F05BD6, ceil);
//REG_FUNC(0x6BBFEC89, ceilf);
//REG_FUNC(0x48082D81, ceill);
//REG_FUNC(0xB918D13, copysign);
//REG_FUNC(0x16EB9E63, copysignf);
//REG_FUNC(0x19DFC0AA, copysignl);
//REG_FUNC(0x61D0244, cos);
//REG_FUNC(0x127F8302, cosf);
//REG_FUNC(0x89B9BE1F, cosl);
//REG_FUNC(0x110195E7, cosh);
//REG_FUNC(0x61DE0770, coshf);
//REG_FUNC(0x7EADDC5E, coshl);
//REG_FUNC(0x4B84C012, _Cosh);
//REG_FUNC(0x15993458, erf);
//REG_FUNC(0x524AEBFE, erfc);
//REG_FUNC(0x301F113, erfcf);
//REG_FUNC(0xD4C92471, erfcl);
//REG_FUNC(0x41DD1AB8, erff);
//REG_FUNC(0xFD431619, erfl);
//REG_FUNC(0xEB027358, exp);
//REG_FUNC(0x9B18F38F, exp2);
//REG_FUNC(0x79415BD3, exp2f);
//REG_FUNC(0x40053307, exp2l);
//REG_FUNC(0x56473BC7, expf);
//REG_FUNC(0xA71A81AA, expl);
//REG_FUNC(0x2A97A75F, expm1);
//REG_FUNC(0x64131D7B, expm1f);
//REG_FUNC(0x8BF1866C, expm1l);
//REG_FUNC(0x3E672BE3, fabs);
//REG_FUNC(0x75348906, fabsf);
//REG_FUNC(0x3ECA514, fabsl);
//REG_FUNC(0xA278B20D, _FCosh);
//REG_FUNC(0xD6FD5A2E, fdim);
//REG_FUNC(0x8B6CC137, fdimf);
//REG_FUNC(0xE6988B7B, fdiml);
//REG_FUNC(0xD5BD8D5C, _FLog);
//REG_FUNC(0x22BB8237, floor);
//REG_FUNC(0xCD7C05BD, floorf);
//REG_FUNC(0xFDFA4558, floorl);
//REG_FUNC(0x1EACA585, fma);
//REG_FUNC(0xB61672A7, fmaf);
//REG_FUNC(0xBCF6EA7C, fmal);
//REG_FUNC(0xBE30CC1E, fmax);
//REG_FUNC(0x7004FA75, fmaxf);
//REG_FUNC(0xBF5AF69E, fmaxl);
//REG_FUNC(0x2ABBDFF7, fmin);
//REG_FUNC(0x7673CC1E, fminf);
//REG_FUNC(0xE2F5A0F0, fminl);
//REG_FUNC(0x798587E4, fmod);
//REG_FUNC(0x1CD8F88E, fmodf);
//REG_FUNC(0x986011B4, fmodl);
//REG_FUNC(0x59197427, frexp);
//REG_FUNC(0xA6879AC, frexpf);
//REG_FUNC(0x6DC8D877, frexpl);
//REG_FUNC(0x4A496BC0, _FSin);
//REG_FUNC(0x7FBB4C55, _FSinh);
//REG_FUNC(0x2D2CD795, hypot);
//REG_FUNC(0xA397B929, hypotf);
//REG_FUNC(0x5BFBEE8, hypotl);
//REG_FUNC(0x667EE864, ilogb);
//REG_FUNC(0x80050A43, ilogbf);
//REG_FUNC(0x91298DCA, ilogbl);
//REG_FUNC(0x197C9D5, _LCosh);
//REG_FUNC(0x56061B, ldexp);
//REG_FUNC(0xE61E016, ldexpf);
//REG_FUNC(0x8280A7B1, ldexpl);
//REG_FUNC(0x2480AA54, lgamma);
//REG_FUNC(0x2D9556D5, lgammaf);
//REG_FUNC(0xADEBD201, lgammal);
//REG_FUNC(0x5B05329D, _LLog);
//REG_FUNC(0x7B41AC38, llrint);
//REG_FUNC(0xC1F6135B, llrintf);
//REG_FUNC(0x80558247, llrintl);
//REG_FUNC(0xD1251A18, llround);
//REG_FUNC(0x4595A04, llroundf);
//REG_FUNC(0x9AB5C7AF, llroundl);
//REG_FUNC(0x6037C48F, log);
//REG_FUNC(0x811ED68B, logf);
//REG_FUNC(0xC6FFBCD6, logl);
//REG_FUNC(0x67E99979, _Log);
//REG_FUNC(0x2CBE04D7, log1p);
//REG_FUNC(0xF1D7C851, log1pf);
//REG_FUNC(0x3359152C, log1pl);
//REG_FUNC(0xCF65F098, log10);
//REG_FUNC(0xFD2A3464, log10f);
//REG_FUNC(0x3D7E7201, log10l);
//REG_FUNC(0x73AFEE5F, log2);
//REG_FUNC(0x4095DBDB, log2f);
//REG_FUNC(0x720021A9, log2l);
//REG_FUNC(0x5EAE8AD4, logb);
//REG_FUNC(0x25F51CE, logbf);
//REG_FUNC(0x86C4B75F, logbl);
//REG_FUNC(0x207307D0, lrint);
//REG_FUNC(0xDA903135, lrintf);
//REG_FUNC(0xE8C1F6F8, lrintl);
//REG_FUNC(0xD35AFD56, lround);
//REG_FUNC(0xA24C6453, lroundf);
//REG_FUNC(0x8B3ACA4E, lroundl);
//REG_FUNC(0xB397FE83, _LSin);
//REG_FUNC(0xF247EE99, _LSinh);
//REG_FUNC(0x1167B5D2, modf);
//REG_FUNC(0x5D7A7EB2, modff);
//REG_FUNC(0xD41D68F2, modfl);
//REG_FUNC(0xC3FCA1FA, nan);
//REG_FUNC(0xB4761D24, nanf);
//REG_FUNC(0xBFA96D93, nanl);
//REG_FUNC(0x877187C4, nearbyint);
//REG_FUNC(0xD56E78F6, nearbyintf);
//REG_FUNC(0x8DD794DC, nearbyintl);
//REG_FUNC(0xE1A3D449, nextafter);
//REG_FUNC(0xC8A94A33, nextafterf);
//REG_FUNC(0xEAAB2055, nextafterl);
//REG_FUNC(0x39E605E6, nexttoward);
//REG_FUNC(0xDD652D4E, nexttowardf);
//REG_FUNC(0x41E6AEA4, nexttowardl);
//REG_FUNC(0x640DB443, pow);
//REG_FUNC(0x6DEA815A, powf);
//REG_FUNC(0x96328F3D, powl);
//REG_FUNC(0xE4D6117F, remainder);
//REG_FUNC(0xE6BB3DCF, remainderf);
//REG_FUNC(0x354E568E, remainderl);
//REG_FUNC(0x52337926, remquo);
//REG_FUNC(0xD8F6B5D3, remquof);
//REG_FUNC(0xBB353F24, remquol);
//REG_FUNC(0x943F218F, rint);
//REG_FUNC(0xCACE5A19, rintf);
//REG_FUNC(0xE3C097E0, rintl);
//REG_FUNC(0x64D37996, round);
//REG_FUNC(0xAAF31896, roundf);
//REG_FUNC(0x9AB1B1B1, roundl);
//REG_FUNC(0x8F8CF628, scalbln);
//REG_FUNC(0xDEB0A2D0, scalblnf);
//REG_FUNC(0x2113921E, scalblnl);
//REG_FUNC(0x569758D0, scalbn);
//REG_FUNC(0x78F70588, scalbnf);
//REG_FUNC(0x777C7463, scalbnl);
//REG_FUNC(0xB5519FF0, sin);
//REG_FUNC(0x7F00B590, sinf);
//REG_FUNC(0x3294447C, sinl);
//REG_FUNC(0xD92A7F85, _Sin);
//REG_FUNC(0xF2C0AF49, sinh);
//REG_FUNC(0xB5838E7D, sinhf);
//REG_FUNC(0x4B91F2E6, sinhl);
//REG_FUNC(0x40E42E8E, _Sinh);
//REG_FUNC(0xDA227FCC, sqrt);
//REG_FUNC(0xBA3F6937, sqrtf);
//REG_FUNC(0xC1343477, sqrtl);
//REG_FUNC(0x5BAE40B0, tan);
//REG_FUNC(0xA98E941B, tanf);
//REG_FUNC(0x26CD78CA, tanh);
//REG_FUNC(0xC4847578, tanhf);
//REG_FUNC(0x14F2BEA1, tanhl);
//REG_FUNC(0xDC742A5E, tanl);
//REG_FUNC(0x3A7FE686, tgamma);
//REG_FUNC(0xE6067AC0, tgammaf);
//REG_FUNC(0x2949109F, tgammal);
//REG_FUNC(0x212323E, trunc);
//REG_FUNC(0x90B899F, truncf);
//REG_FUNC(0xBC0F1B1A, truncl);
//REG_FUNC(0x98BBDAE0, _Dclass);
//REG_FUNC(0xBD8EF217, _FDclass);
//REG_FUNC(0x314CCE54, _LDclass);
//REG_FUNC(0xC5B9C8D8, _FDtest);
//REG_FUNC(0x27A55170, _Dtest);
//REG_FUNC(0x8DAE8767, _LDtest);
//REG_FUNC(0x622CBFEE, _Fpcomp);
//REG_FUNC(0x9CD4CEFE, _FFpcomp);
//REG_FUNC(0x18F43CD0, _LFpcomp);
//REG_FUNC(0x5BD0F71C, _Dsign);
//REG_FUNC(0xC4F7E42C, _FDsign);
//REG_FUNC(0x1DF73D2B, _LDsign);
return psv_log_base("SceLibm");
}();

1933
rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

72
rpcs3/Emu/ARMv7/PSVFuncList.cpp Normal file
View File

@ -0,0 +1,72 @@
#include "stdafx.h"
#include "Emu/System.h"
#include "PSVFuncList.h"
std::vector<psv_func> g_psv_func_list = []() -> std::vector<psv_func>
{
std::vector<psv_func> v;
psv_func f =
{
0xdeadbeef,
"INVALID FUNCTION",
new psv_func_detail::func_binder<u32>([]() -> u32
{
LOG_ERROR(HLE, "Unimplemented function found");
Emu.Pause();
return 0xffffffffu;
}),
nullptr,
};
v.push_back(f);
return v;
}();
void add_psv_func(psv_func& data)
{
g_psv_func_list.push_back(data);
}
psv_func* get_psv_func_by_nid(u32 nid)
{
for (auto& f : g_psv_func_list)
{
if (f.nid == nid)
{
return &f;
}
}
return nullptr;
}
u32 get_psv_func_index(psv_func* func)
{
auto res = func - g_psv_func_list.data();
assert((size_t)res < g_psv_func_list.size());
return (u32)res;
}
void execute_psv_func_by_index(ARMv7Thread& CPU, u32 index)
{
assert(index < g_psv_func_list.size());
(*g_psv_func_list[index].func)(CPU);
}
extern psv_log_base sceLibc;
extern psv_log_base sceLibm;
extern psv_log_base sceLibstdcxx;
extern psv_log_base sceLibKernel;
void list_known_psv_modules()
{
sceLibc.Log("");
sceLibm.Log("");
sceLibstdcxx.Log("");
sceLibKernel.Log("");
}

672
rpcs3/Emu/ARMv7/PSVFuncList.h Normal file
View File

@ -0,0 +1,672 @@
#pragma once
#include "ARMv7Thread.h"
#include "Emu/SysCalls/LogBase.h"
class psv_log_base : public LogBase
{
std::string m_name;
public:
psv_log_base(const std::string& name)
: m_name(name)
{
}
virtual const std::string& GetName() const override
{
return m_name;
}
};
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,
};
class psv_func_caller
{
public:
virtual void operator()(ARMv7Thread& CPU) = 0;
virtual ~psv_func_caller(){};
};
namespace psv_func_detail
{
enum bind_arg_type
{
ARG_GENERAL,
ARG_FLOAT,
ARG_VECTOR,
ARG_STACK,
};
template<typename T, bind_arg_type type, int g_count, int f_count, int v_count>
struct bind_arg;
template<typename T, int g_count, int f_count, int v_count>
struct bind_arg<T, ARG_GENERAL, g_count, f_count, v_count>
{
static_assert(sizeof(T) <= 4, "Invalid function argument type for ARG_GENERAL");
static __forceinline T func(ARMv7Thread& CPU)
{
return (T&)CPU.GPR[g_count - 1];
}
};
template<typename T, int g_count, int f_count, int v_count>
struct bind_arg<T, ARG_FLOAT, g_count, f_count, v_count>
{
static_assert(f_count <= 0, "TODO: Unsupported argument type (float)");
static_assert(sizeof(T) <= 8, "Invalid function argument type for ARG_FLOAT");
static __forceinline T func(ARMv7Thread& CPU)
{
}
};
template<typename T, int g_count, int f_count, int v_count>
struct bind_arg<T, ARG_VECTOR, g_count, f_count, v_count>
{
static_assert(v_count <= 0, "TODO: Unsupported argument type (vector)");
static_assert(sizeof(T) == 16, "Invalid function argument type for ARG_VECTOR");
static __forceinline T func(ARMv7Thread& CPU)
{
}
};
template<typename T, int g_count, int f_count, int v_count>
struct bind_arg<T, ARG_STACK, g_count, f_count, v_count>
{
static_assert(f_count <= 0, "TODO: Unsupported stack argument type (float)");
static_assert(v_count <= 0, "TODO: Unsupported stack argument type (vector)");
static_assert(sizeof(T) <= 4, "Invalid function argument type for ARG_STACK");
static __forceinline T func(ARMv7Thread& CPU)
{
const u32 res = CPU.GetStackArg(g_count);
return (T&)res;
}
};
template<typename T, bind_arg_type type>
struct bind_result
{
static_assert(type != ARG_FLOAT, "TODO: Unsupported funcion result type (float)");
static_assert(type != ARG_VECTOR, "TODO: Unsupported funcion result type (vector)");
static_assert(type == ARG_GENERAL, "Wrong use of bind_result template");
static_assert(sizeof(T) <= 4, "Invalid function result type for ARG_GENERAL");
static __forceinline void func(ARMv7Thread& CPU, T result)
{
(T&)CPU.GPR[0] = result;
}
};
//template<typename T>
//struct bind_result<T, ARG_FLOAT>
//{
// static_assert(sizeof(T) <= 8, "Invalid function result type for ARG_FLOAT");
// static __forceinline void func(ARMv7Thread& CPU, T result)
// {
// }
//};
//template<typename T>
//struct bind_result<T, ARG_VECTOR>
//{
// static_assert(sizeof(T) == 16, "Invalid function result type for ARG_VECTOR");
// static __forceinline void func(ARMv7Thread& CPU, const T result)
// {
// }
//};
template <typename RT, typename F, typename Tuple, bool Done, int Total, int... N>
struct call_impl
{
static __forceinline RT call(F f, Tuple && t)
{
return call_impl<RT, F, Tuple, Total == 1 + sizeof...(N), Total, N..., sizeof...(N)>::call(f, std::forward<Tuple>(t));
}
};
template <typename RT, typename F, typename Tuple, int Total, int... N>
struct call_impl<RT, F, Tuple, true, Total, N...>
{
static __forceinline RT call(F f, Tuple && t)
{
return f(std::get<N>(std::forward<Tuple>(t))...);
}
};
template <typename RT, typename F, typename Tuple>
static __forceinline RT call(F f, Tuple && t)
{
typedef typename std::decay<Tuple>::type ttype;
return psv_func_detail::call_impl<RT, F, Tuple, 0 == std::tuple_size<ttype>::value, std::tuple_size<ttype>::value>::call(f, std::forward<Tuple>(t));
}
template<int g_count, int f_count, int v_count>
static __forceinline std::tuple<> iterate(ARMv7Thread& CPU)
{
// terminator
return std::tuple<>();
}
template<int g_count, int f_count, int v_count, typename T, typename... A>
static __forceinline std::tuple<T, A...> iterate(ARMv7Thread& CPU)
{
static_assert(!std::is_pointer<T>::value, "Invalid function argument type (pointer)");
static_assert(!std::is_reference<T>::value, "Invalid function argument type (reference)");
// TODO: check calculations
const bool is_float = std::is_floating_point<T>::value;
const bool is_vector = std::is_same<T, u128>::value;
const bind_arg_type t = 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));
const int g = g_count + (is_float || is_vector ? 0 : 1);
const int f = f_count + (is_float ? 1 : 0);
const int v = v_count + (is_vector ? 1 : 0);
return std::tuple_cat(std::tuple<T>(bind_arg<T, t, g, f, v>::func(CPU)), iterate<g, f, v, A...>(CPU));
}
template<typename RT, typename... T>
class func_binder;
template<typename... T>
class func_binder<void, T...> : public psv_func_caller
{
typedef void(*func_t)(T...);
const func_t m_call;
public:
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{
}
virtual void operator()(ARMv7Thread& CPU)
{
call<void>(m_call, iterate<0, 0, 0, T...>(CPU));
}
};
template<typename... T>
class func_binder<void, ARMv7Thread&, T...> : public psv_func_caller
{
typedef void(*func_t)(ARMv7Thread&, T...);
const func_t m_call;
public:
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{
}
virtual void operator()(ARMv7Thread& CPU)
{
call<void>(m_call, std::tuple_cat(std::tuple<ARMv7Thread&>(CPU), iterate<0, 0, 0, T...>(CPU)));
}
};
template<typename RT, typename... T>
class func_binder : public psv_func_caller
{
typedef RT(*func_t)(T...);
const func_t m_call;
public:
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{
}
virtual void operator()(ARMv7Thread& CPU)
{
static_assert(!std::is_pointer<RT>::value, "Invalid function result type (pointer)");
static_assert(!std::is_reference<RT>::value, "Invalid function result type (reference)");
const bool is_float = std::is_floating_point<RT>::value;
const bool is_vector = std::is_same<RT, u128>::value;
const bind_arg_type t = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
bind_result<RT, t>::func(CPU, call<RT>(m_call, iterate<0, 0, 0, T...>(CPU)));
}
};
template<typename RT, typename... T>
class func_binder<RT, ARMv7Thread&, T...> : public psv_func_caller
{
typedef RT(*func_t)(ARMv7Thread&, T...);
const func_t m_call;
public:
func_binder(func_t call)
: psv_func_caller()
, m_call(call)
{
}
virtual void operator()(ARMv7Thread& CPU)
{
static_assert(!std::is_pointer<RT>::value, "Invalid function result type (pointer)");
static_assert(!std::is_reference<RT>::value, "Invalid function result type (reference)");
const bool is_float = std::is_floating_point<RT>::value;
const bool is_vector = std::is_same<RT, u128>::value;
const bind_arg_type t = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
bind_result<RT, t>::func(CPU, call<RT>(m_call, std::tuple_cat(std::tuple<ARMv7Thread&>(CPU), iterate<0, 0, 0, T...>(CPU))));
}
};
}
struct psv_func
{
const u32 nid;
const char* const name;
psv_func_caller* const func;
psv_log_base* const module;
};
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...))
{
psv_func f =
{
nid,
name,
new psv_func_detail::func_binder<RT, T...>(func),
module
};
add_psv_func(f);
}
psv_func* get_psv_func_by_nid(u32 nid);
u32 get_psv_func_index(psv_func* func);
void execute_psv_func_by_index(ARMv7Thread& CPU, u32 index);
void list_known_psv_modules();

2
rpcs3/Emu/Cell/PPCDecoder.cpp
View File

@ -8,4 +8,4 @@ u8 PPCDecoder::DecodeMemory(const u32 address)
Decode(instr);
return sizeof(u32);
}
}

732
rpcs3/Emu/Cell/PPUInterpreter.h
View File

File diff suppressed because it is too large Load Diff

48
rpcs3/Emu/Cell/SPUInterpreter.h
View File

@ -475,6 +475,12 @@ private:
{
const u32 t = (CPU.GPR[rb]._u32[3] + CPU.GPR[ra]._u32[3]) & 0xF;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u8[15 - t] = 0x03;
@ -483,6 +489,12 @@ private:
{
const u32 t = (CPU.GPR[rb]._u32[3] + CPU.GPR[ra]._u32[3]) & 0xE;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u16[7 - (t >> 1)] = 0x0203;
@ -490,6 +502,12 @@ private:
void CWX(u32 rt, u32 ra, u32 rb)
{
const u32 t = (CPU.GPR[ra]._u32[3] + CPU.GPR[rb]._u32[3]) & 0xC;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
@ -499,6 +517,12 @@ private:
{
const u32 t = (CPU.GPR[rb]._u32[3] + CPU.GPR[ra]._u32[3]) & 0x8;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u64[1 - (t >> 3)] = (u64)0x0001020304050607;
@ -584,6 +608,12 @@ private:
{
const int t = (CPU.GPR[ra]._u32[3] + i7) & 0xF;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u8[15 - t] = 0x03;
@ -592,6 +622,12 @@ private:
{
const int t = (CPU.GPR[ra]._u32[3] + i7) & 0xE;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u16[7 - (t >> 1)] = 0x0203;
@ -600,6 +636,12 @@ private:
{
const int t = (CPU.GPR[ra]._u32[3] + i7) & 0xC;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u32[3 - (t >> 2)] = 0x00010203;
@ -608,6 +650,12 @@ private:
{
const int t = (CPU.GPR[ra]._u32[3] + i7) & 0x8;
if (ra == 1 && (CPU.GPR[ra]._u32[3] & 0xF))
{
LOG_ERROR(SPU, "%s(): SP = 0x%x", __FUNCTION__, CPU.GPR[ra]._u32[3]);
Emu.Pause();
}
CPU.GPR[rt]._u64[0] = (u64)0x18191A1B1C1D1E1F;
CPU.GPR[rt]._u64[1] = (u64)0x1011121314151617;
CPU.GPR[rt]._u64[1 - (t >> 3)] = (u64)0x0001020304050607;

190
rpcs3/Emu/Cell/SPURecompiler.h
View File

@ -631,7 +631,7 @@ private:
}
LOG_OPCODE();
}
void ROTH(u32 rt, u32 ra, u32 rb)
void ROTH(u32 rt, u32 ra, u32 rb) //nf
{
XmmInvalidate(rt);
for (u32 i = 0; i < 8; i++)
@ -1384,18 +1384,21 @@ private:
}
void CBX(u32 rt, u32 ra, u32 rb)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
if (ra == rb)
c.mov(*addr, cpu_dword(GPR[rb]._u32[3]));
if (ra == 1)
{
// assuming that SP % 16 is always zero
}
else if (ra == rb)
{
c.add(*addr, *addr);
}
else
{
c.add(*addr, cpu_dword(GPR[rb]._u32[3]));
c.add(*addr, cpu_dword(GPR[ra]._u32[3]));
}
c.not_(*addr);
c.and_(*addr, 0xf);
c.neg(*addr);
c.add(*addr, 0xf);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
@ -1405,18 +1408,21 @@ private:
}
void CHX(u32 rt, u32 ra, u32 rb)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
if (ra == rb)
c.mov(*addr, cpu_dword(GPR[rb]._u32[3]));
if (ra == 1)
{
// assuming that SP % 16 is always zero
}
else if (ra == rb)
{
c.add(*addr, *addr);
}
else
{
c.add(*addr, cpu_dword(GPR[rb]._u32[3]));
c.add(*addr, cpu_dword(GPR[ra]._u32[3]));
}
c.not_(*addr);
c.and_(*addr, 0xe);
c.neg(*addr);
c.add(*addr, 0xe);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
@ -1426,18 +1432,21 @@ private:
}
void CWX(u32 rt, u32 ra, u32 rb)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
if (ra == rb)
c.mov(*addr, cpu_dword(GPR[rb]._u32[3]));
if (ra == 1)
{
// assuming that SP % 16 is always zero
}
else if (ra == rb)
{
c.add(*addr, *addr);
}
else
{
c.add(*addr, cpu_dword(GPR[rb]._u32[3]));
c.add(*addr, cpu_dword(GPR[ra]._u32[3]));
}
c.not_(*addr);
c.and_(*addr, 0xc);
c.neg(*addr);
c.add(*addr, 0xc);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
@ -1447,18 +1456,21 @@ private:
}
void CDX(u32 rt, u32 ra, u32 rb)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
if (ra == rb)
c.mov(*addr, cpu_dword(GPR[rb]._u32[3]));
if (ra == 1)
{
// assuming that SP % 16 is always zero
}
else if (ra == rb)
{
c.add(*addr, *addr);
}
else
{
c.add(*addr, cpu_dword(GPR[rb]._u32[3]));
c.add(*addr, cpu_dword(GPR[ra]._u32[3]));
}
c.not_(*addr);
c.and_(*addr, 0x8);
c.neg(*addr);
c.add(*addr, 0x8);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
@ -1555,59 +1567,103 @@ private:
}
void CBD(u32 rt, u32 ra, s32 i7)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.and_(*addr, 0xf);
c.neg(*addr);
c.add(*addr, 0xf);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(byte_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
if (ra == 1)
{
// assuming that SP % 16 is always zero
const XmmLink& vr = XmmAlloc(rt);
u128 value = u128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
value.u8r[i7 & 0xf] = 0x03;
c.movdqa(vr.get(), XmmConst(value.vi));
XmmFinalize(vr, rt);
}
else
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.not_(*addr);
c.and_(*addr, 0xf);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(byte_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
}
LOG_OPCODE();
}
void CHD(u32 rt, u32 ra, s32 i7)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.and_(*addr, 0xe);
c.neg(*addr);
c.add(*addr, 0xe);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(word_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
if (ra == 1)
{
// assuming that SP % 16 is always zero
const XmmLink& vr = XmmAlloc(rt);
u128 value = u128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
value.u16r[(i7 >> 1) & 0x7] = 0x0203;
c.movdqa(vr.get(), XmmConst(value.vi));
XmmFinalize(vr, rt);
}
else
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.not_(*addr);
c.and_(*addr, 0xe);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(word_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
}
LOG_OPCODE();
}
void CWD(u32 rt, u32 ra, s32 i7)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.and_(*addr, 0xc);
c.neg(*addr);
c.add(*addr, 0xc);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
if (ra == 1)
{
// assuming that SP % 16 is always zero
const XmmLink& vr = XmmAlloc(rt);
u128 value = u128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
value.u32r[(i7 >> 2) & 0x3] = 0x00010203;
c.movdqa(vr.get(), XmmConst(value.vi));
XmmFinalize(vr, rt);
}
else
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.not_(*addr);
c.and_(*addr, 0xc);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
}
LOG_OPCODE();
}
void CDD(u32 rt, u32 ra, s32 i7)
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.and_(*addr, 0x8);
c.neg(*addr);
c.add(*addr, 0x8);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
if (ra == 1)
{
// assuming that SP % 16 is always zero
const XmmLink& vr = XmmAlloc(rt);
u128 value = u128::fromV(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f));
value.u64r[(i7 >> 3) & 0x1] = 0x0001020304050607ull;
c.movdqa(vr.get(), XmmConst(value.vi));
XmmFinalize(vr, rt);
}
else
{
c.mov(*addr, cpu_dword(GPR[ra]._u32[3]));
c.add(*addr, i7);
c.not_(*addr);
c.and_(*addr, 0x8);
const XmmLink& vr = XmmAlloc(rt);
c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
XmmFinalize(vr, rt);
XmmInvalidate(rt);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
}
LOG_OPCODE();
}
void ROTQBII(u32 rt, u32 ra, s32 i7)
@ -3472,6 +3528,16 @@ private:
}
WRAPPER_END(rc, rt, ra, rb);*/
// hypothetical AVX-512 implementation:
// VPXORD mask, rc, [byte:0x0f] // 15 - rc (only for index bits)
// VPSHUFB res {k0}, ra, mask
// VPTESTMB k1 {k0}, rc, [byte:0x10]
// VPSHUFB res {k1}, rb, mask
// VPCMPNLTUB k1 {k0}, mask, [byte:0xc0]
// VPADDB res {k1}, res, [byte:0xff]
// VPCMPNLTUB k1 {k1}, mask, [byte:0xe0]
// VPSUBB res {k1}, res, [byte:0x7f]
const XmmLink& v0 = XmmGet(rc); // v0 = mask
const XmmLink& v1 = XmmAlloc();
const XmmLink& v2 = XmmCopy(v0); // v2 = mask

29
rpcs3/Emu/Cell/SPUThread.cpp
View File

@ -241,13 +241,13 @@ void SPUThread::ProcessCmd(u32 cmd, u32 tag, u32 lsa, u64 ea, u32 size)
{
case MFC_PUT_CMD:
{
vm::write32(ea, ReadLS32(lsa));
vm::write32((u32)ea, ReadLS32(lsa));
return;
}
case MFC_GET_CMD:
{
WriteLS32(lsa, vm::read32(ea));
WriteLS32(lsa, vm::read32((u32)ea));
return;
}
@ -264,13 +264,13 @@ void SPUThread::ProcessCmd(u32 cmd, u32 tag, u32 lsa, u64 ea, u32 size)
{
case MFC_PUT_CMD:
{
memcpy(vm::get_ptr<void>(ea), vm::get_ptr<void>(ls_offset + lsa), size);
memcpy(vm::get_ptr<void>((u32)ea), vm::get_ptr<void>(ls_offset + lsa), size);
return;
}
case MFC_GET_CMD:
{
memcpy(vm::get_ptr<void>(ls_offset + lsa), vm::get_ptr<void>(ea), size);
memcpy(vm::get_ptr<void>(ls_offset + lsa), vm::get_ptr<void>((u32)ea), size);
return;
}
@ -402,6 +402,17 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"),
lsa, ea, tag, size, cmd);
if ((u32)ea != ea)
{
LOG_ERROR(Log::SPU, "DMA %s: Invalid external address (0x%llx)",
(op == MFC_GETLLAR_CMD ? "GETLLAR" :
op == MFC_PUTLLC_CMD ? "PUTLLC" :
op == MFC_PUTLLUC_CMD ? "PUTLLUC" : "PUTQLLUC"),
ea);
Emu.Pause();
return;
}
if (op == MFC_GETLLAR_CMD) // get reservation
{
if (R_ADDR)
@ -412,7 +423,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
R_ADDR = ea;
for (u32 i = 0; i < 16; i++)
{
R_DATA[i] = vm::get_ptr<u64>(R_ADDR)[i];
R_DATA[i] = vm::get_ptr<u64>((u32)R_ADDR)[i];
vm::get_ptr<u64>(ls_offset + lsa)[i] = R_DATA[i];
}
MFCArgs.AtomicStat.PushUncond(MFC_GETLLAR_SUCCESS);
@ -432,7 +443,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
{
changed++;
mask |= (0x3 << (i * 2));
if (vm::get_ptr<u64>(R_ADDR)[i] != R_DATA[i])
if (vm::get_ptr<u64>((u32)R_ADDR)[i] != R_DATA[i])
{
m_events |= SPU_EVENT_LR;
MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE);
@ -446,7 +457,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
{
if (buf[i] != R_DATA[i])
{
if (InterlockedCompareExchange(&vm::get_ptr<volatile u64>(ea)[i], buf[i], R_DATA[i]) != R_DATA[i])
if (InterlockedCompareExchange(&vm::get_ptr<volatile u64>((u32)R_ADDR)[i], buf[i], R_DATA[i]) != R_DATA[i])
{
m_events |= SPU_EVENT_LR;
MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE);
@ -520,7 +531,7 @@ bool SPUThread::CheckEvents()
{
for (u32 i = 0; i < 16; i++)
{
if (vm::get_ptr<u64>(R_ADDR)[i] != R_DATA[i])
if (vm::get_ptr<u64>((u32)R_ADDR)[i] != R_DATA[i])
{
m_events |= SPU_EVENT_LR;
R_ADDR = 0;
@ -1165,4 +1176,4 @@ void SPUThread::StopAndSignal(u32 code)
break;
}
}
}
}

12
rpcs3/Emu/Memory/Memory.cpp
View File

@ -412,6 +412,12 @@ void DynamicMemoryBlockBase::Delete()
bool DynamicMemoryBlockBase::AllocFixed(u64 addr, u32 size)
{
if (!MemoryBlock::GetStartAddr())
{
LOG_ERROR(MEMORY, "DynamicMemoryBlockBase::AllocFixed(addr=0x%llx, size=0x%x): memory block not initialized", addr, size);
return false;
}
size = PAGE_4K(size + (addr & 4095)); // align size
addr &= ~4095; // align start address
@ -441,6 +447,12 @@ void DynamicMemoryBlockBase::AppendMem(u64 addr, u32 size) /* private */
u64 DynamicMemoryBlockBase::AllocAlign(u32 size, u32 align)
{
if (!MemoryBlock::GetStartAddr())
{
LOG_ERROR(MEMORY, "DynamicMemoryBlockBase::AllocAlign(size=0x%x, align=0x%x): memory block not initialized", size, align);
return 0;
}
size = PAGE_4K(size);
u32 exsize;

3
rpcs3/Emu/RSX/GL/GLShaderParam.h
View File

@ -90,9 +90,8 @@ struct GLParamArray
case PARAM_IN: return "in ";
case PARAM_UNIFORM: return "uniform ";
case PARAM_CONST: return "const ";
default: return "";
}
return "";
}
bool HasParam(const GLParamFlag flag, std::string type, const std::string& name)

2
rpcs3/Emu/RSX/RSXThread.cpp
View File

@ -2266,7 +2266,7 @@ void RSXThread::Task()
if(cmd == 0)
{
LOG_ERROR(Log::RSX, "null cmd: cmd=0x%x, put=0x%x, get=0x%x (addr=0x%x)", cmd, put, get, (u32)Memory.RSXIOMem.RealAddr(get));
//Emu.Pause();
Emu.Pause();
//HACK! We shouldn't be here
m_ctrl->get = get + (count + 1) * 4;
continue;

30
rpcs3/Emu/SysCalls/Modules.cpp
View File

@ -201,36 +201,38 @@ void fix_relocs(Module* module, u32 lib, u32 start, u32 end, u32 seg2)
for (u32 i = lib + start; i < lib + end; i += 24)
{
u64 addr = vm::read64(i);
u64 addr = vm::read64(i) + lib;
const u64 flag = vm::read64(i + 8);
if (flag == 0x10100000001ull)
if ((u32)addr != addr || (u32)(addr + seg2) != (addr + seg2))
{
addr = addr + seg2 + lib;
u32 value = vm::read32(addr);
module->Error("fix_relocs(): invalid address (0x%llx)", addr);
}
else if (flag == 0x10100000001ull)
{
addr = addr + seg2;
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16) + seg2);
vm::write32(addr, value + lib);
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x100000001ull)
{
addr = addr + seg2 + lib;
u32 value = vm::read32(addr);
addr = addr + seg2;
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16));
vm::write32(addr, value + lib);
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x10000000001ull)
{
addr = addr + lib;
u32 value = vm::read32(addr);
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16) + seg2);
vm::write32(addr, value + lib);
vm::write32((u32)addr, value + lib);
}
else if (flag == 1)
{
addr = addr + lib;
u32 value = vm::read32(addr);
u32 value = vm::read32((u32)addr);
assert(value == vm::read64(i + 16));
vm::write32(addr, value + lib);
vm::write32((u32)addr, value + lib);
}
else if (flag == 0x10000000004ull || flag == 0x10000000006ull)
{

274
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View File

@ -27,7 +27,6 @@ AudioDecoder::AudioDecoder(AudioCodecType type, u32 addr, u32 size, vm::ptr<Cell
, cbFunc(func)
, cbArg(arg)
, adecCb(nullptr)
, is_running(false)
, is_closed(false)
, is_finished(false)
, just_started(false)
@ -53,7 +52,7 @@ AudioDecoder::AudioDecoder(AudioCodecType type, u32 addr, u32 size, vm::ptr<Cell
return;
}
io_buf = (u8*)av_malloc(4096);
fmt->pb = avio_alloc_context(io_buf, 4096, 0, this, adecRead, NULL, NULL);
fmt->pb = avio_alloc_context(io_buf, 256, 0, this, adecRead, NULL, NULL);
if (!fmt->pb)
{
cellAdec->Error("AudioDecoder(): avio_alloc_context failed");
@ -87,13 +86,44 @@ AudioDecoder::~AudioDecoder()
}
}
int adecRawRead(void* opaque, u8* buf, int buf_size)
int adecRead(void* opaque, u8* buf, int buf_size)
{
AudioDecoder& adec = *(AudioDecoder*)opaque;
int res = 0;
next:
if (adec.reader.has_ats)
{
u8 code1 = vm::read8(adec.reader.addr + 2);
u8 code2 = vm::read8(adec.reader.addr + 3);
adec.channels = code1 >> 2;
adec.frame_size = ((((u32)code1 & 0x3) << 8) | (u32)code2) * 8 + 8;
adec.sample_rate = at3freq[code1 >> 5];
adec.reader.size -= 8;
adec.reader.addr += 8;
adec.reader.has_ats = false;
}
if (!adec.reader.init)
{
OMAHeader oma(1 /* atrac3p id */, adec.sample_rate, adec.channels, adec.frame_size);
if (buf_size < sizeof(oma))
{
cellAdec->Error("adecRead(): OMAHeader writing failed");
Emu.Pause();
return 0;
}
memcpy(buf, &oma, sizeof(oma));
buf += sizeof(oma);
buf_size -= sizeof(oma);
res += sizeof(oma);
adec.reader.init = true;
}
if (adec.reader.size < (u32)buf_size /*&& !adec.just_started*/)
{
AdecTask task;
@ -126,6 +156,7 @@ next:
adec.reader.addr = adec.task.au.addr;
adec.reader.size = adec.task.au.size;
adec.reader.has_ats = adec.use_ats_headers;
//LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", adec.task.au.size, adec.task.au.pts);
}
break;
@ -159,89 +190,6 @@ next:
}
}
int adecRead(void* opaque, u8* buf, int buf_size)
{
AudioDecoder& adec = *(AudioDecoder*)opaque;
int res = 0;
if (adec.reader.rem_size && adec.reader.rem)
{
if (buf_size < (int)adec.reader.rem_size)
{
cellAdec->Error("adecRead(): too small buf_size (rem_size = %d, buf_size = %d)", adec.reader.rem_size, buf_size);
Emu.Pause();
return 0;
}
memcpy(buf, adec.reader.rem, adec.reader.rem_size);
free(adec.reader.rem);
adec.reader.rem = nullptr;
buf += adec.reader.rem_size;
buf_size -= adec.reader.rem_size;
res += adec.reader.rem_size;
adec.reader.rem_size = 0;
}
while (buf_size)
{
u8 header[8];
if (adecRawRead(opaque, header, 8) < 8) break;
if (header[0] != 0x0f || header[1] != 0xd0)
{
cellAdec->Error("adecRead(): 0x0FD0 header not found");
Emu.Pause();
return -1;
}
if (!adec.reader.init)
{
OMAHeader oma(1 /* atrac3p id */, header[2], header[3]);
if (buf_size < sizeof(oma) + 8)
{
cellAdec->Error("adecRead(): OMAHeader writing failed");
Emu.Pause();
return 0;
}
memcpy(buf, &oma, sizeof(oma));
buf += sizeof(oma);
buf_size -= sizeof(oma);
res += sizeof(oma);
adec.reader.init = true;
}
else
{
}
u32 size = (((header[2] & 0x3) << 8) | header[3]) * 8 + 8; // data to be read before next header
//LOG_NOTICE(HLE, "*** audio block read: size = 0x%x", size);
if (buf_size < (int)size)
{
if (adecRawRead(opaque, buf, buf_size) < buf_size) break; // ???
res += buf_size;
size -= buf_size;
buf_size = 0;
adec.reader.rem = (u8*)malloc(size);
adec.reader.rem_size = size;
if (adecRawRead(opaque, adec.reader.rem, size) < (int)size) break; // ???
}
else
{
if (adecRawRead(opaque, buf, size) < (int)size) break; // ???
buf += size;
buf_size -= size;
res += size;
}
}
return res;
}
u32 adecOpen(AudioDecoder* data)
{
AudioDecoder& adec = *data;
@ -293,11 +241,13 @@ u32 adecOpen(AudioDecoder* data)
adec.reader.addr = 0;
adec.reader.size = 0;
adec.reader.init = false;
if (adec.reader.rem) free(adec.reader.rem);
adec.reader.rem = nullptr;
adec.reader.rem_size = 0;
adec.is_running = true;
adec.reader.has_ats = false;
adec.just_started = true;
adec.channels = task.at3p.channels;
adec.frame_size = task.at3p.frame_size;
adec.sample_rate = task.at3p.sample_rate;
adec.use_ats_headers = task.at3p.ats_header == 1;
}
break;
@ -307,7 +257,6 @@ u32 adecOpen(AudioDecoder* data)
cellAdec->Warning("adecEndSeq:");
adec.cbFunc.call(*adec.adecCb, adec.id, CELL_ADEC_MSG_TYPE_SEQDONE, CELL_OK, adec.cbArg);
adec.is_running = false;
adec.just_finished = true;
}
break;
@ -318,12 +267,13 @@ u32 adecOpen(AudioDecoder* data)
adec.reader.addr = task.au.addr;
adec.reader.size = task.au.size;
adec.reader.has_ats = adec.use_ats_headers;
//LOG_NOTICE(HLE, "Audio AU: size = 0x%x, pts = 0x%llx", task.au.size, task.au.pts);
if (adec.just_started)
{
adec.first_pts = task.au.pts;
adec.last_pts = task.au.pts - 0x10000; // hack
adec.last_pts = task.au.pts - 0x10000; // hack?
}
struct AVPacketHolder : AVPacket
@ -347,36 +297,30 @@ u32 adecOpen(AudioDecoder* data)
~AVPacketHolder()
{
av_free(data);
//av_free_packet(this);
}
} au(0);
/*{
wxFile dump;
dump.Open(wxString::Format("audio pts-0x%llx.dump", task.au.pts), wxFile::write);
u8* buf = (u8*)malloc(task.au.size);
if (Memory.CopyToReal(buf, task.au.addr, task.au.size)) dump.Write(buf, task.au.size);
free(buf);
dump.Close();
}*/
if (adec.just_started && adec.just_finished)
{
avcodec_flush_buffers(adec.ctx);
adec.reader.init = true;
adec.reader.init = true; // wrong
adec.just_finished = false;
adec.just_started = false;
}
else if (adec.just_started) // deferred initialization
{
err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), NULL);
if (err)
AVDictionary* opts = nullptr;
av_dict_set(&opts, "probesize", "96", 0);
err = avformat_open_input(&adec.fmt, NULL, av_find_input_format("oma"), &opts);
if (err || opts)
{
cellAdec->Error("adecDecodeAu: avformat_open_input() failed");
cellAdec->Error("adecDecodeAu: avformat_open_input() failed (err=0x%x, opts=%d)", err, opts ? 1 : 0);
Emu.Pause();
break;
}
AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_ATRAC3P); // ???
if (!codec)
{
@ -405,14 +349,14 @@ u32 adecOpen(AudioDecoder* data)
}
adec.ctx = adec.fmt->streams[0]->codec; // TODO: check data
AVDictionary* opts = nullptr;
opts = nullptr;
av_dict_set(&opts, "refcounted_frames", "1", 0);
{
std::lock_guard<std::mutex> lock(g_mutex_avcodec_open2);
// not multithread-safe (???)
err = avcodec_open2(adec.ctx, codec, &opts);
}
if (err)
if (err || opts)
{
cellAdec->Error("adecDecodeAu: avcodec_open2() failed");
Emu.Pause();
@ -431,22 +375,6 @@ u32 adecOpen(AudioDecoder* data)
break;
}
/*if (!adec.ctx) // fake
{
AdecFrame frame;
frame.pts = task.au.pts;
frame.auAddr = task.au.addr;
frame.auSize = task.au.size;
frame.userdata = task.au.userdata;
frame.size = 4096;
frame.data = nullptr;
adec.frames.Push(frame);
adec.cbFunc.call(*adec.adecCb, adec.id, CELL_ADEC_MSG_TYPE_PCMOUT, CELL_OK, adec.cbArg);
break;
}*/
last_frame = av_read_frame(adec.fmt, &au) < 0;
if (last_frame)
{
@ -504,7 +432,7 @@ u32 adecOpen(AudioDecoder* data)
}
else
{
adec.last_pts += ((u64)frame.data->nb_samples) * 90000 / 48000;
adec.last_pts += ((u64)frame.data->nb_samples) * 90000 / frame.data->sample_rate;
frame.pts = adec.last_pts;
}
//frame.pts = adec.last_pts;
@ -520,12 +448,6 @@ u32 adecOpen(AudioDecoder* data)
Emu.Pause();
break;
}
if (frame.data->channels != 2)
{
cellAdec->Error("adecDecodeAu: unsupported channel count (%d)", frame.data->channels);
Emu.Pause();
break;
}
//LOG_NOTICE(HLE, "got audio frame (pts=0x%llx, nb_samples=%d, ch=%d, sample_rate=%d, nbps=%d)",
//frame.pts, frame.data->nb_samples, frame.data->channels, frame.data->sample_rate,
@ -599,7 +521,7 @@ int cellAdecQueryAttr(vm::ptr<CellAdecType> type, vm::ptr<CellAdecAttr> attr)
// TODO: check values
attr->adecVerLower = 0x280000; // from dmux
attr->adecVerUpper = 0x260000;
attr->workMemSize = 4 * 1024 * 1024; // 4 MB
attr->workMemSize = 256 * 1024; // 256 KB
return CELL_OK;
}
@ -658,7 +580,7 @@ int cellAdecClose(u32 handle)
int cellAdecStartSeq(u32 handle, u32 param_addr)
{
cellAdec->Todo("cellAdecStartSeq(handle=%d, param_addr=0x%x)", handle, param_addr);
cellAdec->Warning("cellAdecStartSeq(handle=%d, param_addr=0x%x)", handle, param_addr);
AudioDecoder* adec;
if (!Emu.GetIdManager().GetIDData(handle, adec))
@ -668,7 +590,31 @@ int cellAdecStartSeq(u32 handle, u32 param_addr)
AdecTask task(adecStartSeq);
// TODO: using parameters
switch (adec->type)
{
case CELL_ADEC_TYPE_ATRACX_2CH:
{
auto param = vm::ptr<const CellAdecParamAtracX>::make(param_addr);
task.at3p.sample_rate = param->sampling_freq;
task.at3p.channel_config = param->ch_config_idx;
task.at3p.channels = param->nch_out;
task.at3p.frame_size = param->nbytes;
task.at3p.extra_config = param->extra_config_data;
task.at3p.output = param->bw_pcm;
task.at3p.downmix = param->downmix_flag;
task.at3p.ats_header = param->au_includes_ats_hdr_flg;
cellAdec->Todo("*** CellAdecParamAtracX: sr=%d, ch_cfg=%d(%d), frame_size=0x%x, extra=0x%x, output=%d, downmix=%d, ats_header=%d",
task.at3p.sample_rate, task.at3p.channel_config, task.at3p.channels, task.at3p.frame_size, (u32&)task.at3p.extra_config, task.at3p.output, task.at3p.downmix, task.at3p.ats_header);
break;
}
default:
{
cellAdec->Todo("cellAdecStartSeq(): Unimplemented audio codec type(%d)", adec->type);
Emu.Pause();
return CELL_OK;
}
}
adec->job.Push(task, &adec->is_closed);
return CELL_OK;
@ -705,6 +651,7 @@ int cellAdecDecodeAu(u32 handle, vm::ptr<CellAdecAuInfo> auInfo)
task.au.pts = ((u64)auInfo->pts.upper << 32) | (u64)auInfo->pts.lower;
task.au.userdata = auInfo->userData;
//cellAdec->Notice("cellAdecDecodeAu(): addr=0x%x, size=0x%x, pts=0x%llx", task.au.addr, task.au.size, task.au.pts);
adec->job.Push(task, &adec->is_closed);
return CELL_OK;
}
@ -722,28 +669,38 @@ int cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
AdecFrame af;
if (!adec->frames.Pop(af, &sq_no_wait))
{
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_ADEC_ERROR_EMPTY;
}
AVFrame* frame = af.data;
if (!af.data)
{
// hack
return CELL_OK;
}
if (outBuffer)
{
// reverse byte order, extract data:
float* in_f[2];
in_f[0] = (float*)frame->extended_data[0];
in_f[1] = (float*)frame->extended_data[1];
for (u32 i = 0; i < af.size / 8; i++)
// reverse byte order:
if (frame->channels == 1)
{
outBuffer[i * 2 + 0] = in_f[0][i];
outBuffer[i * 2 + 1] = in_f[1][i];
float* in_f = (float*)frame->extended_data[0];
for (u32 i = 0; i < af.size / 4; i++)
{
outBuffer[i] = in_f[i];
}
}
else if (frame->channels == 2)
{
float* in_f[2];
in_f[0] = (float*)frame->extended_data[0];
in_f[1] = (float*)frame->extended_data[1];
for (u32 i = 0; i < af.size / 8; i++)
{
outBuffer[i * 2 + 0] = in_f[0][i];
outBuffer[i * 2 + 1] = in_f[1][i];
}
}
else
{
cellAdec->Error("cellAdecGetPcm(): unsupported channel count (%d)", frame->channels);
Emu.Pause();
}
}
@ -765,7 +722,7 @@ int cellAdecGetPcmItem(u32 handle, vm::ptr<u32> pcmItem_ptr)
AdecFrame af;
if (!adec->frames.Peek(af, &sq_no_wait))
{
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_ADEC_ERROR_EMPTY;
}
@ -791,12 +748,23 @@ int cellAdecGetPcmItem(u32 handle, vm::ptr<u32> pcmItem_ptr)
pcm->auInfo.userData = af.userdata;
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof(CellAdecPcmItem));
atx->samplingFreq = frame->sample_rate; // ???
atx->nbytes = frame->nb_samples * frame->channels * sizeof(float); // ???
atx->channelConfigIndex = CELL_ADEC_CH_STEREO; // ???
atx->samplingFreq = frame->sample_rate;
atx->nbytes = frame->nb_samples * sizeof(float);
if (frame->channels == 1)
{
atx->channelConfigIndex = 1;
}
else if (frame->channels == 2)
{
atx->channelConfigIndex = 2;
}
else
{
cellAdec->Error("cellAdecGetPcmItem(): unsupported channel count (%d)", frame->channels);
Emu.Pause();
}
*pcmItem_ptr = pcm.addr();
return CELL_OK;
}

59
rpcs3/Emu/SysCalls/Modules/cellAdec.h
View File

@ -790,7 +790,7 @@ struct CellAdecParamAtracX
be_t<s32> ch_config_idx;
be_t<s32> nch_out;
be_t<s32> nbytes;
u8 extra_config_data[4]; // downmix coefficients
std::array<u8, 4> extra_config_data; // downmix coefficients
be_t<ATRACX_WordSize> bw_pcm;
ATRACX_DownmixFlag downmix_flag;
ATRACX_ATSHeaderInclude au_includes_ats_hdr_flg;
@ -1010,6 +1010,18 @@ struct AdecTask
u64 pts;
u64 userdata;
} au;
struct
{
s32 sample_rate;
s32 channel_config;
s32 channels;
s32 frame_size;
std::array<u8, 4> extra_config;
s32 output;
u8 downmix;
u8 ats_header;
} at3p;
};
AdecTask(AdecJobType type)
@ -1034,6 +1046,8 @@ struct AdecFrame
int adecRead(void* opaque, u8* buf, int buf_size);
static const u32 at3freq[8] = { 32000, 44100, 48000, 88200, 96000, 0, 0, 0 };
struct OMAHeader // OMA Header
{
u32 magic; // 0x01334145
@ -1043,26 +1057,34 @@ struct OMAHeader // OMA Header
u64 unk2; // 0xcef5000000000400ULL
u64 unk3; // 0x1c458024329192d2ULL
u8 codecId; // 1 for ATRAC3P
u8 reserved0; // 0
u8 code0; // 0
u8 code1;
u8 code2;
u32 reserved1; // 0
u64 reserved[7]; // 0
u32 reserved[15]; // 0
OMAHeader(u8 id, u8 code1, u8 code2)
OMAHeader(u8 codec_id, u32 freq, u8 channel_count, u32 frame_size)
: magic(0x01334145)
, size(96 << 8)
, unk0(0xffff)
, unk1(0x00500f0100000000ULL)
, unk2(0xcef5000000000400ULL)
, unk3(0x1c458024329192d2ULL)
, codecId(id)
, reserved0(0)
, code1(code1)
, code2(code2)
, reserved1(0)
, codecId(codec_id)
, code0(0)
{
memset(reserved, 0, sizeof(reserved));
u8 freq_code;
for (freq_code = 0; freq_code < 5; freq_code++)
{
if (at3freq[freq_code] == freq)
{
break;
}
}
u32 prepared_frame_size = (frame_size - 8) / 8;
code1 = ((prepared_frame_size >> 8) & 0x3) | ((channel_count & 0x7) << 2) | (freq_code << 5);
code2 = prepared_frame_size & 0xff;
}
};
@ -1073,7 +1095,6 @@ class AudioDecoder
public:
SQueue<AdecTask> job;
u32 id;
volatile bool is_running;
volatile bool is_closed;
volatile bool is_finished;
bool just_started;
@ -1088,20 +1109,13 @@ public:
u32 addr;
u32 size;
bool init;
u8* rem;
u32 rem_size;
bool has_ats;
AudioReader()
: rem(nullptr)
, rem_size(0)
: init(false)
{
}
~AudioReader()
{
if (rem) free(rem);
rem = nullptr;
}
} reader;
SQueue<AdecFrame> frames;
@ -1116,6 +1130,11 @@ public:
AdecTask task;
u64 last_pts, first_pts;
u32 channels;
u32 frame_size;
u32 sample_rate;
bool use_ats_headers;
PPUThread* adecCb;
AudioDecoder(AudioCodecType type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg);

197
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View File

@ -1,48 +1,71 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "Emu/SysCalls/Modules.h"
Module *cellAtrac = nullptr;
#include "cellAtrac.h"
int cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
#ifdef PRX_DEBUG
#include "prx_libatrac3plus.h"
u32 libatrac3plus;
u32 libatrac3plus_rtoc;
#endif
s64 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
{
cellAtrac->Todo("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
cellAtrac->Warning("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x11F4, libatrac3plus_rtoc);
#endif
*puiWorkMemByte = 0x1000; // unproved
return CELL_OK;
}
int cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
s64 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
{
cellAtrac->Todo("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
cellAtrac->Warning("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0FF0, libatrac3plus_rtoc);
#endif
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
return CELL_OK;
}
int cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
s64 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
{
cellAtrac->Todo("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
cellAtrac->Warning("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0DB0, libatrac3plus_rtoc);
#endif
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
return CELL_OK;
}
int cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
s64 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
{
cellAtrac->Todo("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr());
cellAtrac->Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0D08, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<u32> piRemainFrame)
s64 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<u32> piRemainFrame)
{
cellAtrac->Todo("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
cellAtrac->Warning("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x09A8, libatrac3plus_rtoc);
#endif
*puiSamples = 0;
*puiFinishflag = 1;
@ -50,10 +73,13 @@ int cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32
return CELL_OK;
}
int cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
s64 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
{
cellAtrac->Todo("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
cellAtrac->Warning("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0BE8, libatrac3plus_rtoc);
#endif
*ppucWritePointer = pHandle->data.pucWorkMem_addr;
*puiWritableByte = 0x1000;
@ -61,79 +87,112 @@ int cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> pp
return CELL_OK;
}
int cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
s64 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
{
cellAtrac->Todo("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte);
cellAtrac->Warning("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0AFC, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRemainFrame)
s64 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRemainFrame)
{
cellAtrac->Todo("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr());
cellAtrac->Warning("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x092C, libatrac3plus_rtoc);
#endif
*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
return CELL_OK;
}
int cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize)
s64 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize)
{
cellAtrac->Todo("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr());
cellAtrac->Warning("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x08B0, libatrac3plus_rtoc);
#endif
*puiVacantSize = 0x1000;
return CELL_OK;
}
int cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
s64 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
{
cellAtrac->Todo("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr());
cellAtrac->Warning("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0010, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
s64 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
{
cellAtrac->Todo("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
cellAtrac->Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x07E8, libatrac3plus_rtoc);
#endif
*puiReadPosition = 0;
*puiDataByte = 0; // write to null block will occur
return CELL_OK;
}
int cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
s64 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
{
cellAtrac->Todo("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
cellAtrac->Warning("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0704, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel)
s64 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel)
{
cellAtrac->Todo("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr());
cellAtrac->Warning("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0060, libatrac3plus_rtoc);
#endif
*puiChannel = 2;
return CELL_OK;
}
int cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample)
s64 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample)
{
cellAtrac->Todo("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr());
cellAtrac->Warning("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x00AC, libatrac3plus_rtoc);
#endif
*puiMaxSample = 512;
return CELL_OK;
}
int cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample)
s64 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample)
{
cellAtrac->Todo("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr());
cellAtrac->Warning("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0688, libatrac3plus_rtoc);
#endif
*puiNextSample = 0;
return CELL_OK;
}
int cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSample, vm::ptr<u32> piLoopStartSample, vm::ptr<u32> piLoopEndSample)
s64 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSample, vm::ptr<u32> piLoopStartSample, vm::ptr<u32> piLoopEndSample)
{
cellAtrac->Todo("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
cellAtrac->Warning("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0104, libatrac3plus_rtoc);
#endif
*piEndSample = 0;
*piLoopStartSample = 0;
@ -141,44 +200,60 @@ int cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSa
return CELL_OK;
}
int cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition)
s64 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition)
{
cellAtrac->Todo("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
cellAtrac->Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
pHandle.addr(), puiSamplePosition.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0190, libatrac3plus_rtoc);
#endif
*puiSamplePosition = 0;
return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
}
int cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate)
s64 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate)
{
cellAtrac->Todo("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
cellAtrac->Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
pHandle.addr(), puiBitrate.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0374, libatrac3plus_rtoc);
#endif
*puiBitrate = 128;
return CELL_OK;
}
int cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piLoopNum, vm::ptr<u32> puiLoopStatus)
s64 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piLoopNum, vm::ptr<u32> puiLoopStatus)
{
cellAtrac->Todo("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
cellAtrac->Warning("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x025C, libatrac3plus_rtoc);
#endif
*piLoopNum = 0;
*puiLoopStatus = 0;
return CELL_OK;
}
int cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum)
s64 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum)
{
cellAtrac->Todo("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum);
cellAtrac->Warning("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x1538, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
s64 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
{
cellAtrac->Todo("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
cellAtrac->Warning("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
pHandle.addr(), uiSample, pBufferInfo.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x05BC, libatrac3plus_rtoc);
#endif
pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr;
pBufferInfo->uiWritableByte = 0x1000;
@ -187,17 +262,24 @@ int cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiS
return CELL_OK;
}
int cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
s64 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
{
cellAtrac->Todo("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
cellAtrac->Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
pHandle.addr(), uiSample, uiWriteByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x04E4, libatrac3plus_rtoc);
#endif
return CELL_OK;
}
int cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piResult)
s64 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piResult)
{
cellAtrac->Todo("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
cellAtrac->Warning("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
pHandle.addr(), piResult.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x02E4, libatrac3plus_rtoc);
#endif
*piResult = 0;
return CELL_OK;
@ -237,4 +319,27 @@ void cellAtrac_init(Module *pxThis)
cellAtrac->AddFunc(0x7772eb2b, cellAtracResetPlayPosition);
cellAtrac->AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libatrac3plus = (u32)Memory.MainMem.AllocAlign(sizeof(libatrac3plus_data), 0x100000);
memcpy(vm::get_ptr<void>(libatrac3plus), libatrac3plus_data, sizeof(libatrac3plus_data));
libatrac3plus_rtoc = libatrac3plus + 0xBED0;
extern Module* cellAdec;
FIX_IMPORT(cellAdec, cellAdecDecodeAu, libatrac3plus + 0x399C);
FIX_IMPORT(cellAdec, cellAdecStartSeq, libatrac3plus + 0x39BC);
FIX_IMPORT(cellAdec, cellAdecQueryAttr, libatrac3plus + 0x39DC);
FIX_IMPORT(cellAdec, cellAdecClose, libatrac3plus + 0x39FC);
FIX_IMPORT(cellAdec, cellAdecGetPcm, libatrac3plus + 0x3A1C);
FIX_IMPORT(cellAdec, cellAdecOpen, libatrac3plus + 0x3A3C);
fix_import(cellAdec, 0xDF982D2C, libatrac3plus + 0x3A5C);
fix_relocs(cellAtrac, libatrac3plus, 0x3EF0, 0x5048, 0x3CE0);
});
#endif
}

30
rpcs3/Emu/SysCalls/Modules/cellAtrac.h
View File

@ -3,7 +3,6 @@
// Return Codes
enum
{
CELL_ATRAC_OK = 0x00000000,
CELL_ATRAC_ERROR_API_FAIL = 0x80610301,
CELL_ATRAC_ERROR_READSIZE_OVER_BUFFER = 0x80610311,
CELL_ATRAC_ERROR_UNKNOWN_FORMAT = 0x80610312,
@ -27,6 +26,32 @@ enum
CELL_ATRAC_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610382,
};
enum
{
CELL_ATRACMULTI_ERROR_API_FAIL = 0x80610b01,
CELL_ATRACMULTI_ERROR_READSIZE_OVER_BUFFER = 0x80610b11,
CELL_ATRACMULTI_ERROR_UNKNOWN_FORMAT = 0x80610b12,
CELL_ATRACMULTI_ERROR_READSIZE_IS_TOO_SMALL = 0x80610b13,
CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLING_RATE = 0x80610b14,
CELL_ATRACMULTI_ERROR_ILLEGAL_DATA = 0x80610b15,
CELL_ATRACMULTI_ERROR_NO_DECODER = 0x80610b21,
CELL_ATRACMULTI_ERROR_UNSET_DATA = 0x80610b22,
CELL_ATRACMULTI_ERROR_DECODER_WAS_CREATED = 0x80610b23,
CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED = 0x80610b31,
CELL_ATRACMULTI_ERROR_NODATA_IN_BUFFER = 0x80610b32,
CELL_ATRACMULTI_ERROR_NOT_ALIGNED_OUT_BUFFER = 0x80610b33,
CELL_ATRACMULTI_ERROR_NEED_SECOND_BUFFER = 0x80610b34,
CELL_ATRACMULTI_ERROR_ALLDATA_IS_ONMEMORY = 0x80610b41,
CELL_ATRACMULTI_ERROR_ADD_DATA_IS_TOO_BIG = 0x80610b42,
CELL_ATRACMULTI_ERROR_NONEED_SECOND_BUFFER = 0x80610b51,
CELL_ATRACMULTI_ERROR_UNSET_LOOP_NUM = 0x80610b61,
CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLE = 0x80610b71,
CELL_ATRACMULTI_ERROR_ILLEGAL_RESET_BYTE = 0x80610b72,
CELL_ATRACMULTI_ERROR_ILLEGAL_PPU_THREAD_PRIORITY = 0x80610b81,
CELL_ATRACMULTI_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610b82,
CELL_ATRACMULTI_ERROR_API_PARAMETER = 0x80610b91,
};
// Remain Frame
enum
{
@ -38,6 +63,7 @@ enum
union CellAtracHandle
{
u8 uiWorkMem[512];
struct AtracHandle
{
u32 pucWorkMem_addr;
@ -56,4 +82,4 @@ struct CellAtracExtRes
{
be_t<u32> pSpurs_addr;
u8 priority[8];
};
};

2
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View File

@ -337,7 +337,7 @@ int cellAudioInit()
// 2x MAXPS (optional)
// 2x MINPS (optional)
// 2x CVTPS2DQ (converts float to s32)
// PACKSSDW (converts s32 to s16 with clipping)
// PACKSSDW (converts s32 to s16 with signed saturation)
if (g_is_u16)
{

6
rpcs3/Emu/SysCalls/Modules/cellAvconfExt.cpp
View File

@ -16,15 +16,15 @@ int cellVideoOutGetScreenSize(u32 videoOut, vm::ptr<float> screenSize)
{
cellAvconfExt->Warning("cellVideoOutGetScreenSize(videoOut=%d, screenSize_addr=0x%x)", videoOut, screenSize.addr());
if (!videoOut == CELL_VIDEO_OUT_PRIMARY)
if (videoOut != CELL_VIDEO_OUT_PRIMARY)
return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
#ifdef _WIN32
HDC screen = GetDC(NULL);
u32 diagonal = round(sqrt((pow(GetDeviceCaps(screen, HORZSIZE), 2) + pow(GetDeviceCaps(screen, VERTSIZE), 2))) * 0.0393);
float diagonal = roundf(sqrtf((powf(GetDeviceCaps(screen, HORZSIZE), 2) + powf(GetDeviceCaps(screen, VERTSIZE), 2))) * 0.0393);
#else
// TODO: Linux implementation, without using wx
// u32 diagonal = round(sqrt((pow(wxGetDisplaySizeMM().GetWidth(), 2) + pow(wxGetDisplaySizeMM().GetHeight(), 2))) * 0.0393);
// float diagonal = roundf(sqrtf((powf(wxGetDisplaySizeMM().GetWidth(), 2) + powf(wxGetDisplaySizeMM().GetHeight(), 2))) * 0.0393);
#endif
if (Ini.GS3DTV.GetValue())

91
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View File

@ -326,7 +326,7 @@ u32 dmuxOpen(Demuxer* data)
cellDmux->Notice("Demuxer thread started (mem=0x%x, size=0x%x, cb=0x%x, arg=0x%x)", dmux.memAddr, dmux.memSize, dmux.cbFunc, dmux.cbArg);
DemuxerTask task;
DemuxerStream stream;
DemuxerStream stream = {};
ElementaryStream* esALL[192]; memset(esALL, 0, sizeof(esALL));
ElementaryStream** esAVC = &esALL[0]; // AVC (max 16)
ElementaryStream** esM2V = &esALL[16]; // MPEG-2 (max 16)
@ -337,9 +337,6 @@ u32 dmuxOpen(Demuxer* data)
u32 cb_add = 0;
u32 updates_count = 0;
u32 updates_signaled = 0;
while (true)
{
if (Emu.IsStopped() || dmux.is_closed)
@ -347,7 +344,7 @@ u32 dmuxOpen(Demuxer* data)
break;
}
if (!dmux.job.Peek(task, &sq_no_wait) && dmux.is_running)
if (!dmux.job.Peek(task, &sq_no_wait) && dmux.is_running && stream.addr)
{
// default task (demuxing) (if there is no other work)
be_t<u32> code;
@ -356,14 +353,13 @@ u32 dmuxOpen(Demuxer* data)
if (!stream.peek(code))
{
dmux.is_running = false;
// demuxing finished
auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
dmuxMsg->supplementalInfo = stream.userdata;
dmux.cbFunc.call(*dmux.dmuxCb, dmux.id, dmuxMsg, dmux.cbArg);
updates_signaled++;
dmux.is_running = false;
}
else switch (code.ToLE())
{
@ -405,11 +401,6 @@ u32 dmuxOpen(Demuxer* data)
PesHeader pes(stream);
if (!pes.new_au) // temporarily
{
cellDmux->Error("No pts info found");
}
// read additional header:
stream.peek(ch); // ???
//stream.skip(4);
@ -425,13 +416,6 @@ u32 dmuxOpen(Demuxer* data)
continue;
}
/*if (es.hasunseen()) // hack, probably useless
{
stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
continue;
}*/
stream.skip(4);
len -= 4;
@ -480,12 +464,6 @@ u32 dmuxOpen(Demuxer* data)
if (pes.new_au && es.hasdata()) // new AU detected
{
/*if (es.hasunseen()) // hack, probably useless
{
stream = backup;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
continue;
}*/
es.finish(stream);
// callback
auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
@ -572,24 +550,11 @@ u32 dmuxOpen(Demuxer* data)
esALL[i]->reset();
}
}
updates_count = 0;
updates_signaled = 0;
}
if (updates_count != updates_signaled)
{
cellDmux->Error("dmuxSetStream: stream update inconsistency (input=%d, signaled=%d)", updates_count, updates_signaled);
Emu.Pause();
return;
}
updates_count++;
stream = task.stream;
//LOG_NOTICE(HLE, "*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
//stream.addr, stream.size, stream.discontinuity, stream.userdata);
dmux.is_running = true;
dmux.fbSetStream.Push(task.stream.addr, &dmux.is_closed); // feedback
}
break;
@ -601,12 +566,11 @@ u32 dmuxOpen(Demuxer* data)
dmuxMsg->supplementalInfo = stream.userdata;
dmux.cbFunc.call(*dmux.dmuxCb, dmux.id, dmuxMsg, dmux.cbArg);
updates_signaled++;
stream = {};
dmux.is_running = false;
if (task.type == dmuxResetStreamAndWaitDone)
{
dmux.fbSetStream.Push(0, &dmux.is_closed);
}
//if (task.type == dmuxResetStreamAndWaitDone)
//{
//}
}
break;
@ -825,14 +789,9 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
return CELL_DMUX_ERROR_ARG;
}
if (dmux->is_running)
if (dmux->is_running.exchange(true))
{
if (Emu.IsStopped())
{
cellDmux->Warning("cellDmuxSetStream(%d) aborted (waiting)", demuxerHandle);
return CELL_OK;
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_DMUX_ERROR_BUSY;
}
@ -844,18 +803,6 @@ int cellDmuxSetStream(u32 demuxerHandle, const u32 streamAddress, u32 streamSize
info.userdata = userData;
dmux->job.Push(task, &dmux->is_closed);
u32 addr;
if (!dmux->fbSetStream.Pop(addr, &dmux->is_closed))
{
cellDmux->Warning("cellDmuxSetStream(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK;
}
if (addr != info.addr)
{
cellDmux->Error("cellDmuxSetStream(%d): wrong stream queued (right=0x%x, queued=0x%x)", demuxerHandle, info.addr, addr);
Emu.Pause();
}
return CELL_OK;
}
@ -870,7 +817,6 @@ int cellDmuxResetStream(u32 demuxerHandle)
}
dmux->job.Push(DemuxerTask(dmuxResetStream), &dmux->is_closed);
return CELL_OK;
}
@ -885,17 +831,14 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
}
dmux->job.Push(DemuxerTask(dmuxResetStreamAndWaitDone), &dmux->is_closed);
u32 addr;
if (!dmux->fbSetStream.Pop(addr, &dmux->is_closed))
while (dmux->is_running && !dmux->is_closed) // TODO: ensure that it is safe
{
cellDmux->Warning("cellDmuxResetStreamAndWaitDone(%d) aborted (fbSetStream.Pop())", demuxerHandle);
return CELL_OK;
}
if (addr != 0)
{
cellDmux->Error("cellDmuxResetStreamAndWaitDone(%d): wrong stream queued (0x%x)", demuxerHandle, addr);
Emu.Pause();
if (Emu.IsStopped())
{
cellDmux->Warning("cellDmuxResetStreamAndWaitDone(%d) aborted", demuxerHandle);
return CELL_OK;
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
return CELL_OK;
}
@ -912,7 +855,6 @@ int cellDmuxQueryEsAttr(vm::ptr<const CellDmuxType> demuxerType, vm::ptr<const C
}
// TODO: check esFilterId and esSpecificInfo correctly
dmuxQueryEsAttr(0, esFilterId, esSpecificInfo_addr, esAttr);
return CELL_OK;
}
@ -929,7 +871,6 @@ int cellDmuxQueryEsAttr2(vm::ptr<const CellDmuxType2> demuxerType2, vm::ptr<cons
}
// TODO: check demuxerType2, esFilterId and esSpecificInfo correctly
dmuxQueryEsAttr(demuxerType2->streamSpecificInfo_addr, esFilterId, esSpecificInfo_addr, esAttr);
return CELL_OK;
}

3
rpcs3/Emu/SysCalls/Modules/cellDmux.h
View File

@ -408,7 +408,6 @@ class Demuxer
{
public:
SQueue<DemuxerTask, 32> job;
SQueue<u32, 16> fbSetStream;
const u32 memAddr;
const u32 memSize;
const vm::ptr<CellDmuxCbMsg> cbFunc;
@ -416,7 +415,7 @@ public:
u32 id;
volatile bool is_finished;
volatile bool is_closed;
volatile bool is_running;
std::atomic<bool> is_running;
PPUThread* dmuxCb;

80
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View File

@ -16,7 +16,7 @@ u32 libpngdec;
u32 libpngdec_rtoc;
#endif
s32 pngDecCreate(
s64 pngDecCreate(
vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> param,
vm::ptr<const CellPngDecExtThreadInParam> ext = vm::ptr<const CellPngDecExtThreadInParam>::make(0))
@ -45,7 +45,7 @@ s32 pngDecCreate(
return CELL_OK;
}
s32 pngDecDestroy(CellPngDecMainHandle dec)
s64 pngDecDestroy(CellPngDecMainHandle dec)
{
if (!Memory.Free(dec.addr()))
{
@ -55,7 +55,7 @@ s32 pngDecDestroy(CellPngDecMainHandle dec)
return CELL_OK;
}
s32 pngDecOpen(
s64 pngDecOpen(
CellPngDecMainHandle dec,
vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src,
@ -75,13 +75,13 @@ s32 pngDecOpen(
stream->fd = 0;
stream->src = *src;
switch (src->srcSelect.ToBE())
switch (src->srcSelect.ToLE())
{
case se32(CELL_PNGDEC_BUFFER):
case CELL_PNGDEC_BUFFER:
stream->fileSize = src->streamSize.ToLE();
break;
case se32(CELL_PNGDEC_FILE):
case CELL_PNGDEC_FILE:
// Get file descriptor
vm::var<be_t<u32>> fd;
int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 0, fd, vm::ptr<u32>::make(0), 0);
@ -115,7 +115,7 @@ s32 pngDecOpen(
return CELL_OK;
}
s32 pngDecClose(CellPngDecSubHandle stream)
s64 pngDecClose(CellPngDecSubHandle stream)
{
cellFsClose(stream->fd);
if (!Memory.Free(stream.addr()))
@ -126,7 +126,7 @@ s32 pngDecClose(CellPngDecSubHandle stream)
return CELL_OK;
}
s32 pngReadHeader(
s64 pngReadHeader(
CellPngDecSubHandle stream,
vm::ptr<CellPngDecInfo> info,
vm::ptr<CellPngDecExtInfo> extInfo = vm::ptr<CellPngDecExtInfo>::make(0))
@ -189,7 +189,7 @@ s32 pngReadHeader(
return CELL_OK;
}
s32 pngDecSetParameter(
s64 pngDecSetParameter(
CellPngDecSubHandle stream,
vm::ptr<const CellPngDecInParam> inParam,
vm::ptr<CellPngDecOutParam> outParam,
@ -230,7 +230,7 @@ s32 pngDecSetParameter(
return CELL_OK;
}
s32 pngDecodeData(
s64 pngDecodeData(
CellPngDecSubHandle stream,
vm::ptr<u8> data,
vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
@ -359,7 +359,7 @@ s32 pngDecodeData(
return CELL_OK;
}
s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam)
s64 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -379,7 +379,7 @@ s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInPa
#endif
}
s32 cellPngDecExtCreate(
s64 cellPngDecExtCreate(
vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> threadInParam,
vm::ptr<CellPngDecThreadOutParam> threadOutParam,
@ -405,7 +405,7 @@ s32 cellPngDecExtCreate(
#endif
}
s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -418,7 +418,7 @@ s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
#endif
}
s32 cellPngDecOpen(
s64 cellPngDecOpen(
CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src,
@ -436,7 +436,7 @@ s32 cellPngDecOpen(
#endif
}
s32 cellPngDecExtOpen(
s64 cellPngDecExtOpen(
CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src,
@ -456,7 +456,7 @@ s32 cellPngDecExtOpen(
#endif
}
s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle)
s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -468,7 +468,7 @@ s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHand
#endif
}
s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info)
s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -481,7 +481,7 @@ s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle su
#endif
}
s32 cellPngDecExtReadHeader(
s64 cellPngDecExtReadHeader(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<CellPngDecInfo> info,
@ -498,7 +498,7 @@ s32 cellPngDecExtReadHeader(
#endif
}
s32 cellPngDecSetParameter(
s64 cellPngDecSetParameter(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam,
@ -515,7 +515,7 @@ s32 cellPngDecSetParameter(
#endif
}
s32 cellPngDecExtSetParameter(
s64 cellPngDecExtSetParameter(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam,
@ -534,7 +534,7 @@ s32 cellPngDecExtSetParameter(
#endif
}
s32 cellPngDecDecodeData(
s64 cellPngDecDecodeData(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u8> data,
@ -552,7 +552,7 @@ s32 cellPngDecDecodeData(
#endif
}
s32 cellPngDecExtDecodeData(
s64 cellPngDecExtDecodeData(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u8> data,
@ -572,7 +572,7 @@ s32 cellPngDecExtDecodeData(
#endif
}
s32 cellPngDecGetUnknownChunks(
s64 cellPngDecGetUnknownChunks(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
@ -587,7 +587,7 @@ s32 cellPngDecGetUnknownChunks(
#endif
}
s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal)
s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -598,7 +598,7 @@ s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm)
s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -609,7 +609,7 @@ s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal)
s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -620,7 +620,7 @@ s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys)
s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -631,7 +631,7 @@ s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs)
s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -642,7 +642,7 @@ s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt)
s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -653,7 +653,7 @@ s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd)
s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -664,7 +664,7 @@ s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time)
s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -675,7 +675,7 @@ s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist)
s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -686,7 +686,7 @@ s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns)
s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -697,7 +697,7 @@ s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit)
s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -708,7 +708,7 @@ s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp)
s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -719,7 +719,7 @@ s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb)
s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -730,7 +730,7 @@ s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama)
s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -741,7 +741,7 @@ s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte)
s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte)
{
#ifdef PRX_DEBUG
cellPngDec->Warning("%s()", __FUNCTION__);
@ -752,7 +752,7 @@ s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHa
#endif
}
s32 cellPngDecGetTextChunk(
s64 cellPngDecGetTextChunk(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u32> textInfoNum,
@ -804,6 +804,8 @@ void cellPngDec_init(Module *pxThis)
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libpngdec = (u32)Memory.MainMem.AllocAlign(sizeof(libpngdec_data), 0x100000);
memcpy(vm::get_ptr<void>(libpngdec), libpngdec_data, sizeof(libpngdec_data));
libpngdec_rtoc = libpngdec + 0x49710;

58
rpcs3/Emu/SysCalls/Modules/cellPngDec.h
View File

@ -183,77 +183,77 @@ struct CellPngDecDataOutInfo
};
// Functions
s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam);
s64 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam);
s32 cellPngDecExtCreate(
s64 cellPngDecExtCreate(
vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> threadInParam,
vm::ptr<CellPngDecThreadOutParam> threadOutParam,
vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam);
s32 cellPngDecOpen(
s64 cellPngDecOpen(
CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src,
vm::ptr<CellPngDecOpnInfo> openInfo);
s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info);
s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info);
s32 cellPngDecSetParameter(
s64 cellPngDecSetParameter(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam,
vm::ptr<CellPngDecOutParam> outParam);
s32 cellPngDecDecodeData(
s64 cellPngDecDecodeData(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u8> data,
vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
vm::ptr<CellPngDecDataOutInfo> dataOutInfo);
s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle);
s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle);
s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle);
s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle);
s32 cellPngDecGetTextChunk(
s64 cellPngDecGetTextChunk(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u32> textInfoNum,
vm::ptr<vm::bptr<CellPngTextInfo>> textInfo);
s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte);
s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte);
s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama);
s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama);
s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb);
s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb);
s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp);
s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp);
s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit);
s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit);
s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns);
s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns);
s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist);
s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist);
s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time);
s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time);
s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd);
s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd);
s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt);
s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt);
s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs);
s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs);
s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys);
s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys);
s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal);
s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal);
s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm);
s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm);
s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal);
s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal);
s32 cellPngDecGetUnknownChunks(
s64 cellPngDecGetUnknownChunks(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
@ -349,7 +349,7 @@ struct CellPngDecCbCtrlDisp
};
// Functions
s32 cellPngDecExtOpen(
s64 cellPngDecExtOpen(
CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src,
@ -357,13 +357,13 @@ s32 cellPngDecExtOpen(
vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
vm::ptr<const CellPngDecOpnParam> opnParam);
s32 cellPngDecExtReadHeader(
s64 cellPngDecExtReadHeader(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<CellPngDecInfo> info,
vm::ptr<CellPngDecExtInfo> extInfo);
s32 cellPngDecExtSetParameter(
s64 cellPngDecExtSetParameter(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam,
@ -371,7 +371,7 @@ s32 cellPngDecExtSetParameter(
vm::ptr<const CellPngDecExtInParam> extInParam,
vm::ptr<CellPngDecExtOutParam> extOutParam);
s32 cellPngDecExtDecodeData(
s64 cellPngDecExtDecodeData(
CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle,
vm::ptr<u8> data,

35
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

@ -557,9 +557,9 @@ s64 spursInit(
{
if (spurs->m.wklReadyCount[i].read_relaxed() ||
spurs->m.wklSet1.read_relaxed() & (0x8000u >> i) ||
spurs->m.wklFlag.flag.read_relaxed() == 0 &&
(spurs->m.wklFlag.flag.read_relaxed() == 0 &&
spurs->m.flagRecv.read_relaxed() == (u8)i
)
))
{
do_break = true;
break;
@ -575,9 +575,9 @@ s64 spursInit(
{
if (spurs->m.wklReadyCount[i + 0x10].read_relaxed() ||
spurs->m.wklSet2.read_relaxed() & (0x8000u >> i) ||
spurs->m.wklFlag.flag.read_relaxed() == 0 &&
(spurs->m.wklFlag.flag.read_relaxed() == 0 &&
spurs->m.flagRecv.read_relaxed() == (u8)i + 0x10
)
))
{
do_break = true;
break;
@ -953,11 +953,26 @@ s64 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
{
cellSpurs->Todo("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
#ifdef PRX_DEBUG
cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
#ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
#endif
if (!spurs)
{
return CELL_SPURS_CORE_ERROR_NULL_POINTER;
}
if (spurs.addr() % 128)
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
if (spurs->m.xD66.read_relaxed())
{
return CELL_SPURS_CORE_ERROR_STAT;
}
return CELL_OK;
}
@ -1360,13 +1375,7 @@ s32 spursAddWorkload(
spurs->m.wklSet2._and_not({ be_t<u16>::make(0x8000 >> index) }); // clear bit in wklFlag2
}
spurs->m.flagRecv.atomic_op([wnum](u8& FR)
{
if (FR == wnum)
{
FR = 0xff;
}
});
spurs->m.flagRecv.compare_and_swap(wnum, 0xff);
u32 res_wkl;
CellSpurs::_sub_str3& wkl = wnum <= 15 ? spurs->m.wklG1[wnum] : spurs->m.wklG2[wnum & 0xf];

2
rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
View File

@ -766,6 +766,8 @@ void cellSpursJq_init(Module *pxThis)
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libspurs_jq = (u32)Memory.MainMem.AllocAlign(sizeof(libspurs_jq_data), 0x100000);
memcpy(vm::get_ptr<void>(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data));
libspurs_jq_rtoc = libspurs_jq + 0x17E80;

20
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -997,7 +997,7 @@ s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer
s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
{
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU))
if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU)
{
return CELL_SYNC_ERROR_PERM;
}
@ -1124,7 +1124,7 @@ s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32>
s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal)
{
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU))
if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU)
{
return CELL_SYNC_ERROR_PERM;
}
@ -1305,7 +1305,7 @@ s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<const void>
{
s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
#ifdef PRX_DEBUG_XXX
res = cb_caller<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64>::call(GetCurrentPPUThread(), libsre + 0x24B0, libsre_rtoc,
@ -1351,7 +1351,7 @@ s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<const void>
memcpy(vm::get_ptr<void>((u64)(queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), buffer.get_ptr(), size);
s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
#ifdef PRX_DEBUG_XXX
res = cb_caller<s32, vm::ptr<CellSyncLFQueue>, s32, u64>::call(GetCurrentPPUThread(), libsre + 0x26C0, libsre_rtoc,
@ -1376,7 +1376,7 @@ s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<const void>
s32 syncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue)
{
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU))
if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU)
{
return CELL_SYNC_ERROR_PERM;
}
@ -1503,7 +1503,7 @@ s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32>
s32 syncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
{
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU))
if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU)
{
return CELL_SYNC_ERROR_PERM;
}
@ -1681,7 +1681,7 @@ s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<void> buffer
while (true)
{
s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
#ifdef PRX_DEBUG_XXX
res = cb_caller<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64, u64>::call(GetCurrentPPUThread(), libsre + 0x2A90, libsre_rtoc,
@ -1724,7 +1724,7 @@ s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<void> buffer
memcpy(buffer.get_ptr(), vm::get_ptr<void>((u64)(queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), size);
s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
#ifdef PRX_DEBUG_XXX
res = cb_caller<s32, vm::ptr<CellSyncLFQueue>, s32, u64, u64>::call(GetCurrentPPUThread(), libsre + 0x2CA8, libsre_rtoc,
@ -1767,7 +1767,7 @@ s32 cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
const auto push = queue->push1.read_relaxed();
s32 var1, var2;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{
var1 = var2 = (u16)queue->pop2.read_relaxed().pack;
}
@ -1989,6 +1989,8 @@ void cellSync_init(Module *pxThis)
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libsre = (u32)Memory.MainMem.AllocAlign(sizeof(libsre_data), 0x100000);
memcpy(vm::get_ptr<void>(libsre), libsre_data, sizeof(libsre_data));
libsre_rtoc = libsre + 0x399B0;

2
rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
View File

@ -458,6 +458,8 @@ void cellSync2_init(Module *pxThis)
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libsync2 = (u32)Memory.MainMem.AllocAlign(sizeof(libsync2_data), 0x100000);
memcpy(vm::get_ptr<void>(libsync2), libsync2_data, sizeof(libsync2_data));
libsync2_rtoc = libsync2 + 0xF280;

10
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View File

@ -29,7 +29,6 @@ VideoDecoder::VideoDecoder(CellVdecCodecType type, u32 profile, u32 addr, u32 si
, cbArg(arg)
, is_finished(false)
, is_closed(false)
, is_running(false)
, just_started(false)
, just_finished(false)
, ctx(nullptr)
@ -225,9 +224,7 @@ u32 vdecOpen(VideoDecoder* data)
// TODO: reset data
cellVdec->Warning("vdecStartSeq:");
vdec.reader.addr = 0;
vdec.reader.size = 0;
vdec.is_running = true;
vdec.reader = {};
vdec.just_started = true;
}
break;
@ -239,7 +236,6 @@ u32 vdecOpen(VideoDecoder* data)
vdec.cbFunc.call(*vdec.vdecCb, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg);
vdec.is_running = false;
vdec.just_finished = true;
}
break;
@ -595,7 +591,7 @@ int cellVdecGetPicture(u32 handle, vm::ptr<const CellVdecPicFormat> format, vm::
VdecFrame vf;
if (!vdec->frames.Pop(vf, &sq_no_wait))
{
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_VDEC_ERROR_EMPTY;
}
@ -651,7 +647,7 @@ int cellVdecGetPicItem(u32 handle, vm::ptr<u32> picItem_ptr)
VdecFrame vf;
if (!vdec->frames.Peek(vf, &sq_no_wait))
{
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
//std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
return CELL_VDEC_ERROR_EMPTY;
}

1
rpcs3/Emu/SysCalls/Modules/cellVdec.h
View File

@ -694,7 +694,6 @@ class VideoDecoder
public:
SQueue<VdecTask> job;
u32 id;
volatile bool is_running;
volatile bool is_closed;
volatile bool is_finished;
bool just_started;

2
rpcs3/Emu/SysCalls/Modules/libmixer.cpp
View File

@ -358,7 +358,7 @@ int cellSurMixerCreate(vm::ptr<const CellSurMixerConfig> config)
memset(mixdata, 0, sizeof(mixdata));
if (surMixerCb)
{
surMixerCb.call(cb_thread, surMixerCbArg, mixcount, 256);
surMixerCb.call(cb_thread, surMixerCbArg, (u32)mixcount, 256);
}
//u64 stamp1 = get_system_time();

2
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View File

@ -157,7 +157,7 @@ int sys_get_random_number(vm::ptr<u8> addr, u64 size)
if (size > 4096)
size = 4096;
for (u64 i = 0; i < size - 1; i++)
for (u32 i = 0; i < (u32)size - 1; i++)
{
addr[i] = rand() % 256;
}

2
rpcs3/Emu/SysCalls/SC_FUNC.h
View File

@ -249,4 +249,4 @@ template<typename RT, typename... T>
func_caller* bind_func(RT(*call)(T...))
{
return new detail::func_binder<RT, T...>(call);
}
}

1
rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
View File

@ -154,7 +154,6 @@ s32 sys_memory_container_get_size(vm::ptr<sys_memory_info_t> mem_info, u32 cid)
return CELL_ESRCH;
// HACK: Return all memory.
sys_memory_info_t info;
mem_info->total_user_memory = ct->size;
mem_info->available_user_memory = ct->size;
return CELL_OK;

3
rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
View File

@ -218,9 +218,8 @@ s32 sys_mutex_trylock(u32 mutex_id)
switch (mutex->m_mutex.trylock(tid))
{
case SMR_OK: mutex->recursive = 1; t.owned_mutexes++; return CELL_OK;
default: return CELL_EBUSY;
}
return CELL_EBUSY;
}
s32 sys_mutex_unlock(u32 mutex_id)

25
rpcs3/Emu/System.cpp
View File

@ -240,7 +240,7 @@ void Emulator::Load()
try
{
if(!(is_error = !l.Analyze()) && l.GetMachine() != MACHINE_Unknown)
if(!(is_error = !l.Analyze()))
{
switch(l.GetMachine())
{
@ -260,6 +260,9 @@ void Emulator::Load()
case MACHINE_ARM:
Memory.Init(Memory_PSV);
break;
default:
throw std::string("Unknown machine!");
}
is_error = !l.Load();
@ -380,10 +383,24 @@ void Emulator::Load()
}
break;
default:
thread.SetEntry(l.GetEntry());
case MACHINE_ARM:
{
u32 entry = l.GetEntry();
auto code = vm::psv::ptr<const u32>::make(entry & ~3);
// evil way to find entry point in .sceModuleInfo.rodata
while (code[0] != 0xffffffffu)
{
entry = code[0] + 0x81000000;
code++;
}
thread.SetEntry(entry & ~1);
thread.Run();
break;
break;
}
}
m_status = Ready;

95
rpcs3/Loader/ELF32.cpp
View File

@ -3,8 +3,11 @@
#include "Utilities/rFile.h"
#include "Emu/FS/vfsStream.h"
#include "Emu/Memory/Memory.h"
#include "Emu/ARMv7/PSVFuncList.h"
#include "ELF32.h"
//#define LOADER_DEBUG
void Elf32_Ehdr::Show()
{
#ifdef LOADER_DEBUG
@ -341,11 +344,15 @@ bool ELF32Loader::LoadPhdrInfo()
phdr_arr.back().Load(elf32_f);
}
if(entry & 0x1)
if (machine == MACHINE_ARM)
{
entry = (entry & ~0x3) + 0x81000000;
}
else if(entry & 0x3)
{
//entry is physical, convert to virtual
entry &= ~0x1;
entry &= ~0x3;
for(size_t i=0; i<phdr_arr.size(); ++i)
{
@ -502,6 +509,8 @@ bool ELF32Loader::LoadPhdrData(u64 _offset)
bool ELF32Loader::LoadShdrData(u64 offset)
{
u32 fnid_addr = 0;
for(u32 i=0; i<shdr_arr.size(); ++i)
{
Elf32_Shdr& shdr = shdr_arr[i];
@ -527,6 +536,88 @@ bool ELF32Loader::LoadShdrData(u64 offset)
{
max_addr = shdr.sh_addr + shdr.sh_size;
}
// probably should be in LoadPhdrData()
if (machine == MACHINE_ARM && !strcmp(shdr_name_arr[i].c_str(), ".sceFNID.rodata"))
{
fnid_addr = shdr.sh_addr;
}
else if (machine == MACHINE_ARM && !strcmp(shdr_name_arr[i].c_str(), ".sceFStub.rodata"))
{
list_known_psv_modules();
auto fnid = vm::psv::ptr<const u32>::make(fnid_addr);
auto fstub = vm::psv::ptr<const u32>::make(shdr.sh_addr);
for (u32 j = 0; j < shdr.sh_size / 4; j++)
{
u32 nid = fnid[j];
u32 addr = fstub[j];
if (auto func = get_psv_func_by_nid(nid))
{
if (func->module)
func->module->Notice("Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr);
else
LOG_NOTICE(LOADER, "Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr);
// writing Thumb code (temporarily, because it should be ARM)
vm::psv::write16(addr + 0, 0xf870); // HACK (special instruction that calls HLE function)
vm::psv::write16(addr + 2, (u16)get_psv_func_index(func));
vm::psv::write16(addr + 4, 0x4770); // BX LR
vm::psv::write16(addr + 6, 0); // null
}
else
{
LOG_ERROR(LOADER, "Unimplemented function 0x%08x (addr=0x%x)", nid, addr);
vm::psv::write16(addr + 0, 0xf870); // HACK (special instruction that calls HLE function)
vm::psv::write16(addr + 2, 0x0000); // (zero index)
vm::psv::write16(addr + 4, 0x4770); // BX LR
vm::psv::write16(addr + 6, 0); // null
}
}
}
else if (machine == MACHINE_ARM && !strcmp(shdr_name_arr[i].c_str(), ".sceRefs.rodata"))
{
auto code = vm::psv::ptr<const u32>::make(shdr.sh_addr);
u32 data = 0;
for (; code.addr() < shdr.sh_addr + shdr.sh_size; code++)
{
switch (*code)
{
case 0x000000ff:
{
// save address for future use
data = *++code;
break;
}
case 0x0000002f:
{
// movw r12,# instruction will be replaced
const u32 addr = *++code;
vm::psv::write16(addr + 0, 0xf240 | (data & 0x800) >> 1 | (data & 0xf000) >> 12); // MOVW
vm::psv::write16(addr + 2, 0x0c00 | (data & 0x700) << 4 | (data & 0xff));
break;
}
case 0x00000030:
{
// movt r12,# instruction will be replaced
const u32 addr = *++code;
vm::psv::write16(addr + 0, 0xf2c0 | (data & 0x8000000) >> 17 | (data & 0xf0000000) >> 28); // MOVT
vm::psv::write16(addr + 2, 0x0c00 | (data & 0x7000000) >> 12 | (data & 0xff0000) >> 16);
break;
}
case 0x00000000:
{
// probably, no operation
break;
}
default: LOG_NOTICE(LOADER, "sceRefs: unknown code found (0x%08x)", *code);
}
}
}
}
//TODO

2
rpcs3/Loader/ELF32.h
View File

@ -15,7 +15,7 @@ struct Elf32_Ehdr
u16 e_type;
u16 e_machine;
u32 e_version;
u16 e_entry;
u32 e_entry;
u32 e_phoff;
u32 e_shoff;
u32 e_flags;

8
rpcs3/emucore.vcxproj
View File

@ -74,7 +74,14 @@
<ClCompile Include="Crypto\unpkg.cpp" />
<ClCompile Include="Crypto\unself.cpp" />
<ClCompile Include="Crypto\utils.cpp" />
<ClCompile Include="Emu\ARMv7\ARMv7DisAsm.cpp" />
<ClCompile Include="Emu\ARMv7\ARMv7Interpreter.cpp" />
<ClCompile Include="Emu\ARMv7\ARMv7Thread.cpp" />
<ClCompile Include="Emu\ARMv7\Modules\sceLibKernel.cpp" />
<ClCompile Include="Emu\ARMv7\Modules\sceLibc.cpp" />
<ClCompile Include="Emu\ARMv7\Modules\sceLibm.cpp" />
<ClCompile Include="Emu\ARMv7\Modules\sceLibstdcxx.cpp" />
<ClCompile Include="Emu\ARMv7\PSVFuncList.cpp" />
<ClCompile Include="Emu\Audio\AL\OpenALThread.cpp" />
<ClCompile Include="Emu\Audio\AudioDumper.cpp" />
<ClCompile Include="Emu\Audio\AudioManager.cpp" />
@ -294,6 +301,7 @@
<ClInclude Include="Emu\ARMv7\ARMv7Interpreter.h" />
<ClInclude Include="Emu\ARMv7\ARMv7Opcodes.h" />
<ClInclude Include="Emu\ARMv7\ARMv7Thread.h" />
<ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
<ClInclude Include="Emu\Audio\AL\OpenALThread.h" />
<ClInclude Include="Emu\Audio\AudioDumper.h" />
<ClInclude Include="Emu\Audio\AudioManager.h" />

27
rpcs3/emucore.vcxproj.filters
View File

@ -75,6 +75,9 @@
<Filter Include="Emu\SysCalls\currently_unused">
<UniqueIdentifier>{ead7494f-a872-4b4d-a864-1a61c3b6012f}</UniqueIdentifier>
</Filter>
<Filter Include="Emu\ARMv7\Modules">
<UniqueIdentifier>{1d9e6fc4-9a79-4329-a8b5-081e24822aaa}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Crypto\aes.cpp">
@ -632,6 +635,27 @@
<ClCompile Include="Emu\Cell\PPULLVMRecompilerTests.cpp">
<Filter>Emu\Cell</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\ARMv7Interpreter.cpp">
<Filter>Emu\ARMv7</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\ARMv7DisAsm.cpp">
<Filter>Emu\ARMv7</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\PSVFuncList.cpp">
<Filter>Emu\ARMv7</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\Modules\sceLibc.cpp">
<Filter>Emu\ARMv7\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\Modules\sceLibstdcxx.cpp">
<Filter>Emu\ARMv7\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\Modules\sceLibKernel.cpp">
<Filter>Emu\ARMv7\Modules</Filter>
</ClCompile>
<ClCompile Include="Emu\ARMv7\Modules\sceLibm.cpp">
<Filter>Emu\ARMv7\Modules</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Crypto\aes.h">
@ -1243,5 +1267,8 @@
<ClInclude Include="Emu\Cell\PPULLVMRecompiler.h">
<Filter>Emu\Cell</Filter>
</ClInclude>
<ClInclude Include="Emu\ARMv7\PSVFuncList.h">
<Filter>Emu\ARMv7</Filter>
</ClInclude>
</ItemGroup>
</Project>