diff --git a/Source/AppConfig.cpp b/Source/AppConfig.cpp index 694957716..cabaf8a11 100644 --- a/Source/AppConfig.cpp +++ b/Source/AppConfig.cpp @@ -1,13 +1,12 @@ #include "AppConfig.h" #include "PathUtils.h" -#define BASE_DATA_PATH (L"Play Data Files") -#define CONFIG_FILENAME (L"config.xml") +#define BASE_DATA_PATH (L"Play Data Files") +#define CONFIG_FILENAME (L"config.xml") CAppConfig::CAppConfig() -: CConfig(BuildConfigPath()) + : CConfig(BuildConfigPath()) { - } Framework::CConfig::PathType CAppConfig::GetBasePath() diff --git a/Source/AppConfig.h b/Source/AppConfig.h index 0980f4d9c..aa41de175 100644 --- a/Source/AppConfig.h +++ b/Source/AppConfig.h @@ -6,11 +6,11 @@ class CAppConfig : public Framework::CConfig, public CSingleton { public: - CAppConfig(); - virtual ~CAppConfig() = default; + CAppConfig(); + virtual ~CAppConfig() = default; - static CConfig::PathType GetBasePath(); + static CConfig::PathType GetBasePath(); private: - static CConfig::PathType BuildConfigPath(); + static CConfig::PathType BuildConfigPath(); }; diff --git a/Source/BasicBlock.cpp b/Source/BasicBlock.cpp index a200a99bc..adbd52da4 100644 --- a/Source/BasicBlock.cpp +++ b/Source/BasicBlock.cpp @@ -26,12 +26,13 @@ #pragma pack(push, 1) struct AOT_BLOCK { - AOT_BLOCK_KEY key; - void* fct; + AOT_BLOCK_KEY key; + void* fct; }; #pragma pack(pop) -extern "C" { +extern "C" +{ extern AOT_BLOCK _aot_firstBlock; extern uint32 _aot_blockCount; } @@ -39,11 +40,11 @@ extern "C" { #endif CBasicBlock::CBasicBlock(CMIPS& context, uint32 begin, uint32 end) -: m_begin(begin) -, m_end(end) -, m_context(context) + : m_begin(begin) + , m_end(end) + , m_context(context) #ifdef AOT_USE_CACHE -, m_function(nullptr) + , m_function(nullptr) #endif { assert(m_end >= m_begin); @@ -51,8 +52,8 @@ CBasicBlock::CBasicBlock(CMIPS& context, uint32 begin, uint32 end) #ifdef AOT_BUILD_CACHE -Framework::CStdStream* CBasicBlock::m_aotBlockOutputStream(nullptr); -std::mutex CBasicBlock::m_aotBlockOutputStreamMutex; +Framework::CStdStream* CBasicBlock::m_aotBlockOutputStream(nullptr); +std::mutex CBasicBlock::m_aotBlockOutputStreamMutex; void CBasicBlock::SetAotBlockOutputStream(Framework::CStdStream* outputStream) { @@ -70,9 +71,9 @@ void CBasicBlock::Compile() { static #ifdef AOT_BUILD_CACHE - __declspec(thread) + __declspec(thread) #endif - CMipsJitter* jitter = nullptr; + CMipsJitter* jitter = nullptr; if(jitter == nullptr) { Jitter::CCodeGen* codeGen = Jitter::CreateCodeGen(); @@ -81,22 +82,21 @@ void CBasicBlock::Compile() for(unsigned int i = 0; i < 4; i++) { jitter->SetVariableAsConstant( - offsetof(CMIPS, m_State.nGPR[CMIPS::R0].nV[i]), - 0 - ); + offsetof(CMIPS, m_State.nGPR[CMIPS::R0].nV[i]), + 0); } } jitter->SetStream(&stream); jitter->Begin(); CompileRange(jitter); -// codeGen.DumpVariables(0); -// codeGen.EndQuota(); + // codeGen.DumpVariables(0); + // codeGen.EndQuota(); jitter->End(); } m_function = CMemoryFunction(stream.GetBuffer(), stream.GetSize()); - + #ifdef VTUNE_ENABLED if(iJIT_IsProfilingActive() == iJIT_SAMPLING_ON) { @@ -137,19 +137,18 @@ void CBasicBlock::Compile() AOT_BLOCK* blocksBegin = &_aot_firstBlock; AOT_BLOCK* blocksEnd = blocksBegin + _aot_blockCount; - AOT_BLOCK blockRef = { blockChecksum, m_begin, m_end, nullptr }; + AOT_BLOCK blockRef = {blockChecksum, m_begin, m_end, nullptr}; - static const auto blockComparer = - [] (const AOT_BLOCK& item1, const AOT_BLOCK& item2) - { - return item1.key < item2.key; - }; + static const auto blockComparer = + [](const AOT_BLOCK& item1, const AOT_BLOCK& item2) { + return item1.key < item2.key; + }; -// assert(std::is_sorted(blocksBegin, blocksEnd, blockComparer)); + // assert(std::is_sorted(blocksBegin, blocksEnd, blockComparer)); bool blockExists = std::binary_search(blocksBegin, blocksEnd, blockRef, blockComparer); auto blockIterator = std::lower_bound(blocksBegin, blocksEnd, blockRef, blockComparer); - + assert(blockExists); assert(blockIterator != blocksEnd); assert(blockIterator->key.crc == blockChecksum); @@ -192,9 +191,9 @@ void CBasicBlock::CompileRange(CMipsJitter* jitter) for(uint32 address = m_begin; address <= fixedEnd; address += 4) { m_context.m_pArch->CompileInstruction( - address, - jitter, - &m_context); + address, + jitter, + &m_context); //Sanity check assert(jitter->IsStackEmpty()); } diff --git a/Source/BasicBlock.h b/Source/BasicBlock.h index 89feda252..ef117aa81 100644 --- a/Source/BasicBlock.h +++ b/Source/BasicBlock.h @@ -9,11 +9,11 @@ struct AOT_BLOCK_KEY { - uint32 crc; - uint32 begin; - uint32 end; + uint32 crc; + uint32 begin; + uint32 end; - bool operator <(const AOT_BLOCK_KEY& k2) const + bool operator<(const AOT_BLOCK_KEY& k2) const { const auto& k1 = (*this); if(k1.crc == k2.crc) @@ -43,36 +43,35 @@ namespace Jitter class CBasicBlock { public: - CBasicBlock(CMIPS&, uint32, uint32); - virtual ~CBasicBlock() = default; - unsigned int Execute(); - void Compile(); + CBasicBlock(CMIPS&, uint32, uint32); + virtual ~CBasicBlock() = default; + unsigned int Execute(); + void Compile(); - uint32 GetBeginAddress() const; - uint32 GetEndAddress() const; - bool IsCompiled() const; + uint32 GetBeginAddress() const; + uint32 GetEndAddress() const; + bool IsCompiled() const; #ifdef AOT_BUILD_CACHE - static void SetAotBlockOutputStream(Framework::CStdStream*); + static void SetAotBlockOutputStream(Framework::CStdStream*); #endif protected: - uint32 m_begin; - uint32 m_end; - CMIPS& m_context; + uint32 m_begin; + uint32 m_end; + CMIPS& m_context; - virtual void CompileRange(CMipsJitter*); + virtual void CompileRange(CMipsJitter*); private: - #ifdef AOT_BUILD_CACHE - static Framework::CStdStream* m_aotBlockOutputStream; - static std::mutex m_aotBlockOutputStreamMutex; + static Framework::CStdStream* m_aotBlockOutputStream; + static std::mutex m_aotBlockOutputStreamMutex; #endif #ifndef AOT_USE_CACHE - CMemoryFunction m_function; + CMemoryFunction m_function; #else - void (*m_function)(void*); + void (*m_function)(void*); #endif }; diff --git a/Source/BiosDebugInfoProvider.h b/Source/BiosDebugInfoProvider.h index aab0a2b4c..76cae007d 100644 --- a/Source/BiosDebugInfoProvider.h +++ b/Source/BiosDebugInfoProvider.h @@ -7,10 +7,10 @@ struct BIOS_DEBUG_MODULE_INFO { - std::string name; - uint32 begin; - uint32 end; - void* param; + std::string name; + uint32 begin; + uint32 end; + void* param; }; typedef std::vector BiosDebugModuleInfoArray; @@ -18,12 +18,12 @@ typedef BiosDebugModuleInfoArray::iterator BiosDebugModuleInfoIterator; struct BIOS_DEBUG_THREAD_INFO { - uint32 id; - uint32 priority; - uint32 pc; - uint32 ra; - uint32 sp; - std::string stateDescription; + uint32 id; + uint32 priority; + uint32 pc; + uint32 ra; + uint32 sp; + std::string stateDescription; }; typedef std::vector BiosDebugThreadInfoArray; @@ -31,10 +31,12 @@ typedef std::vector BiosDebugThreadInfoArray; class CBiosDebugInfoProvider { public: - virtual ~CBiosDebugInfoProvider() {} + virtual ~CBiosDebugInfoProvider() + { + } #ifdef DEBUGGER_INCLUDED - virtual BiosDebugModuleInfoArray GetModulesDebugInfo() const = 0; - virtual BiosDebugThreadInfoArray GetThreadsDebugInfo() const = 0; + virtual BiosDebugModuleInfoArray GetModulesDebugInfo() const = 0; + virtual BiosDebugThreadInfoArray GetThreadsDebugInfo() const = 0; #endif }; diff --git a/Source/COP_FPU.cpp b/Source/COP_FPU.cpp index eaa1e37df..087c9eae3 100644 --- a/Source/COP_FPU.cpp +++ b/Source/COP_FPU.cpp @@ -7,19 +7,18 @@ #include "MemoryUtils.h" const uint32 CCOP_FPU::m_ccMask[8] = -{ - 0x00800000, - 0x02000000, - 0x04000000, - 0x08000000, - 0x10000000, - 0x20000000, - 0x40000000, - 0x80000000 -}; + { + 0x00800000, + 0x02000000, + 0x04000000, + 0x08000000, + 0x10000000, + 0x20000000, + 0x40000000, + 0x80000000}; CCOP_FPU::CCOP_FPU(MIPS_REGSIZE regSize) -: CMIPSCoprocessor(regSize) + : CMIPSCoprocessor(regSize) { SetupReflectionTables(); } diff --git a/Source/COP_FPU.h b/Source/COP_FPU.h index 16736102b..3276ef5b1 100644 --- a/Source/COP_FPU.h +++ b/Source/COP_FPU.h @@ -6,108 +6,108 @@ class CCOP_FPU : public CMIPSCoprocessor { public: - CCOP_FPU(MIPS_REGSIZE); - void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - void GetInstruction(uint32, char*) override; - void GetArguments(uint32, uint32, char*) override; - uint32 GetEffectiveAddress(uint32, uint32) override; - MIPS_BRANCH_TYPE IsBranch(uint32) override; + CCOP_FPU(MIPS_REGSIZE); + void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + void GetInstruction(uint32, char*) override; + void GetArguments(uint32, uint32, char*) override; + uint32 GetEffectiveAddress(uint32, uint32) override; + MIPS_BRANCH_TYPE IsBranch(uint32) override; protected: - void SetupReflectionTables(); + void SetupReflectionTables(); - static void ReflOpRtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtFcs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFdFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFdFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpCcFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFdFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpCcOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtFcs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFdFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFdFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpCcFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFdFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpCcOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - MIPSReflection::INSTRUCTION m_reflGeneral[64]; - MIPSReflection::INSTRUCTION m_reflCop1[32]; - MIPSReflection::INSTRUCTION m_reflBc1[4]; - MIPSReflection::INSTRUCTION m_reflS[64]; - MIPSReflection::INSTRUCTION m_reflW[64]; + MIPSReflection::INSTRUCTION m_reflGeneral[64]; + MIPSReflection::INSTRUCTION m_reflCop1[32]; + MIPSReflection::INSTRUCTION m_reflBc1[4]; + MIPSReflection::INSTRUCTION m_reflS[64]; + MIPSReflection::INSTRUCTION m_reflW[64]; - MIPSReflection::SUBTABLE m_reflGeneralTable; - MIPSReflection::SUBTABLE m_reflCop1Table; - MIPSReflection::SUBTABLE m_reflBc1Table; - MIPSReflection::SUBTABLE m_reflSTable; - MIPSReflection::SUBTABLE m_reflWTable; + MIPSReflection::SUBTABLE m_reflGeneralTable; + MIPSReflection::SUBTABLE m_reflCop1Table; + MIPSReflection::SUBTABLE m_reflBc1Table; + MIPSReflection::SUBTABLE m_reflSTable; + MIPSReflection::SUBTABLE m_reflWTable; private: typedef void (CCOP_FPU::*InstructionFuncConstant)(); - uint8 m_ft = 0; - uint8 m_fs = 0; - uint8 m_fd = 0; + uint8 m_ft = 0; + uint8 m_fs = 0; + uint8 m_fd = 0; - static const uint32 m_ccMask[8]; + static const uint32 m_ccMask[8]; - void SetCCBit(bool, uint32); - void PushCCBit(uint32); + void SetCCBit(bool, uint32); + void PushCCBit(uint32); - static InstructionFuncConstant m_opGeneral[0x20]; - static InstructionFuncConstant m_opSingle[0x40]; - static InstructionFuncConstant m_opWord[0x40]; + static InstructionFuncConstant m_opGeneral[0x20]; + static InstructionFuncConstant m_opSingle[0x40]; + static InstructionFuncConstant m_opWord[0x40]; //General - void MFC1(); - void CFC1(); - void MTC1(); - void CTC1(); - void BC1(); - void S(); - void W(); + void MFC1(); + void CFC1(); + void MTC1(); + void CTC1(); + void BC1(); + void S(); + void W(); //Branch - void BC1F(); - void BC1T(); - void BC1FL(); - void BC1TL(); + void BC1F(); + void BC1T(); + void BC1FL(); + void BC1TL(); //Single - void ADD_S(); - void SUB_S(); - void MUL_S(); - void DIV_S(); - void SQRT_S(); - void ABS_S(); - void MOV_S(); - void NEG_S(); - void TRUNC_W_S(); - void RSQRT_S(); - void ADDA_S(); - void SUBA_S(); - void MULA_S(); - void MADD_S(); - void MSUB_S(); - void MADDA_S(); - void MSUBA_S(); - void CVT_W_S(); - void MAX_S(); - void MIN_S(); - void C_F_S(); - void C_EQ_S(); - void C_LT_S(); - void C_LE_S(); + void ADD_S(); + void SUB_S(); + void MUL_S(); + void DIV_S(); + void SQRT_S(); + void ABS_S(); + void MOV_S(); + void NEG_S(); + void TRUNC_W_S(); + void RSQRT_S(); + void ADDA_S(); + void SUBA_S(); + void MULA_S(); + void MADD_S(); + void MSUB_S(); + void MADDA_S(); + void MSUBA_S(); + void CVT_W_S(); + void MAX_S(); + void MIN_S(); + void C_F_S(); + void C_EQ_S(); + void C_LT_S(); + void C_LE_S(); //Word - void CVT_S_W(); + void CVT_S_W(); //Misc - void LWC1(); - void SWC1(); + void LWC1(); + void SWC1(); //Reflection tables - static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; - static MIPSReflection::INSTRUCTION m_cReflCop1[32]; - static MIPSReflection::INSTRUCTION m_cReflBc1[4]; - static MIPSReflection::INSTRUCTION m_cReflS[64]; - static MIPSReflection::INSTRUCTION m_cReflW[64]; + static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; + static MIPSReflection::INSTRUCTION m_cReflCop1[32]; + static MIPSReflection::INSTRUCTION m_cReflBc1[4]; + static MIPSReflection::INSTRUCTION m_cReflS[64]; + static MIPSReflection::INSTRUCTION m_cReflW[64]; }; diff --git a/Source/COP_FPU_Reflection.cpp b/Source/COP_FPU_Reflection.cpp index 3be103c8f..29c58fd9b 100644 --- a/Source/COP_FPU_Reflection.cpp +++ b/Source/COP_FPU_Reflection.cpp @@ -24,7 +24,7 @@ void CCOP_FPU::ReflOpRtFcs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, ui void CCOP_FPU::ReflOpFdFs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); + uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); sprintf(sText, "F%i, F%i", nFD, nFS); } @@ -32,7 +32,7 @@ void CCOP_FPU::ReflOpFdFs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uin void CCOP_FPU::ReflOpFdFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); + uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); sprintf(sText, "F%i, F%i", nFD, nFT); } @@ -49,7 +49,7 @@ void CCOP_FPU::ReflOpCcFsFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, u { uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nCC = static_cast((nOpcode >> 8) & 0x0007); + uint8 nCC = static_cast((nOpcode >> 8) & 0x0007); sprintf(sText, "CC%i, F%i, F%i", nCC, nFS, nFT); } @@ -58,30 +58,30 @@ void CCOP_FPU::ReflOpFdFsFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, u { uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); + uint8 nFD = static_cast((nOpcode >> 6) & 0x001F); sprintf(sText, "F%i, F%i, F%i", nFD, nFS, nFT); } void CCOP_FPU::ReflOpFtOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nRS = static_cast ((nOpcode >> 21) & 0x001F); - uint8 nFT = static_cast ((nOpcode >> 16) & 0x001F); - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint8 nRS = static_cast((nOpcode >> 21) & 0x001F); + uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); sprintf(sText, "F%i, $%04X(%s)", nFT, nImm, CMIPS::m_sGPRName[nRS]); } void CCOP_FPU::ReflOpCcOff(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "CC%i, $%08X", (nOpcode >> 18) & 0x07, nAddress + CMIPS::GetBranch(nImm)); } uint32 CCOP_FPU::ReflEaOffset(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); nAddress += 4; return (nAddress + CMIPS::GetBranch(nImm)); } @@ -367,43 +367,43 @@ INSTRUCTION CCOP_FPU::m_cReflW[64] = void CCOP_FPU::SetupReflectionTables() { - static_assert(sizeof(m_reflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_reflCop1) == sizeof(m_cReflCop1), "Array sizes don't match"); - static_assert(sizeof(m_reflBc1) == sizeof(m_cReflBc1), "Array sizes don't match"); - static_assert(sizeof(m_reflS) == sizeof(m_cReflS), "Array sizes don't match"); - static_assert(sizeof(m_reflW) == sizeof(m_cReflW), "Array sizes don't match"); + static_assert(sizeof(m_reflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_reflCop1) == sizeof(m_cReflCop1), "Array sizes don't match"); + static_assert(sizeof(m_reflBc1) == sizeof(m_cReflBc1), "Array sizes don't match"); + static_assert(sizeof(m_reflS) == sizeof(m_cReflS), "Array sizes don't match"); + static_assert(sizeof(m_reflW) == sizeof(m_cReflW), "Array sizes don't match"); - memcpy(m_reflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); - memcpy(m_reflCop1, m_cReflCop1, sizeof(m_cReflCop1)); - memcpy(m_reflBc1, m_cReflBc1, sizeof(m_cReflBc1)); - memcpy(m_reflS, m_cReflS, sizeof(m_cReflS)); - memcpy(m_reflW, m_cReflW, sizeof(m_cReflW)); + memcpy(m_reflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); + memcpy(m_reflCop1, m_cReflCop1, sizeof(m_cReflCop1)); + memcpy(m_reflBc1, m_cReflBc1, sizeof(m_cReflBc1)); + memcpy(m_reflS, m_cReflS, sizeof(m_cReflS)); + memcpy(m_reflW, m_cReflW, sizeof(m_cReflW)); - m_reflGeneralTable.nShift = 26; - m_reflGeneralTable.nMask = 0x3F; - m_reflGeneralTable.pTable = m_reflGeneral; + m_reflGeneralTable.nShift = 26; + m_reflGeneralTable.nMask = 0x3F; + m_reflGeneralTable.pTable = m_reflGeneral; - m_reflCop1Table.nShift = 21; - m_reflCop1Table.nMask = 0x1F; - m_reflCop1Table.pTable = m_reflCop1; + m_reflCop1Table.nShift = 21; + m_reflCop1Table.nMask = 0x1F; + m_reflCop1Table.pTable = m_reflCop1; - m_reflBc1Table.nShift = 16; - m_reflBc1Table.nMask = 0x03; - m_reflBc1Table.pTable = m_reflBc1; + m_reflBc1Table.nShift = 16; + m_reflBc1Table.nMask = 0x03; + m_reflBc1Table.pTable = m_reflBc1; - m_reflSTable.nShift = 0; - m_reflSTable.nMask = 0x3F; - m_reflSTable.pTable = m_reflS; + m_reflSTable.nShift = 0; + m_reflSTable.nMask = 0x3F; + m_reflSTable.pTable = m_reflS; - m_reflWTable.nShift = 0; - m_reflWTable.nMask = 0x3F; - m_reflWTable.pTable = m_reflW; + m_reflWTable.nShift = 0; + m_reflWTable.nMask = 0x3F; + m_reflWTable.pTable = m_reflW; - m_reflGeneral[0x11].pSubTable = &m_reflCop1Table; + m_reflGeneral[0x11].pSubTable = &m_reflCop1Table; - m_reflCop1[0x08].pSubTable = &m_reflBc1Table; - m_reflCop1[0x10].pSubTable = &m_reflSTable; - m_reflCop1[0x14].pSubTable = &m_reflWTable; + m_reflCop1[0x08].pSubTable = &m_reflBc1Table; + m_reflCop1[0x10].pSubTable = &m_reflSTable; + m_reflCop1[0x14].pSubTable = &m_reflWTable; } void CCOP_FPU::GetInstruction(uint32 nOpcode, char* sText) @@ -416,8 +416,8 @@ void CCOP_FPU::GetInstruction(uint32 nOpcode, char* sText) } INSTRUCTION Instr; - Instr.pGetMnemonic = SubTableMnemonic; - Instr.pSubTable = &m_reflGeneralTable; + Instr.pGetMnemonic = SubTableMnemonic; + Instr.pSubTable = &m_reflGeneralTable; Instr.pGetMnemonic(&Instr, NULL, nOpcode, sText, nCount); } @@ -431,8 +431,8 @@ void CCOP_FPU::GetArguments(uint32 nAddress, uint32 nOpcode, char* sText) } INSTRUCTION Instr; - Instr.pGetOperands = SubTableOperands; - Instr.pSubTable = &m_reflGeneralTable; + Instr.pGetOperands = SubTableOperands; + Instr.pSubTable = &m_reflGeneralTable; Instr.pGetOperands(&Instr, NULL, nAddress, nOpcode, sText, nCount); } @@ -441,8 +441,8 @@ MIPS_BRANCH_TYPE CCOP_FPU::IsBranch(uint32 nOpcode) if(nOpcode == 0) return MIPS_BRANCH_NONE; INSTRUCTION Instr; - Instr.pIsBranch = SubTableIsBranch; - Instr.pSubTable = &m_reflGeneralTable; + Instr.pIsBranch = SubTableIsBranch; + Instr.pSubTable = &m_reflGeneralTable; return Instr.pIsBranch(&Instr, NULL, nOpcode); } @@ -451,7 +451,7 @@ uint32 CCOP_FPU::GetEffectiveAddress(uint32 nAddress, uint32 nOpcode) if(nOpcode == 0) return 0; INSTRUCTION Instr; - Instr.pGetEffectiveAddress = SubTableEffAddr; - Instr.pSubTable = &m_reflGeneralTable; + Instr.pGetEffectiveAddress = SubTableEffAddr; + Instr.pSubTable = &m_reflGeneralTable; return Instr.pGetEffectiveAddress(&Instr, NULL, nAddress, nOpcode); } diff --git a/Source/COP_SCU.cpp b/Source/COP_SCU.cpp index f2862eae6..5fe280b0c 100644 --- a/Source/COP_SCU.cpp +++ b/Source/COP_SCU.cpp @@ -45,9 +45,9 @@ const char* CCOP_SCU::m_sRegName[] = // clang-format on CCOP_SCU::CCOP_SCU(MIPS_REGSIZE nRegSize) -: CMIPSCoprocessor(nRegSize) -, m_nRT(0) -, m_nRD(0) + : CMIPSCoprocessor(nRegSize) + , m_nRT(0) + , m_nRD(0) { SetupReflectionTables(); } @@ -56,8 +56,8 @@ void CCOP_SCU::CompileInstruction(uint32 nAddress, CMipsJitter* codeGen, CMIPS* { SetupQuickVariables(nAddress, codeGen, pCtx); - m_nRT = (uint8)((m_nOpcode >> 16) & 0x1F); - m_nRD = (uint8)((m_nOpcode >> 11) & 0x1F); + m_nRT = (uint8)((m_nOpcode >> 16) & 0x1F); + m_nRD = (uint8)((m_nOpcode >> 11) & 0x1F); ((this)->*(m_pOpGeneral[(m_nOpcode >> 21) & 0x1F]))(); } @@ -213,7 +213,7 @@ void CCOP_SCU::ERET() m_codeGen->PushRel(offsetof(CMIPS, m_State.nCOP0[STATUS])); m_codeGen->PushCst(CMIPS::STATUS_ERL); m_codeGen->And(); - + m_codeGen->PushCst(0); m_codeGen->BeginIf(Jitter::CONDITION_NE); { diff --git a/Source/COP_SCU.h b/Source/COP_SCU.h index 7a24d057a..61bfb3a0d 100644 --- a/Source/COP_SCU.h +++ b/Source/COP_SCU.h @@ -9,105 +9,104 @@ class CCOP_SCU : public CMIPSCoprocessor public: enum REGISTER { - COUNT = 0x09, - STATUS = 0x0C, - EPC = 0x0E, - CPCOND0 = 0x15, - ERROREPC = 0x1E, + COUNT = 0x09, + STATUS = 0x0C, + EPC = 0x0E, + CPCOND0 = 0x15, + ERROREPC = 0x1E, }; struct PCCR : public convertible { - unsigned int reserved0 : 1; - unsigned int exl0 : 1; - unsigned int k0 : 1; - unsigned int s0 : 1; - unsigned int u0 : 1; - unsigned int event0 : 5; - unsigned int reserved1 : 1; - unsigned int exl1 : 1; - unsigned int k1 : 1; - unsigned int s1 : 1; - unsigned int u1 : 1; - unsigned int event1 : 5; - unsigned int reserved2 : 11; - unsigned int cte : 1; + unsigned int reserved0 : 1; + unsigned int exl0 : 1; + unsigned int k0 : 1; + unsigned int s0 : 1; + unsigned int u0 : 1; + unsigned int event0 : 5; + unsigned int reserved1 : 1; + unsigned int exl1 : 1; + unsigned int k1 : 1; + unsigned int s1 : 1; + unsigned int u1 : 1; + unsigned int event1 : 5; + unsigned int reserved2 : 11; + unsigned int cte : 1; }; static_assert(sizeof(PCCR) == 4, "PCCR must be 4 bytes long."); - CCOP_SCU(MIPS_REGSIZE); - virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - virtual void GetInstruction(uint32, char*) override; - virtual void GetArguments(uint32, uint32, char*) override; - virtual uint32 GetEffectiveAddress(uint32, uint32) override; - virtual MIPS_BRANCH_TYPE IsBranch(uint32) override; + CCOP_SCU(MIPS_REGSIZE); + virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + virtual void GetInstruction(uint32, char*) override; + virtual void GetArguments(uint32, uint32, char*) override; + virtual uint32 GetEffectiveAddress(uint32, uint32) override; + virtual MIPS_BRANCH_TYPE IsBranch(uint32) override; - static const char* m_sRegName[]; + static const char* m_sRegName[]; protected: - void SetupReflectionTables(); + void SetupReflectionTables(); - static void ReflOpRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtPcr(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtRd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpCcOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtPcr(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtRd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpCcOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - MIPSReflection::INSTRUCTION m_ReflGeneral[64]; - MIPSReflection::INSTRUCTION m_ReflMfc0[32]; - MIPSReflection::INSTRUCTION m_ReflMtc0[32]; - MIPSReflection::INSTRUCTION m_ReflCop0[32]; - MIPSReflection::INSTRUCTION m_ReflBc0[4]; - MIPSReflection::INSTRUCTION m_ReflC0[64]; - MIPSReflection::INSTRUCTION m_ReflMfPerf[2]; - MIPSReflection::INSTRUCTION m_ReflMtPerf[2]; - - MIPSReflection::SUBTABLE m_ReflGeneralTable; - MIPSReflection::SUBTABLE m_ReflMfc0Table; - MIPSReflection::SUBTABLE m_ReflMtc0Table; - MIPSReflection::SUBTABLE m_ReflCop0Table; - MIPSReflection::SUBTABLE m_ReflBc0Table; - MIPSReflection::SUBTABLE m_ReflC0Table; - MIPSReflection::SUBTABLE m_ReflMfPerfTable; - MIPSReflection::SUBTABLE m_ReflMtPerfTable; + MIPSReflection::INSTRUCTION m_ReflGeneral[64]; + MIPSReflection::INSTRUCTION m_ReflMfc0[32]; + MIPSReflection::INSTRUCTION m_ReflMtc0[32]; + MIPSReflection::INSTRUCTION m_ReflCop0[32]; + MIPSReflection::INSTRUCTION m_ReflBc0[4]; + MIPSReflection::INSTRUCTION m_ReflC0[64]; + MIPSReflection::INSTRUCTION m_ReflMfPerf[2]; + MIPSReflection::INSTRUCTION m_ReflMtPerf[2]; + MIPSReflection::SUBTABLE m_ReflGeneralTable; + MIPSReflection::SUBTABLE m_ReflMfc0Table; + MIPSReflection::SUBTABLE m_ReflMtc0Table; + MIPSReflection::SUBTABLE m_ReflCop0Table; + MIPSReflection::SUBTABLE m_ReflBc0Table; + MIPSReflection::SUBTABLE m_ReflC0Table; + MIPSReflection::SUBTABLE m_ReflMfPerfTable; + MIPSReflection::SUBTABLE m_ReflMtPerfTable; private: typedef void (CCOP_SCU::*InstructionFuncConstant)(); - static InstructionFuncConstant m_pOpGeneral[0x20]; - static InstructionFuncConstant m_pOpMtc0[0x20]; - static InstructionFuncConstant m_pOpBC0[0x20]; - static InstructionFuncConstant m_pOpC0[0x40]; + static InstructionFuncConstant m_pOpGeneral[0x20]; + static InstructionFuncConstant m_pOpMtc0[0x20]; + static InstructionFuncConstant m_pOpBC0[0x20]; + static InstructionFuncConstant m_pOpC0[0x40]; - uint8 m_nRT; - uint8 m_nRD; + uint8 m_nRT; + uint8 m_nRD; //General - void MFC0(); - void MTC0(); - void BC0(); - void C0(); + void MFC0(); + void MTC0(); + void BC0(); + void C0(); //BC0 - void BC0F(); - void BC0T(); - void BC0FL(); + void BC0F(); + void BC0T(); + void BC0FL(); //C0 - void TLBWI(); - void ERET(); - void EI(); - void DI(); + void TLBWI(); + void ERET(); + void EI(); + void DI(); //Reflection tables - static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; - static MIPSReflection::INSTRUCTION m_cReflCop0[32]; - static MIPSReflection::INSTRUCTION m_cReflMfc0[32]; - static MIPSReflection::INSTRUCTION m_cReflMtc0[32]; - static MIPSReflection::INSTRUCTION m_cReflBc0[4]; - static MIPSReflection::INSTRUCTION m_cReflC0[64]; - static MIPSReflection::INSTRUCTION m_cReflMfPerf[2]; - static MIPSReflection::INSTRUCTION m_cReflMtPerf[2]; + static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; + static MIPSReflection::INSTRUCTION m_cReflCop0[32]; + static MIPSReflection::INSTRUCTION m_cReflMfc0[32]; + static MIPSReflection::INSTRUCTION m_cReflMtc0[32]; + static MIPSReflection::INSTRUCTION m_cReflBc0[4]; + static MIPSReflection::INSTRUCTION m_cReflC0[64]; + static MIPSReflection::INSTRUCTION m_cReflMfPerf[2]; + static MIPSReflection::INSTRUCTION m_cReflMtPerf[2]; }; diff --git a/Source/COP_SCU_Reflection.cpp b/Source/COP_SCU_Reflection.cpp index bd41606ab..0ff303daf 100644 --- a/Source/COP_SCU_Reflection.cpp +++ b/Source/COP_SCU_Reflection.cpp @@ -30,14 +30,14 @@ void CCOP_SCU::ReflOpRtRd(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uin void CCOP_SCU::ReflOpCcOff(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "CC%i, $%08X", (nOpcode >> 18) & 0x07, nAddress + CMIPS::GetBranch(nImm)); } uint32 CCOP_SCU::ReflEaOffset(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); nAddress += 4; return (nAddress + CMIPS::GetBranch(nImm)); } @@ -339,66 +339,66 @@ INSTRUCTION CCOP_SCU::m_cReflMtPerf[2] = void CCOP_SCU::SetupReflectionTables() { - static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_ReflCop0) == sizeof(m_cReflCop0), "Array sizes don't match"); - static_assert(sizeof(m_ReflMfc0) == sizeof(m_cReflMfc0), "Array sizes don't match"); - static_assert(sizeof(m_ReflMtc0) == sizeof(m_cReflMtc0), "Array sizes don't match"); - static_assert(sizeof(m_ReflBc0) == sizeof(m_cReflBc0), "Array sizes don't match"); - static_assert(sizeof(m_ReflC0) == sizeof(m_cReflC0), "Array sizes don't match"); - static_assert(sizeof(m_ReflMtPerf) == sizeof(m_cReflMtPerf), "Array sizes don't match"); - static_assert(sizeof(m_ReflMfPerf) == sizeof(m_cReflMfPerf), "Array sizes don't match"); + static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_ReflCop0) == sizeof(m_cReflCop0), "Array sizes don't match"); + static_assert(sizeof(m_ReflMfc0) == sizeof(m_cReflMfc0), "Array sizes don't match"); + static_assert(sizeof(m_ReflMtc0) == sizeof(m_cReflMtc0), "Array sizes don't match"); + static_assert(sizeof(m_ReflBc0) == sizeof(m_cReflBc0), "Array sizes don't match"); + static_assert(sizeof(m_ReflC0) == sizeof(m_cReflC0), "Array sizes don't match"); + static_assert(sizeof(m_ReflMtPerf) == sizeof(m_cReflMtPerf), "Array sizes don't match"); + static_assert(sizeof(m_ReflMfPerf) == sizeof(m_cReflMfPerf), "Array sizes don't match"); - memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); - memcpy(m_ReflCop0, m_cReflCop0, sizeof(m_cReflCop0)); - memcpy(m_ReflMtc0, m_cReflMtc0, sizeof(m_cReflMtc0)); - memcpy(m_ReflMfc0, m_cReflMfc0, sizeof(m_cReflMfc0)); - memcpy(m_ReflBc0, m_cReflBc0, sizeof(m_cReflBc0)); - memcpy(m_ReflC0, m_cReflC0, sizeof(m_cReflC0)); - memcpy(m_ReflMtPerf, m_cReflMtPerf, sizeof(m_cReflMtPerf)); - memcpy(m_ReflMfPerf, m_cReflMfPerf, sizeof(m_cReflMfPerf)); + memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); + memcpy(m_ReflCop0, m_cReflCop0, sizeof(m_cReflCop0)); + memcpy(m_ReflMtc0, m_cReflMtc0, sizeof(m_cReflMtc0)); + memcpy(m_ReflMfc0, m_cReflMfc0, sizeof(m_cReflMfc0)); + memcpy(m_ReflBc0, m_cReflBc0, sizeof(m_cReflBc0)); + memcpy(m_ReflC0, m_cReflC0, sizeof(m_cReflC0)); + memcpy(m_ReflMtPerf, m_cReflMtPerf, sizeof(m_cReflMtPerf)); + memcpy(m_ReflMfPerf, m_cReflMfPerf, sizeof(m_cReflMfPerf)); - m_ReflGeneralTable.nShift = 26; - m_ReflGeneralTable.nMask = 0x3F; - m_ReflGeneralTable.pTable = m_ReflGeneral; + m_ReflGeneralTable.nShift = 26; + m_ReflGeneralTable.nMask = 0x3F; + m_ReflGeneralTable.pTable = m_ReflGeneral; - m_ReflCop0Table.nShift = 21; - m_ReflCop0Table.nMask = 0x1F; - m_ReflCop0Table.pTable = m_ReflCop0; + m_ReflCop0Table.nShift = 21; + m_ReflCop0Table.nMask = 0x1F; + m_ReflCop0Table.pTable = m_ReflCop0; - m_ReflMfc0Table.nShift = 11; - m_ReflMfc0Table.nMask = 0x1F; - m_ReflMfc0Table.pTable = m_ReflMfc0; + m_ReflMfc0Table.nShift = 11; + m_ReflMfc0Table.nMask = 0x1F; + m_ReflMfc0Table.pTable = m_ReflMfc0; - m_ReflMtc0Table.nShift = 11; - m_ReflMtc0Table.nMask = 0x1F; - m_ReflMtc0Table.pTable = m_ReflMtc0; + m_ReflMtc0Table.nShift = 11; + m_ReflMtc0Table.nMask = 0x1F; + m_ReflMtc0Table.pTable = m_ReflMtc0; - m_ReflBc0Table.nShift = 16; - m_ReflBc0Table.nMask = 0x03; - m_ReflBc0Table.pTable = m_ReflBc0; + m_ReflBc0Table.nShift = 16; + m_ReflBc0Table.nMask = 0x03; + m_ReflBc0Table.pTable = m_ReflBc0; - m_ReflC0Table.nShift = 0; - m_ReflC0Table.nMask = 0x3F; - m_ReflC0Table.pTable = m_ReflC0; + m_ReflC0Table.nShift = 0; + m_ReflC0Table.nMask = 0x3F; + m_ReflC0Table.pTable = m_ReflC0; - m_ReflMfPerfTable.nShift = 0; - m_ReflMfPerfTable.nMask = 1; - m_ReflMfPerfTable.pTable = m_ReflMfPerf; + m_ReflMfPerfTable.nShift = 0; + m_ReflMfPerfTable.nMask = 1; + m_ReflMfPerfTable.pTable = m_ReflMfPerf; - m_ReflMtPerfTable.nShift = 0; - m_ReflMtPerfTable.nMask = 1; - m_ReflMtPerfTable.pTable = m_ReflMtPerf; + m_ReflMtPerfTable.nShift = 0; + m_ReflMtPerfTable.nMask = 1; + m_ReflMtPerfTable.pTable = m_ReflMtPerf; - m_ReflGeneral[0x10].pSubTable = &m_ReflCop0Table; + m_ReflGeneral[0x10].pSubTable = &m_ReflCop0Table; - m_ReflCop0[0x00].pSubTable = &m_ReflMfc0Table; - m_ReflCop0[0x04].pSubTable = &m_ReflMtc0Table; - m_ReflCop0[0x08].pSubTable = &m_ReflBc0Table; - m_ReflCop0[0x10].pSubTable = &m_ReflC0Table; + m_ReflCop0[0x00].pSubTable = &m_ReflMfc0Table; + m_ReflCop0[0x04].pSubTable = &m_ReflMtc0Table; + m_ReflCop0[0x08].pSubTable = &m_ReflBc0Table; + m_ReflCop0[0x10].pSubTable = &m_ReflC0Table; - m_ReflMfc0[0x19].pSubTable = &m_ReflMfPerfTable; + m_ReflMfc0[0x19].pSubTable = &m_ReflMfPerfTable; - m_ReflMtc0[0x19].pSubTable = &m_ReflMtPerfTable; + m_ReflMtc0[0x19].pSubTable = &m_ReflMtPerfTable; } void CCOP_SCU::GetInstruction(uint32 nOpcode, char* sText) @@ -411,8 +411,8 @@ void CCOP_SCU::GetInstruction(uint32 nOpcode, char* sText) } INSTRUCTION Instr; - Instr.pGetMnemonic = SubTableMnemonic; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetMnemonic = SubTableMnemonic; + Instr.pSubTable = &m_ReflGeneralTable; Instr.pGetMnemonic(&Instr, NULL, nOpcode, sText, nCount); } @@ -426,8 +426,8 @@ void CCOP_SCU::GetArguments(uint32 nAddress, uint32 nOpcode, char* sText) } INSTRUCTION Instr; - Instr.pGetOperands = SubTableOperands; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetOperands = SubTableOperands; + Instr.pSubTable = &m_ReflGeneralTable; Instr.pGetOperands(&Instr, NULL, nAddress, nOpcode, sText, nCount); } @@ -436,8 +436,8 @@ MIPS_BRANCH_TYPE CCOP_SCU::IsBranch(uint32 nOpcode) if(nOpcode == 0) return MIPS_BRANCH_NONE; INSTRUCTION Instr; - Instr.pIsBranch = SubTableIsBranch; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pIsBranch = SubTableIsBranch; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pIsBranch(&Instr, NULL, nOpcode); } @@ -446,7 +446,7 @@ uint32 CCOP_SCU::GetEffectiveAddress(uint32 nAddress, uint32 nOpcode) if(nOpcode == 0) return 0; INSTRUCTION Instr; - Instr.pGetEffectiveAddress = SubTableEffAddr; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetEffectiveAddress = SubTableEffAddr; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pGetEffectiveAddress(&Instr, NULL, nAddress, nOpcode); } diff --git a/Source/ControllerInfo.cpp b/Source/ControllerInfo.cpp index 5b70244eb..4b9c7628d 100644 --- a/Source/ControllerInfo.cpp +++ b/Source/ControllerInfo.cpp @@ -3,34 +3,32 @@ using namespace PS2; const char* CControllerInfo::m_buttonName[CControllerInfo::MAX_BUTTONS] = -{ - "analog_left_x", - "analog_left_y", - "analog_right_x", - "analog_right_y", - "dpad_up", - "dpad_down", - "dpad_left", - "dpad_right", - "select", - "start", - "square", - "triangle", - "circle", - "cross", - "l1", - "l2", - "l3", - "r1", - "r2", - "r3" -}; + { + "analog_left_x", + "analog_left_y", + "analog_right_x", + "analog_right_y", + "dpad_up", + "dpad_down", + "dpad_left", + "dpad_right", + "select", + "start", + "square", + "triangle", + "circle", + "cross", + "l1", + "l2", + "l3", + "r1", + "r2", + "r3"}; bool CControllerInfo::IsAxis(BUTTON button) { - return - (button == ANALOG_LEFT_X) || - (button == ANALOG_LEFT_Y) || - (button == ANALOG_RIGHT_X) || - (button == ANALOG_RIGHT_Y); + return (button == ANALOG_LEFT_X) || + (button == ANALOG_LEFT_Y) || + (button == ANALOG_RIGHT_X) || + (button == ANALOG_RIGHT_Y); } diff --git a/Source/ControllerInfo.h b/Source/ControllerInfo.h index 4a8b61316..de3514c11 100644 --- a/Source/ControllerInfo.h +++ b/Source/ControllerInfo.h @@ -32,8 +32,8 @@ namespace PS2 MAX_BUTTONS }; - static const char* m_buttonName[MAX_BUTTONS]; + static const char* m_buttonName[MAX_BUTTONS]; - static bool IsAxis(BUTTON); + static bool IsAxis(BUTTON); }; }; diff --git a/Source/CsoImageStream.cpp b/Source/CsoImageStream.cpp index 5f40f16ee..e09e8efb3 100644 --- a/Source/CsoImageStream.cpp +++ b/Source/CsoImageStream.cpp @@ -22,7 +22,11 @@ struct CsoHeader }; CCsoImageStream::CCsoImageStream(CStream* baseStream) - : m_baseStream(baseStream), m_readBuffer(nullptr), m_zlibBuffer(nullptr), m_index(nullptr), m_position(0) + : m_baseStream(baseStream) + , m_readBuffer(nullptr) + , m_zlibBuffer(nullptr) + , m_index(nullptr) + , m_position(0) { if(baseStream == nullptr) { @@ -35,9 +39,9 @@ CCsoImageStream::CCsoImageStream(CStream* baseStream) CCsoImageStream::~CCsoImageStream() { - delete [] m_readBuffer; - delete [] m_zlibBuffer; - delete [] m_index; + delete[] m_readBuffer; + delete[] m_zlibBuffer; + delete[] m_index; } void CCsoImageStream::ReadFileHeader() @@ -106,7 +110,7 @@ void CCsoImageStream::InitializeBuffers() void CCsoImageStream::Seek(int64 position, Framework::STREAM_SEEK_DIRECTION origin) { - switch (origin) + switch(origin) { case Framework::STREAM_SEEK_CUR: m_position += position; diff --git a/Source/CsoImageStream.h b/Source/CsoImageStream.h index bc2930617..f1f0ca48b 100644 --- a/Source/CsoImageStream.h +++ b/Source/CsoImageStream.h @@ -6,31 +6,31 @@ class CCsoImageStream : public Framework::CStream { public: - CCsoImageStream(Framework::CStream* baseStream); - virtual ~CCsoImageStream(); + CCsoImageStream(Framework::CStream* baseStream); + virtual ~CCsoImageStream(); - virtual void Seek(int64 pos, Framework::STREAM_SEEK_DIRECTION whence) override; - virtual uint64 Tell() override; - virtual bool IsEOF() override; - virtual uint64 Read(void* dest, uint64 bytes) override; - virtual uint64 Write(const void* src, uint64 bytes) override; + virtual void Seek(int64 pos, Framework::STREAM_SEEK_DIRECTION whence) override; + virtual uint64 Tell() override; + virtual bool IsEOF() override; + virtual uint64 Read(void* dest, uint64 bytes) override; + virtual uint64 Write(const void* src, uint64 bytes) override; private: - void ReadFileHeader(); - void InitializeBuffers(); - uint64 GetTotalSize() const; - uint32 ReadFromNextFrame(uint8* dest, uint64 maxBytes); - uint64 ReadBaseAt(uint64 pos, uint8* dest, uint64 bytes); - void DecompressFrame(uint32 frame, uint64 readBufferSize); + void ReadFileHeader(); + void InitializeBuffers(); + uint64 GetTotalSize() const; + uint32 ReadFromNextFrame(uint8* dest, uint64 maxBytes); + uint64 ReadBaseAt(uint64 pos, uint8* dest, uint64 bytes); + void DecompressFrame(uint32 frame, uint64 readBufferSize); - Framework::CStream* m_baseStream; - uint32 m_frameSize; - uint8 m_frameShift; - uint8 m_indexShift; - uint8* m_readBuffer; - uint8* m_zlibBuffer; - uint32 m_zlibBufferFrame; - uint32* m_index; - uint64 m_totalSize; - uint64 m_position; + Framework::CStream* m_baseStream; + uint32 m_frameSize; + uint8 m_frameShift; + uint8 m_indexShift; + uint8* m_readBuffer; + uint8* m_zlibBuffer; + uint32 m_zlibBufferFrame; + uint32* m_index; + uint64 m_totalSize; + uint64 m_position; }; diff --git a/Source/DiskUtils.h b/Source/DiskUtils.h index e6de4d322..aabb7ec2d 100644 --- a/Source/DiskUtils.h +++ b/Source/DiskUtils.h @@ -10,8 +10,8 @@ namespace DiskUtils typedef std::unique_ptr OpticalMediaPtr; typedef std::map SystemConfigMap; - OpticalMediaPtr CreateOpticalMediaFromPath(const boost::filesystem::path&); - SystemConfigMap ParseSystemConfigFile(Framework::CStream*); + OpticalMediaPtr CreateOpticalMediaFromPath(const boost::filesystem::path&); + SystemConfigMap ParseSystemConfigFile(Framework::CStream*); - bool TryGetDiskId(const boost::filesystem::path&, std::string*); + bool TryGetDiskId(const boost::filesystem::path&, std::string*); } diff --git a/Source/ELF.cpp b/Source/ELF.cpp index 5a083624e..d6d58879c 100644 --- a/Source/ELF.cpp +++ b/Source/ELF.cpp @@ -4,13 +4,13 @@ #include "ELF.h" #include "PtrStream.h" -CELF::CELF(uint8* content) -: m_content(content) +CELF::CELF(uint8* content) + : m_content(content) { Framework::CPtrStream stream(m_content, -1); stream.Read(&m_Header, sizeof(ELFHEADER)); - + if(m_Header.nId[0] != 0x7F || m_Header.nId[1] != 'E' || m_Header.nId[2] != 'L' || m_Header.nId[3] != 'F') { throw std::runtime_error("This file isn't a valid ELF file."); @@ -46,8 +46,8 @@ CELF::CELF(uint8* content) CELF::~CELF() { - delete [] m_pProgram; - delete [] m_pSection; + delete[] m_pProgram; + delete[] m_pSection; } uint8* CELF::GetContent() const diff --git a/Source/ELF.h b/Source/ELF.h index f9b20a47f..2613851e6 100644 --- a/Source/ELF.h +++ b/Source/ELF.h @@ -7,56 +7,56 @@ struct ELFSYMBOL { - uint32 nName; - uint32 nValue; - uint32 nSize; - uint8 nInfo; - uint8 nOther; - uint16 nSectionIndex; + uint32 nName; + uint32 nValue; + uint32 nSize; + uint8 nInfo; + uint8 nOther; + uint16 nSectionIndex; }; struct ELFHEADER { - uint8 nId[16]; - uint16 nType; - uint16 nCPU; - uint32 nVersion; - uint32 nEntryPoint; - uint32 nProgHeaderStart; - uint32 nSectHeaderStart; - uint32 nFlags; - uint16 nSize; - uint16 nProgHeaderEntrySize; - uint16 nProgHeaderCount; - uint16 nSectHeaderEntrySize; - uint16 nSectHeaderCount; - uint16 nSectHeaderStringTableIndex; + uint8 nId[16]; + uint16 nType; + uint16 nCPU; + uint32 nVersion; + uint32 nEntryPoint; + uint32 nProgHeaderStart; + uint32 nSectHeaderStart; + uint32 nFlags; + uint16 nSize; + uint16 nProgHeaderEntrySize; + uint16 nProgHeaderCount; + uint16 nSectHeaderEntrySize; + uint16 nSectHeaderCount; + uint16 nSectHeaderStringTableIndex; }; struct ELFSECTIONHEADER { - uint32 nStringTableIndex; - uint32 nType; - uint32 nFlags; - uint32 nStart; - uint32 nOffset; - uint32 nSize; - uint32 nIndex; - uint32 nInfo; - uint32 nAlignment; - uint32 nOther; + uint32 nStringTableIndex; + uint32 nType; + uint32 nFlags; + uint32 nStart; + uint32 nOffset; + uint32 nSize; + uint32 nIndex; + uint32 nInfo; + uint32 nAlignment; + uint32 nOther; }; struct ELFPROGRAMHEADER { - uint32 nType; - uint32 nOffset; - uint32 nVAddress; - uint32 nPAddress; - uint32 nFileSize; - uint32 nMemorySize; - uint32 nFlags; - uint32 nAlignment; + uint32 nType; + uint32 nOffset; + uint32 nVAddress; + uint32 nPAddress; + uint32 nFileSize; + uint32 nMemorySize; + uint32 nFlags; + uint32 nAlignment; }; #pragma pack(pop) @@ -66,75 +66,75 @@ class CELF public: enum EXECUTABLE_TYPE { - ET_NONE = 0, - ET_REL = 1, - ET_EXEC = 2, - ET_DYN = 3, - ET_CORE = 4, + ET_NONE = 0, + ET_REL = 1, + ET_EXEC = 2, + ET_DYN = 3, + ET_CORE = 4, }; enum MACHINE_TYPE { - EM_NONE = 0, - EM_M32 = 1, - EM_SPARC = 2, - EM_386 = 3, - EM_68K = 4, - EM_88K = 5, - EM_860 = 7, - EM_MIPS = 8, - EM_ARM = 40, + EM_NONE = 0, + EM_M32 = 1, + EM_SPARC = 2, + EM_386 = 3, + EM_68K = 4, + EM_88K = 5, + EM_860 = 7, + EM_MIPS = 8, + EM_ARM = 40, }; enum EXECUTABLE_VERSION { - EV_NONE = 0, - EV_CURRENT = 1, + EV_NONE = 0, + EV_CURRENT = 1, }; enum SECTION_HEADER_TYPE { - SHT_NULL = 0, - SHT_PROGBITS = 1, - SHT_SYMTAB = 2, - SHT_STRTAB = 3, - SHT_HASH = 5, - SHT_DYNAMIC = 6, - SHT_NOTE = 7, - SHT_NOBITS = 8, - SHT_REL = 9, - SHT_DYNSYM = 11, + SHT_NULL = 0, + SHT_PROGBITS = 1, + SHT_SYMTAB = 2, + SHT_STRTAB = 3, + SHT_HASH = 5, + SHT_DYNAMIC = 6, + SHT_NOTE = 7, + SHT_NOBITS = 8, + SHT_REL = 9, + SHT_DYNSYM = 11, }; enum PROGRAM_HEADER_TYPE { - PT_NULL = 0, - PT_LOAD = 1, - PT_DYNAMIC = 2, - PT_INTERP = 3, - PT_NOTE = 4, - PT_SHLIB = 5, - PT_PHDR = 6, + PT_NULL = 0, + PT_LOAD = 1, + PT_DYNAMIC = 2, + PT_INTERP = 3, + PT_NOTE = 4, + PT_SHLIB = 5, + PT_PHDR = 6, }; enum PROGRAM_HEADER_FLAG { - PF_X = 0x01, - PF_W = 0x02, - PF_R = 0x04, + PF_X = 0x01, + PF_W = 0x02, + PF_R = 0x04, }; enum DYNAMIC_INFO_TYPE { - DT_NONE = 0, - DT_NEEDED = 1, - DT_PLTRELSZ = 2, - DT_PLTGOT = 3, - DT_HASH = 4, - DT_STRTAB = 5, - DT_SYMTAB = 6, - DT_SONAME = 14, - DT_SYMBOLIC = 16, + DT_NONE = 0, + DT_NEEDED = 1, + DT_PLTRELSZ = 2, + DT_PLTGOT = 3, + DT_HASH = 4, + DT_STRTAB = 5, + DT_SYMTAB = 6, + DT_SONAME = 14, + DT_SYMBOLIC = 16, }; enum MIPS_RELOCATION_TYPE @@ -146,29 +146,29 @@ public: R_MIPS_GPREL16 = 7, }; - CELF(uint8*); - CELF(const CELF&) = delete; - virtual ~CELF(); + CELF(uint8*); + CELF(const CELF&) = delete; + virtual ~CELF(); - CELF& operator =(const CELF&) = delete; + CELF& operator=(const CELF&) = delete; - uint8* GetContent() const; - const ELFHEADER& GetHeader() const; + uint8* GetContent() const; + const ELFHEADER& GetHeader() const; - ELFSECTIONHEADER* GetSection(unsigned int); - const void* GetSectionData(unsigned int); - const char* GetSectionName(unsigned int); + ELFSECTIONHEADER* GetSection(unsigned int); + const void* GetSectionData(unsigned int); + const char* GetSectionName(unsigned int); - ELFSECTIONHEADER* FindSection(const char*); - unsigned int FindSectionIndex(const char*); - const void* FindSectionData(const char*); + ELFSECTIONHEADER* FindSection(const char*); + unsigned int FindSectionIndex(const char*); + const void* FindSectionData(const char*); - ELFPROGRAMHEADER* GetProgram(unsigned int); + ELFPROGRAMHEADER* GetProgram(unsigned int); private: - ELFHEADER m_Header; - uint8* m_content = nullptr; + ELFHEADER m_Header; + uint8* m_content = nullptr; - ELFSECTIONHEADER* m_pSection = nullptr; - ELFPROGRAMHEADER* m_pProgram = nullptr; + ELFSECTIONHEADER* m_pSection = nullptr; + ELFPROGRAMHEADER* m_pProgram = nullptr; }; diff --git a/Source/ElfFile.cpp b/Source/ElfFile.cpp index f0807121e..9398d4819 100644 --- a/Source/ElfFile.cpp +++ b/Source/ElfFile.cpp @@ -1,18 +1,15 @@ #include "ElfFile.h" CElfFile::CElfFile(Framework::CStream& stream) -: CElfFileContainer(stream) -, CELF(GetFileContent()) + : CElfFileContainer(stream) + , CELF(GetFileContent()) { - } CElfFile::~CElfFile() { - } - CElfFileContainer::CElfFileContainer(Framework::CStream& input) { uint32 size = static_cast(input.GetLength()); @@ -22,7 +19,7 @@ CElfFileContainer::CElfFileContainer(Framework::CStream& input) CElfFileContainer::~CElfFileContainer() { - delete [] m_content; + delete[] m_content; } uint8* CElfFileContainer::GetFileContent() const diff --git a/Source/ElfFile.h b/Source/ElfFile.h index c0a133792..ea79ff548 100644 --- a/Source/ElfFile.h +++ b/Source/ElfFile.h @@ -6,24 +6,22 @@ class CElfFileContainer { public: - CElfFileContainer(Framework::CStream&); - virtual ~CElfFileContainer(); + CElfFileContainer(Framework::CStream&); + virtual ~CElfFileContainer(); - uint8* GetFileContent() const; + uint8* GetFileContent() const; private: - uint8* m_content; - + uint8* m_content; }; class CElfFile : protected CElfFileContainer, public CELF { public: - CElfFile(Framework::CStream&); - virtual ~CElfFile(); + CElfFile(Framework::CStream&); + virtual ~CElfFile(); private: - }; #endif diff --git a/Source/FrameDump.cpp b/Source/FrameDump.cpp index 68ae79e54..300df6ba7 100644 --- a/Source/FrameDump.cpp +++ b/Source/FrameDump.cpp @@ -2,14 +2,14 @@ #include "MemoryStateFile.h" #include "RegisterStateFile.h" -#define STATE_INITIAL_GSRAM "init/gsram" -#define STATE_INITIAL_GSREGS "init/gsregs" -#define STATE_INITIAL_GSPRIVREGS "init/gsprivregs" -#define STATE_PACKET_METADATA_PREFIX "packet_metadata_" +#define STATE_INITIAL_GSRAM "init/gsram" +#define STATE_INITIAL_GSREGS "init/gsregs" +#define STATE_INITIAL_GSPRIVREGS "init/gsprivregs" +#define STATE_PACKET_METADATA_PREFIX "packet_metadata_" #define STATE_PACKET_REGISTERWRITES_PREFIX "packet_registerwrites_" -#define STATE_PACKET_IMAGEDATA_PREFIX "packet_imagedata_" +#define STATE_PACKET_IMAGEDATA_PREFIX "packet_imagedata_" -#define STATE_PRIVREG_SMODE2 "SMODE2" +#define STATE_PRIVREG_SMODE2 "SMODE2" CFrameDump::CFrameDump() { @@ -19,7 +19,7 @@ CFrameDump::CFrameDump() CFrameDump::~CFrameDump() { - delete [] m_initialGsRam; + delete[] m_initialGsRam; } void CFrameDump::Reset() @@ -78,7 +78,7 @@ void CFrameDump::Read(Framework::CStream& input) Reset(); Framework::CZipArchiveReader archive(input); - + archive.BeginReadFile(STATE_INITIAL_GSRAM)->Read(m_initialGsRam, CGSHandler::RAMSIZE); archive.BeginReadFile(STATE_INITIAL_GSREGS)->Read(m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX); @@ -135,8 +135,8 @@ void CFrameDump::Write(Framework::CStream& output) const { Framework::CZipArchiveWriter archive; - archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX)); + archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSRAM, m_initialGsRam, CGSHandler::RAMSIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_INITIAL_GSREGS, m_initialGsRegisters, sizeof(uint64) * CGSHandler::REGISTER_MAX)); { auto privRegsStateFile = new CRegisterStateFile(STATE_INITIAL_GSPRIVREGS); @@ -171,8 +171,8 @@ void CFrameDump::IdentifyDrawingKicks() DRAWINGKICK_INFO drawingKickInfo; - static const unsigned int g_initVertexCounts[8] = { 1, 2, 2, 3, 3, 3, 2, 0 }; - static const unsigned int g_nextVertexCounts[8] = { 1, 2, 1, 3, 1, 1, 2, 0 }; + static const unsigned int g_initVertexCounts[8] = {1, 2, 2, 3, 3, 3, 2, 0}; + static const unsigned int g_nextVertexCounts[8] = {1, 2, 1, 3, 1, 1, 2, 0}; CGSHandler::PRIM currentPrim; currentPrim <<= GetInitialGsRegisters()[GS_REG_PRIM]; @@ -194,16 +194,16 @@ void CFrameDump::IdentifyDrawingKicks() vertexCount = g_initVertexCounts[currentPrim.nType]; } else if( - (registerWrite.first == GS_REG_XYOFFSET_1) || - (registerWrite.first == GS_REG_XYOFFSET_2)) + (registerWrite.first == GS_REG_XYOFFSET_1) || + (registerWrite.first == GS_REG_XYOFFSET_2)) { currentOfs[registerWrite.first - GS_REG_XYOFFSET_1] <<= registerWrite.second; } else if( - (registerWrite.first == GS_REG_XYZ2) || - (registerWrite.first == GS_REG_XYZ3) || - (registerWrite.first == GS_REG_XYZF2) || - (registerWrite.first == GS_REG_XYZF3)) + (registerWrite.first == GS_REG_XYZ2) || + (registerWrite.first == GS_REG_XYZ3) || + (registerWrite.first == GS_REG_XYZF2) || + (registerWrite.first == GS_REG_XYZF3)) { if(vertexCount != 0) { @@ -213,7 +213,7 @@ void CFrameDump::IdentifyDrawingKicks() drawingKickInfo.primType = currentPrim.nType; drawingKickInfo.context = currentPrim.nContext; - drawingKickInfo.vertex[vertexCount].x = ((registerWrite.second >> 0) & 0xFFFF) - offset.nOffsetX; + drawingKickInfo.vertex[vertexCount].x = ((registerWrite.second >> 0) & 0xFFFF) - offset.nOffsetX; drawingKickInfo.vertex[vertexCount].y = ((registerWrite.second >> 16) & 0xFFFF) - offset.nOffsetY; if(vertexCount == 0) diff --git a/Source/FrameDump.h b/Source/FrameDump.h index 6982920da..101abf0ef 100644 --- a/Source/FrameDump.h +++ b/Source/FrameDump.h @@ -10,7 +10,7 @@ class CGsPacketMetadata { public: explicit CGsPacketMetadata(unsigned int pathIndex = 0) - : pathIndex(pathIndex) + : pathIndex(pathIndex) { #ifdef DEBUGGER_INCLUDED memset(&vu1State, 0, sizeof(vu1State)); @@ -19,14 +19,14 @@ public: #endif } - unsigned int pathIndex = 0; + unsigned int pathIndex = 0; #ifdef DEBUGGER_INCLUDED - MIPSSTATE vu1State; - uint8 microMem1[PS2::MICROMEM1SIZE]; - uint8 vuMem1[PS2::VUMEM1SIZE]; - uint32 vpu1Top = 0; - uint32 vpu1Itop = 0; - uint32 vuMemPacketAddress = 0; + MIPSSTATE vu1State; + uint8 microMem1[PS2::MICROMEM1SIZE]; + uint8 vuMem1[PS2::VUMEM1SIZE]; + uint32 vpu1Top = 0; + uint32 vpu1Itop = 0; + uint32 vuMemPacketAddress = 0; #endif }; @@ -36,9 +36,9 @@ public: typedef std::vector RegisterWriteArray; typedef std::vector ImageDataArray; - CGsPacketMetadata metadata; - RegisterWriteArray registerWrites; - ImageDataArray imageData; + CGsPacketMetadata metadata; + RegisterWriteArray registerWrites; + ImageDataArray imageData; }; struct DRAWINGKICK_INFO @@ -49,9 +49,9 @@ struct DRAWINGKICK_INFO uint16 y = 0; }; - unsigned int context = 0; - unsigned int primType = CGSHandler::PRIM_INVALID; - VERTEX vertex[3]; + unsigned int context = 0; + unsigned int primType = CGSHandler::PRIM_INVALID; + VERTEX vertex[3]; }; typedef std::map DrawingKickInfoMap; @@ -61,31 +61,31 @@ class CFrameDump public: typedef std::vector PacketArray; - CFrameDump(); - virtual ~CFrameDump(); + CFrameDump(); + virtual ~CFrameDump(); - void Reset(); + void Reset(); - uint8* GetInitialGsRam(); - uint64* GetInitialGsRegisters(); + uint8* GetInitialGsRam(); + uint64* GetInitialGsRegisters(); - uint64 GetInitialSMODE2() const; - void SetInitialSMODE2(uint64); + uint64 GetInitialSMODE2() const; + void SetInitialSMODE2(uint64); - const PacketArray& GetPackets() const; - void AddRegisterPacket(const CGSHandler::RegisterWrite*, uint32, const CGsPacketMetadata*); - void AddImagePacket(const uint8*, uint32); + const PacketArray& GetPackets() const; + void AddRegisterPacket(const CGSHandler::RegisterWrite*, uint32, const CGsPacketMetadata*); + void AddImagePacket(const uint8*, uint32); - void Read(Framework::CStream&); - void Write(Framework::CStream&) const; + void Read(Framework::CStream&); + void Write(Framework::CStream&) const; - void IdentifyDrawingKicks(); - const DrawingKickInfoMap& GetDrawingKicks() const; + void IdentifyDrawingKicks(); + const DrawingKickInfoMap& GetDrawingKicks() const; private: - uint8* m_initialGsRam = nullptr; - uint64 m_initialGsRegisters[CGSHandler::REGISTER_MAX]; - uint64 m_initialSMODE2 = 0; - PacketArray m_packets; - DrawingKickInfoMap m_drawingKicks; + uint8* m_initialGsRam = nullptr; + uint64 m_initialGsRegisters[CGSHandler::REGISTER_MAX]; + uint64 m_initialSMODE2 = 0; + PacketArray m_packets; + DrawingKickInfoMap m_drawingKicks; }; diff --git a/Source/FutureContinuationManager.h b/Source/FutureContinuationManager.h index 9e790aad7..cb29ae5af 100644 --- a/Source/FutureContinuationManager.h +++ b/Source/FutureContinuationManager.h @@ -17,8 +17,8 @@ public: void Execute() { - auto newEnd = std::remove_if(m_futures.begin(), m_futures.end(), - [] (const FuturePtr& future) { return future->IsDone(); } ); + auto newEnd = std::remove_if(m_futures.begin(), m_futures.end(), + [](const FuturePtr& future) { return future->IsDone(); }); m_futures.erase(newEnd, m_futures.end()); } @@ -31,16 +31,16 @@ private: }; typedef std::unique_ptr FuturePtr; - template + template class CFutureWrapper : public CFuture { public: - typedef std::function CallbackType; + typedef std::function CallbackType; CFutureWrapper(std::future future, CallbackType callback) - : m_future(std::move(future)), m_callback(std::move(callback)) + : m_future(std::move(future)) + , m_callback(std::move(callback)) { - } bool IsDone() override diff --git a/Source/ISO9660/BlockProvider.h b/Source/ISO9660/BlockProvider.h index aa31806e8..098b51e50 100644 --- a/Source/ISO9660/BlockProvider.h +++ b/Source/ISO9660/BlockProvider.h @@ -14,8 +14,8 @@ namespace ISO9660 BLOCKSIZE = 0x800ULL }; - virtual ~CBlockProvider() {}; - virtual void ReadBlock(uint32, void*) = 0; + virtual ~CBlockProvider(){}; + virtual void ReadBlock(uint32, void*) = 0; }; class CBlockProvider2048 : public CBlockProvider @@ -24,14 +24,12 @@ namespace ISO9660 typedef std::shared_ptr StreamPtr; CBlockProvider2048(const StreamPtr& stream) - : m_stream(stream) + : m_stream(stream) { - } virtual ~CBlockProvider2048() { - } void ReadBlock(uint32 address, void* block) override @@ -50,14 +48,12 @@ namespace ISO9660 typedef std::shared_ptr StreamPtr; CBlockProviderCDROMXA(const StreamPtr& stream) - : m_stream(stream) + : m_stream(stream) { - } virtual ~CBlockProviderCDROMXA() { - } void ReadBlock(uint32 address, void* block) override diff --git a/Source/ISO9660/DirectoryRecord.cpp b/Source/ISO9660/DirectoryRecord.cpp index 420a68233..22faacc48 100644 --- a/Source/ISO9660/DirectoryRecord.cpp +++ b/Source/ISO9660/DirectoryRecord.cpp @@ -32,7 +32,6 @@ CDirectoryRecord::CDirectoryRecord(Framework::CStream* stream) CDirectoryRecord::~CDirectoryRecord() { - } uint8 CDirectoryRecord::GetLength() const diff --git a/Source/ISO9660/DirectoryRecord.h b/Source/ISO9660/DirectoryRecord.h index ca98089fe..768538f4d 100644 --- a/Source/ISO9660/DirectoryRecord.h +++ b/Source/ISO9660/DirectoryRecord.h @@ -8,22 +8,22 @@ namespace ISO9660 class CDirectoryRecord { public: - CDirectoryRecord(); - CDirectoryRecord(Framework::CStream*); - ~CDirectoryRecord(); + CDirectoryRecord(); + CDirectoryRecord(Framework::CStream*); + ~CDirectoryRecord(); - bool IsDirectory() const; - uint8 GetLength() const; - const char* GetName() const; - uint32 GetPosition() const; - uint32 GetDataLength() const; + bool IsDirectory() const; + uint8 GetLength() const; + const char* GetName() const; + uint32 GetPosition() const; + uint32 GetDataLength() const; private: - uint8 m_length = 0; - uint8 m_exLength = 0; - uint32 m_position = 0; - uint32 m_dataLength = 0; - uint8 m_flags = 0; - char m_name[256]; + uint8 m_length = 0; + uint8 m_exLength = 0; + uint32 m_position = 0; + uint32 m_dataLength = 0; + uint8 m_flags = 0; + char m_name[256]; }; } diff --git a/Source/ISO9660/File.cpp b/Source/ISO9660/File.cpp index efa55d0d9..2f0c9ce71 100644 --- a/Source/ISO9660/File.cpp +++ b/Source/ISO9660/File.cpp @@ -7,24 +7,23 @@ using namespace ISO9660; CFile::CFile(CBlockProvider* blockProvider, uint64 start) -: m_blockProvider(blockProvider) -, m_start(start) -, m_end(ULLONG_MAX) + : m_blockProvider(blockProvider) + , m_start(start) + , m_end(ULLONG_MAX) { InitBlock(); } CFile::CFile(CBlockProvider* blockProvider, uint64 start, uint64 size) -: m_blockProvider(blockProvider) -, m_start(start) -, m_end(start + size) + : m_blockProvider(blockProvider) + , m_start(start) + , m_end(start + size) { InitBlock(); } CFile::~CFile() { - } void CFile::Seek(int64 amount, Framework::STREAM_SEEK_DIRECTION whence) @@ -65,9 +64,9 @@ uint64 CFile::Read(void* data, uint64 length) while(1) { SyncBlock(); - uint64 blockPosition = (m_start + m_position) % CBlockProvider::BLOCKSIZE; - uint64 blockRemain = CBlockProvider::BLOCKSIZE - blockPosition; - uint64 toRead = (length > blockRemain) ? (blockRemain) : (length); + uint64 blockPosition = (m_start + m_position) % CBlockProvider::BLOCKSIZE; + uint64 blockRemain = CBlockProvider::BLOCKSIZE - blockPosition; + uint64 toRead = (length > blockRemain) ? (blockRemain) : (length); memcpy(data, m_block + blockPosition, static_cast(toRead)); diff --git a/Source/ISO9660/File.h b/Source/ISO9660/File.h index e785630dc..e7bf4dcb3 100644 --- a/Source/ISO9660/File.h +++ b/Source/ISO9660/File.h @@ -8,26 +8,25 @@ namespace ISO9660 class CFile : public Framework::CStream { public: - CFile(CBlockProvider*, uint64); - CFile(CBlockProvider*, uint64, uint64); - ~CFile(); - void Seek(int64, Framework::STREAM_SEEK_DIRECTION) override; - uint64 Tell() override; - uint64 Read(void*, uint64) override; - uint64 Write(const void*, uint64) override; - bool IsEOF() override; + CFile(CBlockProvider*, uint64); + CFile(CBlockProvider*, uint64, uint64); + ~CFile(); + void Seek(int64, Framework::STREAM_SEEK_DIRECTION) override; + uint64 Tell() override; + uint64 Read(void*, uint64) override; + uint64 Write(const void*, uint64) override; + bool IsEOF() override; private: - void InitBlock(); - void SyncBlock(); + void InitBlock(); + void SyncBlock(); - CBlockProvider* m_blockProvider = nullptr; - uint64 m_start = 0; - uint64 m_end = 0; - uint64 m_position = 0; - uint32 m_blockPosition = 0; - uint8 m_block[CBlockProvider::BLOCKSIZE]; - bool m_isEof = false; + CBlockProvider* m_blockProvider = nullptr; + uint64 m_start = 0; + uint64 m_end = 0; + uint64 m_position = 0; + uint32 m_blockPosition = 0; + uint8 m_block[CBlockProvider::BLOCKSIZE]; + bool m_isEof = false; }; - } diff --git a/Source/ISO9660/ISO9660.cpp b/Source/ISO9660/ISO9660.cpp index 537dc7c69..c62a5071e 100644 --- a/Source/ISO9660/ISO9660.cpp +++ b/Source/ISO9660/ISO9660.cpp @@ -9,16 +9,14 @@ using namespace ISO9660; CISO9660::CISO9660(const BlockProviderPtr& blockProvider) -: m_blockProvider(blockProvider) -, m_volumeDescriptor(blockProvider.get()) -, m_pathTable(blockProvider.get(), m_volumeDescriptor.GetLPathTableAddress()) + : m_blockProvider(blockProvider) + , m_volumeDescriptor(blockProvider.get()) + , m_pathTable(blockProvider.get(), m_volumeDescriptor.GetLPathTableAddress()) { - } CISO9660::~CISO9660() { - } void CISO9660::ReadBlock(uint32 address, void* data) diff --git a/Source/ISO9660/ISO9660.h b/Source/ISO9660/ISO9660.h index 46ff3b160..4c5446791 100644 --- a/Source/ISO9660/ISO9660.h +++ b/Source/ISO9660/ISO9660.h @@ -11,20 +11,20 @@ class CISO9660 public: typedef std::shared_ptr BlockProviderPtr; - CISO9660(const BlockProviderPtr&); - ~CISO9660(); + CISO9660(const BlockProviderPtr&); + ~CISO9660(); - void ReadBlock(uint32, void*); + void ReadBlock(uint32, void*); - Framework::CStream* Open(const char*); - bool GetFileRecord(ISO9660::CDirectoryRecord*, const char*); + Framework::CStream* Open(const char*); + bool GetFileRecord(ISO9660::CDirectoryRecord*, const char*); private: - bool GetFileRecordFromDirectory(ISO9660::CDirectoryRecord*, uint32, const char*); + bool GetFileRecordFromDirectory(ISO9660::CDirectoryRecord*, uint32, const char*); - BlockProviderPtr m_blockProvider; - ISO9660::CVolumeDescriptor m_volumeDescriptor; - ISO9660::CPathTable m_pathTable; + BlockProviderPtr m_blockProvider; + ISO9660::CVolumeDescriptor m_volumeDescriptor; + ISO9660::CPathTable m_pathTable; - uint8 m_blockBuffer[ISO9660::CBlockProvider::BLOCKSIZE]; + uint8 m_blockBuffer[ISO9660::CBlockProvider::BLOCKSIZE]; }; diff --git a/Source/ISO9660/PathTable.cpp b/Source/ISO9660/PathTable.cpp index 66c753f33..783e257b4 100644 --- a/Source/ISO9660/PathTable.cpp +++ b/Source/ISO9660/PathTable.cpp @@ -21,7 +21,6 @@ CPathTable::CPathTable(CBlockProvider* blockProvider, uint32 tableLba) CPathTable::~CPathTable() { - } uint32 CPathTable::GetDirectoryAddress(unsigned int recordIndex) const diff --git a/Source/ISO9660/PathTable.h b/Source/ISO9660/PathTable.h index cedecfb3b..033423192 100644 --- a/Source/ISO9660/PathTable.h +++ b/Source/ISO9660/PathTable.h @@ -11,17 +11,16 @@ namespace ISO9660 class CPathTable { public: - CPathTable(CBlockProvider*, uint32); - ~CPathTable(); + CPathTable(CBlockProvider*, uint32); + ~CPathTable(); - unsigned int FindRoot() const; - unsigned int FindDirectory(const char*, unsigned int) const; - uint32 GetDirectoryAddress(unsigned int) const; + unsigned int FindRoot() const; + unsigned int FindDirectory(const char*, unsigned int) const; + uint32 GetDirectoryAddress(unsigned int) const; private: typedef std::map RecordMapType; - RecordMapType m_records; + RecordMapType m_records; }; - } diff --git a/Source/ISO9660/PathTableRecord.cpp b/Source/ISO9660/PathTableRecord.cpp index 1561123d1..518d38f74 100644 --- a/Source/ISO9660/PathTableRecord.cpp +++ b/Source/ISO9660/PathTableRecord.cpp @@ -19,7 +19,6 @@ CPathTableRecord::CPathTableRecord(Framework::CStream& stream) CPathTableRecord::~CPathTableRecord() { - } uint8 CPathTableRecord::GetNameLength() const diff --git a/Source/ISO9660/PathTableRecord.h b/Source/ISO9660/PathTableRecord.h index df2c798f2..06549f2d1 100644 --- a/Source/ISO9660/PathTableRecord.h +++ b/Source/ISO9660/PathTableRecord.h @@ -9,19 +9,19 @@ namespace ISO9660 class CPathTableRecord { public: - CPathTableRecord(Framework::CStream&); - ~CPathTableRecord(); + CPathTableRecord(Framework::CStream&); + ~CPathTableRecord(); - uint8 GetNameLength() const; - uint32 GetAddress() const; - uint32 GetParentRecord() const; - const char* GetName() const; + uint8 GetNameLength() const; + uint32 GetAddress() const; + uint32 GetParentRecord() const; + const char* GetName() const; private: - uint8 m_nameLength = 0; - uint8 m_exLength = 0; - uint32 m_location = 0; - uint16 m_parentDir = 0; - std::string m_directory; + uint8 m_nameLength = 0; + uint8 m_exLength = 0; + uint32 m_location = 0; + uint16 m_parentDir = 0; + std::string m_directory; }; } diff --git a/Source/ISO9660/VolumeDescriptor.cpp b/Source/ISO9660/VolumeDescriptor.cpp index bb8aab11d..e2350bf65 100644 --- a/Source/ISO9660/VolumeDescriptor.cpp +++ b/Source/ISO9660/VolumeDescriptor.cpp @@ -10,7 +10,7 @@ using namespace ISO9660; CVolumeDescriptor::CVolumeDescriptor(CBlockProvider* blockProvider) { CFile stream(blockProvider, VOLUME_DESCRIPTOR_LBA * CBlockProvider::BLOCKSIZE); - + stream.Read(&m_type, 1); if(m_type != 0x01) @@ -39,7 +39,6 @@ CVolumeDescriptor::CVolumeDescriptor(CBlockProvider* blockProvider) CVolumeDescriptor::~CVolumeDescriptor() { - } uint32 CVolumeDescriptor::GetLPathTableAddress() const diff --git a/Source/ISO9660/VolumeDescriptor.h b/Source/ISO9660/VolumeDescriptor.h index 803dabbbe..a86b68fd4 100644 --- a/Source/ISO9660/VolumeDescriptor.h +++ b/Source/ISO9660/VolumeDescriptor.h @@ -8,18 +8,17 @@ namespace ISO9660 class CVolumeDescriptor { public: - CVolumeDescriptor(CBlockProvider*); - ~CVolumeDescriptor(); + CVolumeDescriptor(CBlockProvider*); + ~CVolumeDescriptor(); - uint32 GetLPathTableAddress() const; - uint32 GetMPathTableAddress() const; + uint32 GetLPathTableAddress() const; + uint32 GetMPathTableAddress() const; private: - uint8 m_type = 0; - char m_stdId[6]; - char m_volumeId[33]; - uint32 m_LPathTableAddress = 0; - uint32 m_MPathTableAddress = 0; + uint8 m_type = 0; + char m_stdId[6]; + char m_volumeId[33]; + uint32 m_LPathTableAddress = 0; + uint32 m_MPathTableAddress = 0; }; - } diff --git a/Source/Integer64.h b/Source/Integer64.h index 3ed14a2cb..b51fc2039 100644 --- a/Source/Integer64.h +++ b/Source/Integer64.h @@ -5,8 +5,7 @@ struct INTEGER64 { - union - { + union { uint64 q; struct { diff --git a/Source/IszImageStream.cpp b/Source/IszImageStream.cpp index 3d408ecae..bda61d404 100644 --- a/Source/IszImageStream.cpp +++ b/Source/IszImageStream.cpp @@ -8,7 +8,7 @@ #include "StdStream.h" CIszImageStream::CIszImageStream(CStream* baseStream) -: m_baseStream(baseStream) + : m_baseStream(baseStream) { if(baseStream == nullptr) { @@ -36,9 +36,9 @@ CIszImageStream::CIszImageStream(CStream* baseStream) CIszImageStream::~CIszImageStream() { - delete [] m_cachedBlock; - delete [] m_readBuffer; - delete [] m_blockDescriptorTable; + delete[] m_cachedBlock; + delete[] m_readBuffer; + delete[] m_blockDescriptorTable; delete m_baseStream; } @@ -117,7 +117,7 @@ void CIszImageStream::ReadBlockDescriptorTable() m_blockDescriptorTable[i].storageType = static_cast(value >> 22); } - delete [] cryptedTable; + delete[] cryptedTable; } uint64 CIszImageStream::GetTotalSize() const @@ -199,8 +199,8 @@ void CIszImageStream::ReadGzipBlock(uint32 compressedBlockSize) m_baseStream->Read(m_readBuffer, compressedBlockSize); uLongf destLength = m_header.blockSize; if(uncompress( - reinterpret_cast(m_cachedBlock), &destLength, - reinterpret_cast(m_readBuffer), compressedBlockSize) != Z_OK) + reinterpret_cast(m_cachedBlock), &destLength, + reinterpret_cast(m_readBuffer), compressedBlockSize) != Z_OK) { throw std::runtime_error("Error decompressing zlib block."); } @@ -215,8 +215,8 @@ void CIszImageStream::ReadBz2Block(uint32 compressedBlockSize) m_readBuffer[2] = 'h'; unsigned int destLength = m_header.blockSize; if(BZ2_bzBuffToBuffDecompress( - reinterpret_cast(m_cachedBlock), &destLength, - reinterpret_cast(m_readBuffer), compressedBlockSize, 0, 0) != BZ_OK) + reinterpret_cast(m_cachedBlock), &destLength, + reinterpret_cast(m_readBuffer), compressedBlockSize, 0, 0) != BZ_OK) { throw std::runtime_error("Error decompressing bz2 block."); } diff --git a/Source/IszImageStream.h b/Source/IszImageStream.h index 98cbbbde1..05711a0aa 100644 --- a/Source/IszImageStream.h +++ b/Source/IszImageStream.h @@ -6,49 +6,49 @@ class CIszImageStream : public Framework::CStream { public: - CIszImageStream(Framework::CStream*); - virtual ~CIszImageStream(); + CIszImageStream(Framework::CStream*); + virtual ~CIszImageStream(); - virtual void Seek(int64, Framework::STREAM_SEEK_DIRECTION) override; - virtual uint64 Tell() override; - virtual uint64 Read(void*, uint64) override; - virtual uint64 Write(const void*, uint64) override; - virtual bool IsEOF() override; + virtual void Seek(int64, Framework::STREAM_SEEK_DIRECTION) override; + virtual uint64 Tell() override; + virtual uint64 Read(void*, uint64) override; + virtual uint64 Write(const void*, uint64) override; + virtual bool IsEOF() override; private: #pragma pack(push, 1) struct HEADER { - char signature[4]; - uint8 headerSize; - int8 version; - uint32 volumeSerialNumber; + char signature[4]; + uint8 headerSize; + int8 version; + uint32 volumeSerialNumber; - uint16 sectorSize; - uint32 totalSectors; + uint16 sectorSize; + uint32 totalSectors; - int8 hasPassword; + int8 hasPassword; - int64 segmentSize; + int64 segmentSize; - uint32 blockNumber; - uint32 blockSize; - uint8 blockPtrLength; + uint32 blockNumber; + uint32 blockSize; + uint8 blockPtrLength; - int8 segmentNumber; + int8 segmentNumber; - uint32 blockPtrOffset; - uint32 segmentPtrOffset; - uint32 dataOffset; + uint32 blockPtrOffset; + uint32 segmentPtrOffset; + uint32 dataOffset; - int8 reserved; + int8 reserved; }; #pragma pack(pop) struct BLOCKDESCRIPTOR { - uint32 size; - uint8 storageType; + uint32 size; + uint8 storageType; }; enum HASPASSWORD @@ -68,21 +68,21 @@ private: ADI_BZ2 = 3 }; - void ReadBlockDescriptorTable(); - uint64 GetTotalSize() const; - const BLOCKDESCRIPTOR& SeekToBlock(uint64); - void SyncCache(); + void ReadBlockDescriptorTable(); + uint64 GetTotalSize() const; + const BLOCKDESCRIPTOR& SeekToBlock(uint64); + void SyncCache(); - void ReadZeroBlock(uint32); - void ReadDataBlock(uint32); - void ReadGzipBlock(uint32); - void ReadBz2Block(uint32); + void ReadZeroBlock(uint32); + void ReadDataBlock(uint32); + void ReadGzipBlock(uint32); + void ReadBz2Block(uint32); - Framework::CStream* m_baseStream = nullptr; - HEADER m_header; - BLOCKDESCRIPTOR* m_blockDescriptorTable = nullptr; - int64 m_cachedBlockNumber = -1; - uint8* m_cachedBlock = nullptr; - uint8* m_readBuffer = nullptr; - uint64 m_position = 0; + Framework::CStream* m_baseStream = nullptr; + HEADER m_header; + BLOCKDESCRIPTOR* m_blockDescriptorTable = nullptr; + int64 m_cachedBlockNumber = -1; + uint8* m_cachedBlock = nullptr; + uint8* m_readBuffer = nullptr; + uint64 m_position = 0; }; diff --git a/Source/Log.cpp b/Source/Log.cpp index 199abc416..cd09beed0 100644 --- a/Source/Log.cpp +++ b/Source/Log.cpp @@ -17,7 +17,6 @@ CLog::CLog() CLog::~CLog() { - } void CLog::Print(const char* logName, const char* format, ...) diff --git a/Source/Log.h b/Source/Log.h index 556ffdda1..456960c5c 100644 --- a/Source/Log.h +++ b/Source/Log.h @@ -10,18 +10,18 @@ class CLog : public CSingleton { public: - CLog(); - virtual ~CLog(); + CLog(); + virtual ~CLog(); - void Print(const char*, const char*, ...); + void Print(const char*, const char*, ...); private: typedef std::map LogMapType; - Framework::CStdStream& GetLog(const char*); + Framework::CStdStream& GetLog(const char*); - boost::filesystem::path m_logBasePath; - LogMapType m_logs; + boost::filesystem::path m_logBasePath; + LogMapType m_logs; }; #endif diff --git a/Source/MA_MIPSIV.cpp b/Source/MA_MIPSIV.cpp index 2cc8d9cfe..450c36357 100644 --- a/Source/MA_MIPSIV.cpp +++ b/Source/MA_MIPSIV.cpp @@ -8,43 +8,43 @@ #include "placeholder_def.h" uint32 g_LWMaskRight[4] = -{ - 0x00FFFFFF, - 0x0000FFFF, - 0x000000FF, - 0x00000000, + { + 0x00FFFFFF, + 0x0000FFFF, + 0x000000FF, + 0x00000000, }; uint32 g_LWMaskLeft[4] = -{ - 0xFFFFFF00, - 0xFFFF0000, - 0xFF000000, - 0x00000000, + { + 0xFFFFFF00, + 0xFFFF0000, + 0xFF000000, + 0x00000000, }; uint64 g_LDMaskRight[8] = -{ - 0x00FFFFFFFFFFFFFFULL, - 0x0000FFFFFFFFFFFFULL, - 0x000000FFFFFFFFFFULL, - 0x00000000FFFFFFFFULL, - 0x0000000000FFFFFFULL, - 0x000000000000FFFFULL, - 0x00000000000000FFULL, - 0x0000000000000000ULL, + { + 0x00FFFFFFFFFFFFFFULL, + 0x0000FFFFFFFFFFFFULL, + 0x000000FFFFFFFFFFULL, + 0x00000000FFFFFFFFULL, + 0x0000000000FFFFFFULL, + 0x000000000000FFFFULL, + 0x00000000000000FFULL, + 0x0000000000000000ULL, }; uint64 g_LDMaskLeft[8] = -{ - 0xFFFFFFFFFFFFFF00ULL, - 0xFFFFFFFFFFFF0000ULL, - 0xFFFFFFFFFF000000ULL, - 0xFFFFFFFF00000000ULL, - 0xFFFFFF0000000000ULL, - 0xFFFF000000000000ULL, - 0xFF00000000000000ULL, - 0x0000000000000000ULL, + { + 0xFFFFFFFFFFFFFF00ULL, + 0xFFFFFFFFFFFF0000ULL, + 0xFFFFFFFFFF000000ULL, + 0xFFFFFFFF00000000ULL, + 0xFFFFFF0000000000ULL, + 0xFFFF000000000000ULL, + 0xFF00000000000000ULL, + 0x0000000000000000ULL, }; extern "C" uint32 LWL_Proxy(uint32 address, uint32 rt, CMIPS* context) @@ -143,8 +143,8 @@ extern "C" void SDR_Proxy(uint32 address, uint64 rt, CMIPS* context) MemoryUtils_SetDoubleProxy(context, memory, alignedAddress); } -CMA_MIPSIV::CMA_MIPSIV(MIPS_REGSIZE nRegSize) : -CMIPSArchitecture(nRegSize) +CMA_MIPSIV::CMA_MIPSIV(MIPS_REGSIZE nRegSize) + : CMIPSArchitecture(nRegSize) { SetupInstructionTables(); SetupReflectionTables(); @@ -152,7 +152,6 @@ CMIPSArchitecture(nRegSize) CMA_MIPSIV::~CMA_MIPSIV() { - } void CMA_MIPSIV::SetupInstructionTables() @@ -182,11 +181,11 @@ void CMA_MIPSIV::CompileInstruction(uint32 nAddress, CMipsJitter* codeGen, CMIPS { SetupQuickVariables(nAddress, codeGen, pCtx); - m_nRS = (uint8)((m_nOpcode >> 21) & 0x1F); - m_nRT = (uint8)((m_nOpcode >> 16) & 0x1F); - m_nRD = (uint8)((m_nOpcode >> 11) & 0x1F); - m_nSA = (uint8)((m_nOpcode >> 6) & 0x1F); - m_nImmediate = (uint16)(m_nOpcode & 0xFFFF); + m_nRS = (uint8)((m_nOpcode >> 21) & 0x1F); + m_nRT = (uint8)((m_nOpcode >> 16) & 0x1F); + m_nRD = (uint8)((m_nOpcode >> 11) & 0x1F); + m_nSA = (uint8)((m_nOpcode >> 6) & 0x1F); + m_nImmediate = (uint16)(m_nOpcode & 0xFFFF); if(m_nOpcode) { @@ -278,7 +277,7 @@ void CMA_MIPSIV::ADDI() //09 void CMA_MIPSIV::ADDIU() { - if(m_nRT == 0 && m_nRS == 0) + if(m_nRT == 0 && m_nRS == 0) { //Hack: PS2 IOP uses ADDIU R0, R0, $x for dynamic linking m_codeGen->PushCst(m_nAddress); @@ -323,7 +322,7 @@ void CMA_MIPSIV::ANDI() m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[0])); m_codeGen->PushCst(m_nImmediate); - + m_codeGen->And(); m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[0])); @@ -805,14 +804,14 @@ void CMA_MIPSIV::SLL() //02 void CMA_MIPSIV::SRL() { - void (Jitter::CJitter::*shiftFunction)(uint8) = &Jitter::CJitter::Srl; + void (Jitter::CJitter::*shiftFunction)(uint8) = &Jitter::CJitter::Srl; Template_ShiftCst32(std::bind(shiftFunction, m_codeGen, std::placeholders::_1)); } //03 void CMA_MIPSIV::SRA() { - void (Jitter::CJitter::*shiftFunction)(uint8) = &Jitter::CJitter::Sra; + void (Jitter::CJitter::*shiftFunction)(uint8) = &Jitter::CJitter::Sra; Template_ShiftCst32(std::bind(shiftFunction, m_codeGen, std::placeholders::_1)); } @@ -826,7 +825,7 @@ void CMA_MIPSIV::SLLV() //06 void CMA_MIPSIV::SRLV() { - void (Jitter::CJitter::*shiftFunction)() = &Jitter::CJitter::Srl; + void (Jitter::CJitter::*shiftFunction)() = &Jitter::CJitter::Srl; Template_ShiftVar32(std::bind(shiftFunction, m_codeGen)); } diff --git a/Source/MA_MIPSIV.h b/Source/MA_MIPSIV.h index cbf9e5240..6f309af18 100644 --- a/Source/MA_MIPSIV.h +++ b/Source/MA_MIPSIV.h @@ -7,13 +7,13 @@ class CMA_MIPSIV : public CMIPSArchitecture { public: - CMA_MIPSIV(MIPS_REGSIZE); - virtual ~CMA_MIPSIV(); - virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*); - virtual void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); - virtual void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); - virtual MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); - virtual uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); + CMA_MIPSIV(MIPS_REGSIZE); + virtual ~CMA_MIPSIV(); + virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*); + virtual void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); + virtual void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); + virtual MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); + virtual uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); protected: enum @@ -24,55 +24,55 @@ protected: MAX_REGIMM_OPS = 0x20, }; - typedef std::function InstructionFunction; + typedef std::function InstructionFunction; - InstructionFunction m_pOpGeneral[MAX_GENERAL_OPS]; - InstructionFunction m_pOpSpecial[MAX_SPECIAL_OPS]; - InstructionFunction m_pOpSpecial2[MAX_SPECIAL2_OPS]; - InstructionFunction m_pOpRegImm[MAX_REGIMM_OPS]; + InstructionFunction m_pOpGeneral[MAX_GENERAL_OPS]; + InstructionFunction m_pOpSpecial[MAX_SPECIAL_OPS]; + InstructionFunction m_pOpSpecial2[MAX_SPECIAL2_OPS]; + InstructionFunction m_pOpRegImm[MAX_REGIMM_OPS]; - static void ReflOpTarget(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtRsImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRsRtOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRsOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpHintOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpIdOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRdRsRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRdRtSa(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRdRtRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRdRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRsRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpTarget(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtRsImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRsRtOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRsOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpHintOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpIdOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRdRsRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRdRtSa(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRdRtRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRdRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRsRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static uint32 ReflEaTarget(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaTarget(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - static void ReflCOPMnemonic(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); - static void ReflCOPOperands(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static MIPS_BRANCH_TYPE ReflCOPIsBranch(MIPSReflection::INSTRUCTION*, CMIPS*, uint32); - static uint32 ReflCOPEffeAddr(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static void ReflCOPMnemonic(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); + static void ReflCOPOperands(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static MIPS_BRANCH_TYPE ReflCOPIsBranch(MIPSReflection::INSTRUCTION*, CMIPS*, uint32); + static uint32 ReflCOPEffeAddr(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - MIPSReflection::INSTRUCTION m_ReflGeneral[MAX_GENERAL_OPS]; - MIPSReflection::INSTRUCTION m_ReflSpecial[MAX_SPECIAL_OPS]; - MIPSReflection::INSTRUCTION m_ReflRegImm[MAX_REGIMM_OPS]; + MIPSReflection::INSTRUCTION m_ReflGeneral[MAX_GENERAL_OPS]; + MIPSReflection::INSTRUCTION m_ReflSpecial[MAX_SPECIAL_OPS]; + MIPSReflection::INSTRUCTION m_ReflRegImm[MAX_REGIMM_OPS]; - MIPSReflection::SUBTABLE m_ReflGeneralTable; - MIPSReflection::SUBTABLE m_ReflSpecialTable; - MIPSReflection::SUBTABLE m_ReflRegImmTable; + MIPSReflection::SUBTABLE m_ReflGeneralTable; + MIPSReflection::SUBTABLE m_ReflSpecialTable; + MIPSReflection::SUBTABLE m_ReflRegImmTable; - uint8 m_nRS; - uint8 m_nRT; - uint8 m_nRD; - uint8 m_nSA; - uint16 m_nImmediate; + uint8 m_nRS; + uint8 m_nRT; + uint8 m_nRD; + uint8 m_nSA; + uint16 m_nImmediate; protected: //Instruction compiler templates - typedef std::function TemplateParamedOperationFunctionType; - typedef std::function TemplateOperationFunctionType; + typedef std::function TemplateParamedOperationFunctionType; + typedef std::function TemplateOperationFunctionType; void Template_Add32(bool); void Template_Add64(bool); @@ -91,131 +91,131 @@ protected: void Template_BranchLez(bool, bool); private: - void SetupInstructionTables(); - void SetupReflectionTables(); + void SetupInstructionTables(); + void SetupReflectionTables(); - void SPECIAL(); - void SPECIAL2(); - void REGIMM(); + void SPECIAL(); + void SPECIAL2(); + void REGIMM(); //General - void J(); - void JAL(); - void BEQ(); - void BNE(); - void BLEZ(); - void BGTZ(); - void ADDI(); - void ADDIU(); - void SLTI(); - void SLTIU(); - void ANDI(); - void ORI(); - void XORI(); - void LUI(); - void COP0(); - void COP1(); - void COP2(); - void BEQL(); - void BNEL(); - void BLEZL(); - void BGTZL(); - void DADDI(); - void DADDIU(); - void LDL(); - void LDR(); - void LB(); - void LH(); - void LWL(); - void LW(); - void LBU(); - void LHU(); - void LWR(); - void LWU(); - void SB(); - void SH(); - void SWL(); - void SW(); - void SDL(); - void SDR(); - void SWR(); - void CACHE(); - void LWC1(); - void PREF(); - void LDC2(); - void LD(); - void SWC1(); - void SDC2(); - void SD(); + void J(); + void JAL(); + void BEQ(); + void BNE(); + void BLEZ(); + void BGTZ(); + void ADDI(); + void ADDIU(); + void SLTI(); + void SLTIU(); + void ANDI(); + void ORI(); + void XORI(); + void LUI(); + void COP0(); + void COP1(); + void COP2(); + void BEQL(); + void BNEL(); + void BLEZL(); + void BGTZL(); + void DADDI(); + void DADDIU(); + void LDL(); + void LDR(); + void LB(); + void LH(); + void LWL(); + void LW(); + void LBU(); + void LHU(); + void LWR(); + void LWU(); + void SB(); + void SH(); + void SWL(); + void SW(); + void SDL(); + void SDR(); + void SWR(); + void CACHE(); + void LWC1(); + void PREF(); + void LDC2(); + void LD(); + void SWC1(); + void SDC2(); + void SD(); - //Special - void SLL(); - void SRL(); - void SRA(); - void SLLV(); - void SRLV(); - void SRAV(); - void JR(); - void JALR(); - void MOVZ(); - void MOVN(); - void SYSCALL(); - void BREAK(); - void SYNC(); - void DSLLV(); - void DSRLV(); - void DSRAV(); - void MFHI(); - void MTHI(); - void MFLO(); - void MTLO(); - void MULT(); - void MULTU(); - void DIV(); - void DIVU(); - void ADD(); - void ADDU(); - void SUB(); - void SUBU(); - void AND(); - void OR(); - void XOR(); - void NOR(); - void SLT(); - void SLTU(); - void DADD(); - void DADDU(); - void DSUB(); - void DSUBU(); - void TEQ(); - void DSLL(); - void DSRL(); - void DSRA(); - void DSLL32(); - void DSRL32(); - void DSRA32(); + //Special + void SLL(); + void SRL(); + void SRA(); + void SLLV(); + void SRLV(); + void SRAV(); + void JR(); + void JALR(); + void MOVZ(); + void MOVN(); + void SYSCALL(); + void BREAK(); + void SYNC(); + void DSLLV(); + void DSRLV(); + void DSRAV(); + void MFHI(); + void MTHI(); + void MFLO(); + void MTLO(); + void MULT(); + void MULTU(); + void DIV(); + void DIVU(); + void ADD(); + void ADDU(); + void SUB(); + void SUBU(); + void AND(); + void OR(); + void XOR(); + void NOR(); + void SLT(); + void SLTU(); + void DADD(); + void DADDU(); + void DSUB(); + void DSUBU(); + void TEQ(); + void DSLL(); + void DSRL(); + void DSRA(); + void DSLL32(); + void DSRL32(); + void DSRA32(); //Special2 //RegImm - void BLTZ(); - void BGEZ(); - void BLTZL(); - void BGEZL(); - void BLTZAL(); - void BGEZAL(); - void BLTZALL(); - void BGEZALL(); + void BLTZ(); + void BGEZ(); + void BLTZL(); + void BGEZL(); + void BLTZAL(); + void BGEZAL(); + void BLTZALL(); + void BGEZALL(); //Opcode tables typedef void (CMA_MIPSIV::*InstructionFuncConstant)(); - static InstructionFuncConstant m_cOpGeneral[MAX_GENERAL_OPS]; - static InstructionFuncConstant m_cOpSpecial[MAX_SPECIAL_OPS]; - static InstructionFuncConstant m_cOpRegImm[MAX_REGIMM_OPS]; + static InstructionFuncConstant m_cOpGeneral[MAX_GENERAL_OPS]; + static InstructionFuncConstant m_cOpSpecial[MAX_SPECIAL_OPS]; + static InstructionFuncConstant m_cOpRegImm[MAX_REGIMM_OPS]; //Reflection tables - static MIPSReflection::INSTRUCTION m_cReflGeneral[MAX_GENERAL_OPS]; - static MIPSReflection::INSTRUCTION m_cReflSpecial[MAX_SPECIAL_OPS]; - static MIPSReflection::INSTRUCTION m_cReflRegImm[MAX_REGIMM_OPS]; + static MIPSReflection::INSTRUCTION m_cReflGeneral[MAX_GENERAL_OPS]; + static MIPSReflection::INSTRUCTION m_cReflSpecial[MAX_SPECIAL_OPS]; + static MIPSReflection::INSTRUCTION m_cReflRegImm[MAX_REGIMM_OPS]; }; diff --git a/Source/MA_MIPSIV_Reflection.cpp b/Source/MA_MIPSIV_Reflection.cpp index 091df77c3..954be2013 100644 --- a/Source/MA_MIPSIV_Reflection.cpp +++ b/Source/MA_MIPSIV_Reflection.cpp @@ -16,9 +16,9 @@ void CMA_MIPSIV::ReflOpRtRsImm(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress uint8 nRS, nRT; uint16 nImm; - nRS = (uint8) ((nOpcode >> 21) & 0x001F); - nRT = (uint8) ((nOpcode >> 16) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRS = (uint8)((nOpcode >> 21) & 0x001F); + nRT = (uint8)((nOpcode >> 16) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); sprintf(sText, "%s, %s, $%04X", CMIPS::m_sGPRName[nRT], CMIPS::m_sGPRName[nRS], nImm); } @@ -28,8 +28,8 @@ void CMA_MIPSIV::ReflOpRtImm(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint8 nRT; uint16 nImm; - nRT = (uint8) ((nOpcode >> 16) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRT = (uint8)((nOpcode >> 16) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); sprintf(sText, "%s, $%04X", CMIPS::m_sGPRName[nRT], nImm); } @@ -39,9 +39,9 @@ void CMA_MIPSIV::ReflOpRsRtOff(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress uint8 nRS, nRT; uint16 nImm; - nRS = (uint8) ((nOpcode >> 21) & 0x001F); - nRT = (uint8) ((nOpcode >> 16) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRS = (uint8)((nOpcode >> 21) & 0x001F); + nRT = (uint8)((nOpcode >> 16) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "%s, %s, $%08X", CMIPS::m_sGPRName[nRS], CMIPS::m_sGPRName[nRT], (nAddress + CMIPS::GetBranch(nImm))); @@ -52,8 +52,8 @@ void CMA_MIPSIV::ReflOpRsOff(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint8 nRS; uint16 nImm; - nRS = (uint8) ((nOpcode >> 21) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRS = (uint8)((nOpcode >> 21) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "%s, $%08X", CMIPS::m_sGPRName[nRS], (nAddress + CMIPS::GetBranch(nImm))); @@ -64,9 +64,9 @@ void CMA_MIPSIV::ReflOpRtOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress uint8 nRS, nRT; uint16 nImm; - nRS = (uint8) ((nOpcode >> 21) & 0x001F); - nRT = (uint8) ((nOpcode >> 16) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRS = (uint8)((nOpcode >> 21) & 0x001F); + nRT = (uint8)((nOpcode >> 16) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "%s, $%04X(%s)", CMIPS::m_sGPRName[nRT], nImm, CMIPS::m_sGPRName[nRS]); @@ -74,9 +74,9 @@ void CMA_MIPSIV::ReflOpRtOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress void CMA_MIPSIV::ReflOpHintOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nRS = (uint8) ((nOpcode >> 21) & 0x001F); - uint8 nHint = (uint8) ((nOpcode >> 16) & 0x001F); - uint16 nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + uint8 nRS = (uint8)((nOpcode >> 21) & 0x001F); + uint8 nHint = (uint8)((nOpcode >> 16) & 0x001F); + uint16 nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "%i, $%04X(%s)", nHint, nImm, CMIPS::m_sGPRName[nRS]); @@ -87,9 +87,9 @@ void CMA_MIPSIV::ReflOpIdOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress uint8 nRS, nRT; uint16 nImm; - nRS = (uint8) ((nOpcode >> 21) & 0x001F); - nRT = (uint8) ((nOpcode >> 16) & 0x001F); - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + nRS = (uint8)((nOpcode >> 21) & 0x001F); + nRT = (uint8)((nOpcode >> 16) & 0x001F); + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; sprintf(sText, "$%02X, $%04X(%s)", nRT, nImm, CMIPS::m_sGPRName[nRS]); @@ -112,7 +112,7 @@ void CMA_MIPSIV::ReflOpRdRtSa(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, nRT = (uint8)((nOpcode >> 16) & 0x001F); nRD = (uint8)((nOpcode >> 11) & 0x001F); - nSA = (uint8)((nOpcode >> 6) & 0x001F); + nSA = (uint8)((nOpcode >> 6) & 0x001F); sprintf(sText, "%s, %s, %i", CMIPS::m_sGPRName[nRD], CMIPS::m_sGPRName[nRT], nSA); } @@ -175,8 +175,8 @@ uint32 CMA_MIPSIV::ReflEaTarget(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddres uint32 CMA_MIPSIV::ReflEaOffset(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { uint16 nImm; - - nImm = (uint16)((nOpcode >> 0) & 0xFFFF); + + nImm = (uint16)((nOpcode >> 0) & 0xFFFF); nAddress += 4; return (nAddress + CMIPS::GetBranch(nImm)); @@ -430,28 +430,28 @@ INSTRUCTION CMA_MIPSIV::m_cReflRegImm[32] = void CMA_MIPSIV::SetupReflectionTables() { - static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_ReflSpecial) == sizeof(m_cReflSpecial), "Array sizes don't match"); - static_assert(sizeof(m_ReflRegImm) == sizeof(m_cReflRegImm), "Array sizes don't match"); + static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_ReflSpecial) == sizeof(m_cReflSpecial), "Array sizes don't match"); + static_assert(sizeof(m_ReflRegImm) == sizeof(m_cReflRegImm), "Array sizes don't match"); - memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); - memcpy(m_ReflSpecial, m_cReflSpecial, sizeof(m_cReflSpecial)); - memcpy(m_ReflRegImm, m_cReflRegImm, sizeof(m_cReflRegImm)); + memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); + memcpy(m_ReflSpecial, m_cReflSpecial, sizeof(m_cReflSpecial)); + memcpy(m_ReflRegImm, m_cReflRegImm, sizeof(m_cReflRegImm)); - m_ReflGeneralTable.nShift = 26; - m_ReflGeneralTable.nMask = 0x3F; - m_ReflGeneralTable.pTable = m_ReflGeneral; + m_ReflGeneralTable.nShift = 26; + m_ReflGeneralTable.nMask = 0x3F; + m_ReflGeneralTable.pTable = m_ReflGeneral; - m_ReflSpecialTable.nShift = 0; - m_ReflSpecialTable.nMask = 0x3F; - m_ReflSpecialTable.pTable = m_ReflSpecial; + m_ReflSpecialTable.nShift = 0; + m_ReflSpecialTable.nMask = 0x3F; + m_ReflSpecialTable.pTable = m_ReflSpecial; - m_ReflRegImmTable.nShift = 16; - m_ReflRegImmTable.nMask = 0x1F; - m_ReflRegImmTable.pTable = m_ReflRegImm; + m_ReflRegImmTable.nShift = 16; + m_ReflRegImmTable.nMask = 0x1F; + m_ReflRegImmTable.pTable = m_ReflRegImm; - m_ReflGeneral[0x00].pSubTable = &m_ReflSpecialTable; - m_ReflGeneral[0x01].pSubTable = &m_ReflRegImmTable; + m_ReflGeneral[0x00].pSubTable = &m_ReflSpecialTable; + m_ReflGeneral[0x01].pSubTable = &m_ReflRegImmTable; } void CMA_MIPSIV::GetInstructionMnemonic(CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) @@ -464,8 +464,8 @@ void CMA_MIPSIV::GetInstructionMnemonic(CMIPS* pCtx, uint32 nAddress, uint32 nOp return; } - Instr.pGetMnemonic = SubTableMnemonic; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetMnemonic = SubTableMnemonic; + Instr.pSubTable = &m_ReflGeneralTable; Instr.pGetMnemonic(&Instr, pCtx, nOpcode, sText, nCount); } @@ -479,8 +479,8 @@ void CMA_MIPSIV::GetInstructionOperands(CMIPS* pCtx, uint32 nAddress, uint32 nOp return; } - Instr.pGetOperands = SubTableOperands; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetOperands = SubTableOperands; + Instr.pSubTable = &m_ReflGeneralTable; Instr.pGetOperands(&Instr, pCtx, nAddress, nOpcode, sText, nCount); } @@ -490,8 +490,8 @@ MIPS_BRANCH_TYPE CMA_MIPSIV::IsInstructionBranch(CMIPS* pCtx, uint32 nAddress, u if(nOpcode == 0) return MIPS_BRANCH_NONE; - Instr.pIsBranch = SubTableIsBranch; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pIsBranch = SubTableIsBranch; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pIsBranch(&Instr, pCtx, nOpcode); } @@ -501,7 +501,7 @@ uint32 CMA_MIPSIV::GetInstructionEffectiveAddress(CMIPS* pCtx, uint32 nAddress, if(nOpcode == 0) return 0; - Instr.pGetEffectiveAddress = SubTableEffAddr; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetEffectiveAddress = SubTableEffAddr; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pGetEffectiveAddress(&Instr, pCtx, nAddress, nOpcode); } diff --git a/Source/MA_MIPSIV_Templates.cpp b/Source/MA_MIPSIV_Templates.cpp index 9cb9046a1..327a3dea5 100644 --- a/Source/MA_MIPSIV_Templates.cpp +++ b/Source/MA_MIPSIV_Templates.cpp @@ -400,7 +400,7 @@ void CMA_MIPSIV::Template_BranchEq(bool condition, bool likely) m_codeGen->PushRel64(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[0])); m_codeGen->PushRel64(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[0])); m_codeGen->Cmp64(Jitter::CONDITION_NE); - + m_codeGen->PushCst(0); } diff --git a/Source/MIPS.cpp b/Source/MIPS.cpp index f9acdf52f..5cc9551a9 100644 --- a/Source/MIPS.cpp +++ b/Source/MIPS.cpp @@ -4,14 +4,13 @@ #include "COP_SCU.h" const char* CMIPS::m_sGPRName[] = -{ - "R0", "AT", "V0", "V1", "A0", "A1", "A2", "A3", - "T0", "T1", "T2", "T3", "T4", "T5", "T6", "T7", - "S0", "S1", "S2", "S3", "S4", "S5", "S6", "S7", - "T8", "T9", "K0", "K1", "GP", "SP", "FP", "RA" -}; + { + "R0", "AT", "V0", "V1", "A0", "A1", "A2", "A3", + "T0", "T1", "T2", "T3", "T4", "T5", "T6", "T7", + "S0", "S1", "S2", "S3", "S4", "S5", "S6", "S7", + "T8", "T9", "K0", "K1", "GP", "SP", "FP", "RA"}; -CMIPS::CMIPS(MEMORYMAP_ENDIANESS nEnd) +CMIPS::CMIPS(MEMORYMAP_ENDIANESS nEnd) { m_analysis = new CMIPSAnalysis(this); switch(nEnd) diff --git a/Source/MIPS.h b/Source/MIPS.h index 32ed8ca04..399171dc5 100644 --- a/Source/MIPS.h +++ b/Source/MIPS.h @@ -12,8 +12,8 @@ struct REGISTER_PIPELINE { - uint32 counter; - uint32 heldValue; + uint32 counter; + uint32 heldValue; }; enum @@ -27,9 +27,9 @@ enum //- The value at index - 1 is the latest value struct FLAG_PIPELINE { - uint32 index; - uint32 values[FLAG_PIPELINE_SLOTS]; - uint32 pipeTimes[FLAG_PIPELINE_SLOTS]; + uint32 index; + uint32 values[FLAG_PIPELINE_SLOTS]; + uint32 pipeTimes[FLAG_PIPELINE_SLOTS]; }; enum @@ -44,127 +44,155 @@ enum struct MIPSSTATE { - uint32 nPC; - uint32 nDelayedJumpAddr; - uint32 nHasException; + uint32 nPC; + uint32 nDelayedJumpAddr; + uint32 nHasException; #ifdef _WIN32 -__declspec(align(16)) + __declspec(align(16)) #else -__attribute__((aligned(16))) + __attribute__((aligned(16))) #endif - uint128 nGPR[32]; + uint128 nGPR[32]; - uint32 nHI[2]; - uint32 nLO[2]; - uint32 nHI1[2]; - uint32 nLO1[2]; - uint32 nSA; + uint32 nHI[2]; + uint32 nLO[2]; + uint32 nHI1[2]; + uint32 nLO1[2]; + uint32 nSA; //COP0 - uint32 nCOP0[32]; + uint32 nCOP0[32]; - uint32 cop0_pccr; - uint32 cop0_pcr[2]; + uint32 cop0_pccr; + uint32 cop0_pcr[2]; //COP1 - uint32 nCOP1[32]; - uint32 nCOP1A; - uint32 nFCSR; + uint32 nCOP1[32]; + uint32 nCOP1A; + uint32 nFCSR; //COP2 #ifdef _WIN32 -__declspec(align(16)) + __declspec(align(16)) #else -__attribute__((aligned(16))) + __attribute__((aligned(16))) #endif - uint128 nCOP2[33]; + uint128 nCOP2[33]; - uint128 nCOP2A; + uint128 nCOP2A; - uint128 nCOP2VF_PreUp; - uint128 nCOP2VF_UpRes; + uint128 nCOP2VF_PreUp; + uint128 nCOP2VF_UpRes; - uint32 nCOP2Q; - uint32 nCOP2I; - uint32 nCOP2P; - uint32 nCOP2R; - uint32 nCOP2CF; //Mirror of CLIP flag (computed with values from pipeClip) - uint32 nCOP2MF; //Mirror of MACflag (computed with values from pipeMac) - uint32 nCOP2SF; //Sticky values of sign and zero MACflag (ie.: SxSySzSw ZxZyZzZw) - uint32 nCOP2T; + uint32 nCOP2Q; + uint32 nCOP2I; + uint32 nCOP2P; + uint32 nCOP2R; + uint32 nCOP2CF; //Mirror of CLIP flag (computed with values from pipeClip) + uint32 nCOP2MF; //Mirror of MACflag (computed with values from pipeMac) + uint32 nCOP2SF; //Sticky values of sign and zero MACflag (ie.: SxSySzSw ZxZyZzZw) + uint32 nCOP2T; - uint32 nCOP2VI[16]; + uint32 nCOP2VI[16]; - REGISTER_PIPELINE pipeQ; - REGISTER_PIPELINE pipeP; - FLAG_PIPELINE pipeMac; - FLAG_PIPELINE pipeClip; + REGISTER_PIPELINE pipeQ; + REGISTER_PIPELINE pipeP; + FLAG_PIPELINE pipeMac; + FLAG_PIPELINE pipeClip; - uint32 pipeTime; + uint32 pipeTime; - uint32 cmsar0; - uint32 callMsEnabled; - uint32 callMsAddr; + uint32 cmsar0; + uint32 callMsEnabled; + uint32 callMsAddr; - uint32 savedIntReg; - uint32 savedIntRegTemp; - uint32 xgkickAddress; + uint32 savedIntReg; + uint32 savedIntRegTemp; + uint32 xgkickAddress; }; -#define MIPS_INVALID_PC (0x00000001) +#define MIPS_INVALID_PC (0x00000001) class CMIPS { public: - typedef uint32 (*AddressTranslator)(CMIPS*, uint32); - typedef std::set BreakpointSet; + typedef uint32 (*AddressTranslator)(CMIPS*, uint32); + typedef std::set BreakpointSet; - CMIPS(MEMORYMAP_ENDIANESS); - ~CMIPS(); - void ToggleBreakpoint(uint32); - bool IsBranch(uint32); - static int32 GetBranch(uint16); - static uint32 TranslateAddress64(CMIPS*, uint32); + CMIPS(MEMORYMAP_ENDIANESS); + ~CMIPS(); + void ToggleBreakpoint(uint32); + bool IsBranch(uint32); + static int32 GetBranch(uint16); + static uint32 TranslateAddress64(CMIPS*, uint32); - void Reset(); + void Reset(); - bool CanGenerateInterrupt() const; - bool GenerateInterrupt(uint32); - bool GenerateException(uint32); + bool CanGenerateInterrupt() const; + bool GenerateInterrupt(uint32); + bool GenerateException(uint32); - MIPSSTATE m_State; + MIPSSTATE m_State; - void* m_vuMem = nullptr; + void* m_vuMem = nullptr; - CMIPSArchitecture* m_pArch = nullptr; - CMIPSCoprocessor* m_pCOP[4]; - CMemoryMap* m_pMemoryMap = nullptr; - BreakpointSet m_breakpoints; + CMIPSArchitecture* m_pArch = nullptr; + CMIPSCoprocessor* m_pCOP[4]; + CMemoryMap* m_pMemoryMap = nullptr; + BreakpointSet m_breakpoints; - CMIPSAnalysis* m_analysis = nullptr; - CMIPSTags m_Comments; - CMIPSTags m_Functions; + CMIPSAnalysis* m_analysis = nullptr; + CMIPSTags m_Comments; + CMIPSTags m_Functions; - AddressTranslator m_pAddrTranslator = nullptr; + AddressTranslator m_pAddrTranslator = nullptr; enum REGISTER { - R0 = 0, AT, V0, V1, A0, A1, A2, A3, - T0, T1, T2, T3, T4, T5, T6, T7, - S0, S1, S2, S3, S4, S5, S6, S7, - T8, T9, K0, K1, GP, SP, FP, RA + R0 = 0, + AT, + V0, + V1, + A0, + A1, + A2, + A3, + T0, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + S0, + S1, + S2, + S3, + S4, + S5, + S6, + S7, + T8, + T9, + K0, + K1, + GP, + SP, + FP, + RA }; enum { - STATUS_IE = (1 << 0), - STATUS_EXL = (1 << 1), - STATUS_ERL = (1 << 2), - STATUS_EIE = (1 << 16), //PS2 EE specific + STATUS_IE = (1 << 0), + STATUS_EXL = (1 << 1), + STATUS_ERL = (1 << 2), + STATUS_EIE = (1 << 16), //PS2 EE specific }; - static const char* m_sGPRName[]; + static const char* m_sGPRName[]; }; #endif diff --git a/Source/MIPSAnalysis.cpp b/Source/MIPSAnalysis.cpp index bfd8b2dba..1ec59ce0e 100644 --- a/Source/MIPSAnalysis.cpp +++ b/Source/MIPSAnalysis.cpp @@ -3,14 +3,12 @@ #include "MIPS.h" CMIPSAnalysis::CMIPSAnalysis(CMIPS* ctx) -: m_ctx(ctx) + : m_ctx(ctx) { - } CMIPSAnalysis::~CMIPSAnalysis() { - } void CMIPSAnalysis::Clear() @@ -30,12 +28,12 @@ void CMIPSAnalysis::InsertSubroutine(uint32 start, uint32 end, uint32 stackAlloc assert(FindSubroutine(end) == nullptr); SUBROUTINE subroutine; - subroutine.start = start; - subroutine.end = end; - subroutine.stackAllocStart = stackAllocStart; - subroutine.stackAllocEnd = stackAllocEnd; - subroutine.stackSize = stackSize; - subroutine.returnAddrPos = returnAddrPos; + subroutine.start = start; + subroutine.end = end; + subroutine.stackAllocStart = stackAllocStart; + subroutine.stackAllocEnd = stackAllocEnd; + subroutine.stackSize = stackSize; + subroutine.returnAddrPos = returnAddrPos; m_subroutines.insert(std::make_pair(start, subroutine)); } @@ -118,9 +116,9 @@ void CMIPSAnalysis::FindSubroutinesByStackAllocation(uint32 start, uint32 end) //Check SW/SD/SQ RA, 0x????(SP) if( - ((opcode & 0xFFFF0000) == 0xAFBF0000) || //SW - ((opcode & 0xFFFF0000) == 0xFFBF0000) || //SD - ((opcode & 0xFFFF0000) == 0x7FBF0000)) //SQ + ((opcode & 0xFFFF0000) == 0xAFBF0000) || //SW + ((opcode & 0xFFFF0000) == 0xFFBF0000) || //SD + ((opcode & 0xFFFF0000) == 0x7FBF0000)) //SQ { returnAddr = (opcode & 0xFFFF); } @@ -133,7 +131,7 @@ void CMIPSAnalysis::FindSubroutinesByStackAllocation(uint32 start, uint32 end) //Check above //ADDIU SP, SP, 0x???? //JR RA - + opcode = m_ctx->m_pMemoryMap->GetInstruction(tempAddr - 4); if(IsStackFreeingInstruction(opcode)) { @@ -179,8 +177,8 @@ void CMIPSAnalysis::FindSubroutinesByJumpTargets(uint32 start, uint32 end, uint3 { uint32 opcode = m_ctx->m_pMemoryMap->GetInstruction(address); if( - (opcode & 0xFC000000) == 0x0C000000 || - (opcode & 0xFC000000) == 0x08000000) + (opcode & 0xFC000000) == 0x0C000000 || + (opcode & 0xFC000000) == 0x08000000) { uint32 jumpTarget = (opcode & 0x03FFFFFF) * 4; if(jumpTarget < start) continue; @@ -229,31 +227,30 @@ void CMIPSAnalysis::ExpandSubroutines(uint32 executableStart, uint32 executableE static const uint32 searchLimit = 0x1000; const auto& findFreeSubroutineEnd = - [this](uint32 begin, uint32 end) -> uint32 + [this](uint32 begin, uint32 end) -> uint32 { + for(uint32 address = begin; address <= begin + searchLimit; address += 4) { - for(uint32 address = begin; address <= begin + searchLimit; address += 4) + if(FindSubroutine(address) != nullptr) return MIPS_INVALID_PC; + + uint32 opcode = m_ctx->m_pMemoryMap->GetInstruction(address); + + //Check for JR RA or J + if((opcode == 0x03E00008) || ((opcode & 0xFC000000) == 0x08000000)) { - if(FindSubroutine(address) != nullptr) return MIPS_INVALID_PC; - - uint32 opcode = m_ctx->m_pMemoryMap->GetInstruction(address); - - //Check for JR RA or J - if((opcode == 0x03E00008) || ((opcode & 0xFC000000) == 0x08000000)) - { - //+4 for delay slot - return address + 4; - } - - //Check for BEQ R0, R0, $label - if((opcode & 0xFFFF0000) == 0x10000000) - { - //+4 for delay slot - return address + 4; - } + //+4 for delay slot + return address + 4; } - return MIPS_INVALID_PC; - }; + //Check for BEQ R0, R0, $label + if((opcode & 0xFFFF0000) == 0x10000000) + { + //+4 for delay slot + return address + 4; + } + } + + return MIPS_INVALID_PC; + }; for(auto& subroutinePair : m_subroutines) { @@ -267,10 +264,10 @@ void CMIPSAnalysis::ExpandSubroutines(uint32 executableStart, uint32 executableE for(uint32 address = subroutine.start; address <= subroutine.end; address += 4) { uint32 opcode = m_ctx->m_pMemoryMap->GetInstruction(address); - + auto branchType = m_ctx->m_pArch->IsInstructionBranch(m_ctx, address, opcode); if(branchType != MIPS_BRANCH_NORMAL) continue; - + uint32 branchTarget = m_ctx->m_pArch->GetInstructionEffectiveAddress(m_ctx, address, opcode); //Check if pointing inside our subroutine. If so, don't bother @@ -289,7 +286,7 @@ void CMIPSAnalysis::ExpandSubroutines(uint32 executableStart, uint32 executableE if(FindSubroutine(branchTarget) != nullptr) continue; uint32 routineEnd = findFreeSubroutineEnd(branchTarget, executableEnd); - if(routineEnd == MIPS_INVALID_PC) + if(routineEnd == MIPS_INVALID_PC) { continue; } @@ -323,10 +320,10 @@ static bool TryGetStringAtAddress(CMIPS* context, uint32 address, std::string& r uint8 byte = context->m_pMemoryMap->GetByte(address); if(byte == 0) break; if(byte > 0x7F) return false; - if((byte < 0x20) && - (byte != '\t') && - (byte != '\n') && - (byte != '\r')) + if((byte < 0x20) && + (byte != '\t') && + (byte != '\n') && + (byte != '\r')) { return false; } @@ -341,8 +338,8 @@ void CMIPSAnalysis::AnalyseStringReferences() for(auto subroutinePair : m_subroutines) { const auto& subroutine = subroutinePair.second; - uint32 registerValue[0x20] = { 0 }; - bool registerWritten[0x20] = { false }; + uint32 registerValue[0x20] = {0}; + bool registerWritten[0x20] = {false}; for(uint32 address = subroutine.start; address <= subroutine.end; address += 4) { uint32 op = m_ctx->m_pMemoryMap->GetInstruction(address); @@ -416,7 +413,7 @@ CMIPSAnalysis::CallStackItemArray CMIPSAnalysis::GetCallStack(CMIPS* context, ui { //We haven't called a sub routine yet... The RA is good, but we //don't know wether stack memory has been allocated or not - + //ADDIU SP, SP, 0x???? //If the PC is after this instruction, then, we've allocated stack diff --git a/Source/MIPSAnalysis.h b/Source/MIPSAnalysis.h index 1711c9a9e..88045d12f 100644 --- a/Source/MIPSAnalysis.h +++ b/Source/MIPSAnalysis.h @@ -12,38 +12,38 @@ class CMIPSAnalysis public: struct SUBROUTINE { - uint32 start; - uint32 end; - uint32 stackAllocStart; - uint32 stackAllocEnd; - uint32 stackSize; - uint32 returnAddrPos; + uint32 start; + uint32 end; + uint32 stackAllocStart; + uint32 stackAllocEnd; + uint32 stackSize; + uint32 returnAddrPos; }; typedef std::vector CallStackItemArray; - CMIPSAnalysis(CMIPS*); - ~CMIPSAnalysis(); - void Analyse(uint32, uint32, uint32 = -1); - const SUBROUTINE* FindSubroutine(uint32) const; - void Clear(); + CMIPSAnalysis(CMIPS*); + ~CMIPSAnalysis(); + void Analyse(uint32, uint32, uint32 = -1); + const SUBROUTINE* FindSubroutine(uint32) const; + void Clear(); - void InsertSubroutine(uint32, uint32, uint32, uint32, uint32, uint32); - void ChangeSubroutineStart(uint32, uint32); - void ChangeSubroutineEnd(uint32, uint32); + void InsertSubroutine(uint32, uint32, uint32, uint32, uint32, uint32); + void ChangeSubroutineStart(uint32, uint32); + void ChangeSubroutineEnd(uint32, uint32); - static CallStackItemArray GetCallStack(CMIPS*, uint32 pc, uint32 sp, uint32 ra); + static CallStackItemArray GetCallStack(CMIPS*, uint32 pc, uint32 sp, uint32 ra); private: typedef std::map> SubroutineList; - void AnalyseSubroutines(uint32, uint32, uint32); - void AnalyseStringReferences(); + void AnalyseSubroutines(uint32, uint32, uint32); + void AnalyseStringReferences(); - void FindSubroutinesByStackAllocation(uint32, uint32); - void FindSubroutinesByJumpTargets(uint32, uint32, uint32); - void ExpandSubroutines(uint32, uint32); + void FindSubroutinesByStackAllocation(uint32, uint32); + void FindSubroutinesByJumpTargets(uint32, uint32, uint32); + void ExpandSubroutines(uint32, uint32); - CMIPS* m_ctx; - SubroutineList m_subroutines; + CMIPS* m_ctx; + SubroutineList m_subroutines; }; diff --git a/Source/MIPSArchitecture.cpp b/Source/MIPSArchitecture.cpp index 9f93e8f77..957b3b123 100644 --- a/Source/MIPSArchitecture.cpp +++ b/Source/MIPSArchitecture.cpp @@ -1,7 +1,6 @@ #include "MIPSArchitecture.h" CMIPSArchitecture::CMIPSArchitecture(MIPS_REGSIZE regSize) -: CMIPSInstructionFactory(regSize) + : CMIPSInstructionFactory(regSize) { - } diff --git a/Source/MIPSArchitecture.h b/Source/MIPSArchitecture.h index cfd675a0b..a3d197b87 100644 --- a/Source/MIPSArchitecture.h +++ b/Source/MIPSArchitecture.h @@ -5,10 +5,10 @@ class CMIPSArchitecture : public CMIPSInstructionFactory { public: - CMIPSArchitecture(MIPS_REGSIZE); - virtual ~CMIPSArchitecture() = default; - virtual void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int) = 0; - virtual void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int) = 0; - virtual MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32) = 0; - virtual uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32) = 0; + CMIPSArchitecture(MIPS_REGSIZE); + virtual ~CMIPSArchitecture() = default; + virtual void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int) = 0; + virtual void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int) = 0; + virtual MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32) = 0; + virtual uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32) = 0; }; diff --git a/Source/MIPSAssembler.cpp b/Source/MIPSAssembler.cpp index 740f100dd..8190227c0 100644 --- a/Source/MIPSAssembler.cpp +++ b/Source/MIPSAssembler.cpp @@ -4,11 +4,10 @@ #include "lexical_cast_ex.h" CMIPSAssembler::CMIPSAssembler(uint32* ptr) -: m_ptr(ptr) -, m_startPtr(ptr) -, m_nextLabelId(1) + : m_ptr(ptr) + , m_startPtr(ptr) + , m_nextLabelId(1) { - } CMIPSAssembler::~CMIPSAssembler() @@ -71,13 +70,13 @@ void CMIPSAssembler::ADDIU(unsigned int rt, unsigned int rs, uint16 immediate) void CMIPSAssembler::ADDU(unsigned int rd, unsigned int rs, unsigned int rt) { - (*m_ptr) = (rs << 21) | (rt << 16) | (rd << 11) | (0x21); + (*m_ptr) = (rs << 21) | (rt << 16) | (rd << 11) | (0x21); m_ptr++; } void CMIPSAssembler::AND(unsigned int rd, unsigned int rs, unsigned int rt) { - (*m_ptr) = (rs << 21) | (rt << 16) | (rd << 11) | (0x24); + (*m_ptr) = (rs << 21) | (rt << 16) | (rd << 11) | (0x24); m_ptr++; } diff --git a/Source/MIPSAssembler.h b/Source/MIPSAssembler.h index 8751a64c1..6f794f294 100644 --- a/Source/MIPSAssembler.h +++ b/Source/MIPSAssembler.h @@ -10,92 +10,92 @@ public: { unsigned int id; - bool operator < (const LABEL& rhs) const + bool operator<(const LABEL& rhs) const { return id < rhs.id; }; }; - CMIPSAssembler(uint32*); - ~CMIPSAssembler(); + CMIPSAssembler(uint32*); + ~CMIPSAssembler(); - unsigned int GetProgramSize(); - LABEL CreateLabel(); - void MarkLabel(LABEL); + unsigned int GetProgramSize(); + LABEL CreateLabel(); + void MarkLabel(LABEL); - void ADDIU(unsigned int, unsigned int, uint16); - void ADDU(unsigned int, unsigned int, unsigned int); - void AND(unsigned int, unsigned int, unsigned int); - void ANDI(unsigned int, unsigned int, uint16); - void BEQ(unsigned int, unsigned int, uint16); - void BEQ(unsigned int, unsigned int, LABEL); - void BGEZ(unsigned int, uint16); - void BGEZ(unsigned int, LABEL); - void BGTZ(unsigned int, uint16); - void BNE(unsigned int, unsigned int, uint16); - void BNE(unsigned int, unsigned int, LABEL); - void BLEZ(unsigned int, uint16); - void BLTZ(unsigned int, uint16); - void DADDU(unsigned int, unsigned int, unsigned int); - void DADDIU(unsigned int, unsigned int, uint16); - void DSLL(unsigned int, unsigned int, unsigned int); - void DSLL32(unsigned int, unsigned int, unsigned int); - void DSLLV(unsigned int, unsigned int, unsigned int); - void DSRA(unsigned int, unsigned int, unsigned int); - void DSRA32(unsigned int, unsigned int, unsigned int); - void DSRAV(unsigned int, unsigned int, unsigned int); - void DSRL(unsigned int, unsigned int, unsigned int); - void DSRL32(unsigned int, unsigned int, unsigned int); - void DSRLV(unsigned int, unsigned int, unsigned int); - void DSUBU(unsigned int, unsigned int, unsigned int); - void ERET(); - void JR(unsigned int); - void JAL(uint32); - void JALR(unsigned int, unsigned int = 31); - void LBU(unsigned int, uint16, unsigned int); - void LD(unsigned int, uint16, unsigned int); - void LDL(unsigned int, uint16, unsigned int); - void LDR(unsigned int, uint16, unsigned int); - void LHU(unsigned int, uint16, unsigned int); - void LI(unsigned int, uint32); - void LUI(unsigned int, uint16); - void LW(unsigned int, uint16, unsigned int); - void LWL(unsigned int, uint16, unsigned int); - void LWR(unsigned int, uint16, unsigned int); - void MFC0(unsigned int, unsigned int); - void MFHI(unsigned int); - void MFLO(unsigned int); - void MTC0(unsigned int, unsigned int); - void MTHI(unsigned int); - void MTLO(unsigned int); - void MOV(unsigned int, unsigned int); - void MULT(unsigned int, unsigned int, unsigned int); - void MULTU(unsigned int, unsigned int, unsigned int); - void NOP(); - void NOR(unsigned int, unsigned int, unsigned int); - void OR(unsigned int, unsigned int, unsigned int); - void ORI(unsigned int, unsigned int, uint16); - void SD(unsigned int, uint16, unsigned int); - void SLL(unsigned int, unsigned int, unsigned int); - void SLLV(unsigned int, unsigned int, unsigned int); - void SLT(unsigned int, unsigned int, unsigned int); - void SLTI(unsigned int, unsigned int, uint16); - void SLTIU(unsigned int, unsigned int, uint16); - void SLTU(unsigned int, unsigned int, unsigned int); - void SRA(unsigned int, unsigned int, unsigned int); - void SRAV(unsigned int, unsigned int, unsigned int); - void SRL(unsigned int, unsigned int, unsigned int); - void SRLV(unsigned int, unsigned int, unsigned int); - void SB(unsigned int, uint16, unsigned int); - void SW(unsigned int, uint16, unsigned int); - void SYSCALL(); + void ADDIU(unsigned int, unsigned int, uint16); + void ADDU(unsigned int, unsigned int, unsigned int); + void AND(unsigned int, unsigned int, unsigned int); + void ANDI(unsigned int, unsigned int, uint16); + void BEQ(unsigned int, unsigned int, uint16); + void BEQ(unsigned int, unsigned int, LABEL); + void BGEZ(unsigned int, uint16); + void BGEZ(unsigned int, LABEL); + void BGTZ(unsigned int, uint16); + void BNE(unsigned int, unsigned int, uint16); + void BNE(unsigned int, unsigned int, LABEL); + void BLEZ(unsigned int, uint16); + void BLTZ(unsigned int, uint16); + void DADDU(unsigned int, unsigned int, unsigned int); + void DADDIU(unsigned int, unsigned int, uint16); + void DSLL(unsigned int, unsigned int, unsigned int); + void DSLL32(unsigned int, unsigned int, unsigned int); + void DSLLV(unsigned int, unsigned int, unsigned int); + void DSRA(unsigned int, unsigned int, unsigned int); + void DSRA32(unsigned int, unsigned int, unsigned int); + void DSRAV(unsigned int, unsigned int, unsigned int); + void DSRL(unsigned int, unsigned int, unsigned int); + void DSRL32(unsigned int, unsigned int, unsigned int); + void DSRLV(unsigned int, unsigned int, unsigned int); + void DSUBU(unsigned int, unsigned int, unsigned int); + void ERET(); + void JR(unsigned int); + void JAL(uint32); + void JALR(unsigned int, unsigned int = 31); + void LBU(unsigned int, uint16, unsigned int); + void LD(unsigned int, uint16, unsigned int); + void LDL(unsigned int, uint16, unsigned int); + void LDR(unsigned int, uint16, unsigned int); + void LHU(unsigned int, uint16, unsigned int); + void LI(unsigned int, uint32); + void LUI(unsigned int, uint16); + void LW(unsigned int, uint16, unsigned int); + void LWL(unsigned int, uint16, unsigned int); + void LWR(unsigned int, uint16, unsigned int); + void MFC0(unsigned int, unsigned int); + void MFHI(unsigned int); + void MFLO(unsigned int); + void MTC0(unsigned int, unsigned int); + void MTHI(unsigned int); + void MTLO(unsigned int); + void MOV(unsigned int, unsigned int); + void MULT(unsigned int, unsigned int, unsigned int); + void MULTU(unsigned int, unsigned int, unsigned int); + void NOP(); + void NOR(unsigned int, unsigned int, unsigned int); + void OR(unsigned int, unsigned int, unsigned int); + void ORI(unsigned int, unsigned int, uint16); + void SD(unsigned int, uint16, unsigned int); + void SLL(unsigned int, unsigned int, unsigned int); + void SLLV(unsigned int, unsigned int, unsigned int); + void SLT(unsigned int, unsigned int, unsigned int); + void SLTI(unsigned int, unsigned int, uint16); + void SLTIU(unsigned int, unsigned int, uint16); + void SLTU(unsigned int, unsigned int, unsigned int); + void SRA(unsigned int, unsigned int, unsigned int); + void SRAV(unsigned int, unsigned int, unsigned int); + void SRL(unsigned int, unsigned int, unsigned int); + void SRLV(unsigned int, unsigned int, unsigned int); + void SB(unsigned int, uint16, unsigned int); + void SW(unsigned int, uint16, unsigned int); + void SYSCALL(); protected: - uint32* m_ptr = nullptr; + uint32* m_ptr = nullptr; private: - void ResolveLabelReferences(); - void CreateLabelReference(LABEL); + void ResolveLabelReferences(); + void CreateLabelReference(LABEL); struct LABELREF { @@ -105,8 +105,8 @@ private: typedef std::map LabelMapType; typedef std::multimap LabelReferenceMapType; - uint32* m_startPtr = nullptr; - LabelMapType m_labels; - LabelReferenceMapType m_labelReferences; - unsigned int m_nextLabelId; + uint32* m_startPtr = nullptr; + LabelMapType m_labels; + LabelReferenceMapType m_labelReferences; + unsigned int m_nextLabelId; }; diff --git a/Source/MIPSCoprocessor.cpp b/Source/MIPSCoprocessor.cpp index bef5da5a0..58025f80e 100644 --- a/Source/MIPSCoprocessor.cpp +++ b/Source/MIPSCoprocessor.cpp @@ -1,12 +1,10 @@ #include "MIPSCoprocessor.h" -CMIPSCoprocessor::CMIPSCoprocessor(MIPS_REGSIZE nRegSize) : -CMIPSInstructionFactory(nRegSize) +CMIPSCoprocessor::CMIPSCoprocessor(MIPS_REGSIZE nRegSize) + : CMIPSInstructionFactory(nRegSize) { - } CMIPSCoprocessor::~CMIPSCoprocessor() { - } diff --git a/Source/MIPSCoprocessor.h b/Source/MIPSCoprocessor.h index 704608814..62263eca6 100644 --- a/Source/MIPSCoprocessor.h +++ b/Source/MIPSCoprocessor.h @@ -6,12 +6,12 @@ class CMIPSCoprocessor : public CMIPSInstructionFactory { public: - CMIPSCoprocessor(MIPS_REGSIZE); - virtual ~CMIPSCoprocessor(); - virtual void GetInstruction(uint32, char*) = 0; - virtual void GetArguments(uint32, uint32, char*) = 0; - virtual uint32 GetEffectiveAddress(uint32, uint32) = 0; - virtual MIPS_BRANCH_TYPE IsBranch(uint32) = 0; + CMIPSCoprocessor(MIPS_REGSIZE); + virtual ~CMIPSCoprocessor(); + virtual void GetInstruction(uint32, char*) = 0; + virtual void GetArguments(uint32, uint32, char*) = 0; + virtual uint32 GetEffectiveAddress(uint32, uint32) = 0; + virtual MIPS_BRANCH_TYPE IsBranch(uint32) = 0; }; #endif diff --git a/Source/MIPSInstructionFactory.cpp b/Source/MIPSInstructionFactory.cpp index bac2b551f..920011db2 100644 --- a/Source/MIPSInstructionFactory.cpp +++ b/Source/MIPSInstructionFactory.cpp @@ -5,24 +5,23 @@ #include "offsetof_def.h" CMIPSInstructionFactory::CMIPSInstructionFactory(MIPS_REGSIZE nRegSize) -: m_regSize(nRegSize) + : m_regSize(nRegSize) { - } void CMIPSInstructionFactory::SetupQuickVariables(uint32 nAddress, CMipsJitter* codeGen, CMIPS* pCtx) { - m_pCtx = pCtx; - m_codeGen = codeGen; - m_nAddress = nAddress; + m_pCtx = pCtx; + m_codeGen = codeGen; + m_nAddress = nAddress; - m_nOpcode = m_pCtx->m_pMemoryMap->GetInstruction(m_nAddress); + m_nOpcode = m_pCtx->m_pMemoryMap->GetInstruction(m_nAddress); } void CMIPSInstructionFactory::ComputeMemAccessAddr() { - uint8 nRS = (uint8) ((m_nOpcode >> 21) & 0x001F); - uint16 nImmediate = (uint16)((m_nOpcode >> 0) & 0xFFFF); + uint8 nRS = (uint8)((m_nOpcode >> 21) & 0x001F); + uint16 nImmediate = (uint16)((m_nOpcode >> 0) & 0xFFFF); if(m_pCtx->m_pAddrTranslator == &CMIPS::TranslateAddress64) { diff --git a/Source/MIPSInstructionFactory.h b/Source/MIPSInstructionFactory.h index 5b6536925..d2be25ce5 100644 --- a/Source/MIPSInstructionFactory.h +++ b/Source/MIPSInstructionFactory.h @@ -7,35 +7,35 @@ class CMIPS; enum MIPS_REGSIZE { - MIPS_REGSIZE_32 = 0, - MIPS_REGSIZE_64 = 1, + MIPS_REGSIZE_32 = 0, + MIPS_REGSIZE_64 = 1, }; enum MIPS_BRANCH_TYPE { - MIPS_BRANCH_NONE = 0, - MIPS_BRANCH_NORMAL = 1, - MIPS_BRANCH_NODELAY = 2, + MIPS_BRANCH_NONE = 0, + MIPS_BRANCH_NORMAL = 1, + MIPS_BRANCH_NODELAY = 2, }; class CMIPSInstructionFactory { public: - CMIPSInstructionFactory(MIPS_REGSIZE); - virtual ~CMIPSInstructionFactory() = default; - virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*) = 0; + CMIPSInstructionFactory(MIPS_REGSIZE); + virtual ~CMIPSInstructionFactory() = default; + virtual void CompileInstruction(uint32, CMipsJitter*, CMIPS*) = 0; protected: - void ComputeMemAccessAddr(); - void Branch(Jitter::CONDITION); - void BranchLikely(Jitter::CONDITION); + void ComputeMemAccessAddr(); + void Branch(Jitter::CONDITION); + void BranchLikely(Jitter::CONDITION); - void Illegal(); - void SetupQuickVariables(uint32, CMipsJitter*, CMIPS*); + void Illegal(); + void SetupQuickVariables(uint32, CMipsJitter*, CMIPS*); - CMipsJitter* m_codeGen = nullptr; - CMIPS* m_pCtx = nullptr; - uint32 m_nOpcode = 0; - uint32 m_nAddress = 0; - MIPS_REGSIZE m_regSize; + CMipsJitter* m_codeGen = nullptr; + CMIPS* m_pCtx = nullptr; + uint32 m_nOpcode = 0; + uint32 m_nAddress = 0; + MIPS_REGSIZE m_regSize; }; diff --git a/Source/MIPSReflection.cpp b/Source/MIPSReflection.cpp index 2b542e65e..a47b9026d 100644 --- a/Source/MIPSReflection.cpp +++ b/Source/MIPSReflection.cpp @@ -20,9 +20,9 @@ void MIPSReflection::CopyMnemonic(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nOpco void MIPSReflection::SubTableMnemonic(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nOpcode, char* sText, unsigned int nCount) { pInstr = DereferenceInstruction(pInstr->pSubTable, nOpcode); - if(pInstr->pGetMnemonic == NULL) + if(pInstr->pGetMnemonic == NULL) { - strncpy(sText, "???", nCount); + strncpy(sText, "???", nCount); return; } pInstr->pGetMnemonic(pInstr, pCtx, nOpcode, sText, nCount); @@ -31,9 +31,9 @@ void MIPSReflection::SubTableMnemonic(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 n void MIPSReflection::SubTableOperands(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { pInstr = DereferenceInstruction(pInstr->pSubTable, nOpcode); - if(pInstr->pGetOperands == NULL) + if(pInstr->pGetOperands == NULL) { - strncpy(sText, "", nCount); + strncpy(sText, "", nCount); return; } pInstr->pGetOperands(pInstr, pCtx, nAddress, nOpcode, sText, nCount); diff --git a/Source/MIPSReflection.h b/Source/MIPSReflection.h index 3484c1b11..e0782c193 100644 --- a/Source/MIPSReflection.h +++ b/Source/MIPSReflection.h @@ -12,33 +12,34 @@ namespace MIPSReflection struct SUBTABLE { - uint32 nShift; - uint32 nMask; - INSTRUCTION* pTable; + uint32 nShift; + uint32 nMask; + INSTRUCTION* pTable; }; struct INSTRUCTION { - const char* sMnemonic; - SUBTABLE* pSubTable; - void (*pGetMnemonic)(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); - void (*pGetOperands)(INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - MIPS_BRANCH_TYPE (*pIsBranch)(INSTRUCTION*, CMIPS*, uint32); - uint32 (*pGetEffectiveAddress)(INSTRUCTION*, CMIPS*, uint32, uint32); + const char* sMnemonic; + SUBTABLE* pSubTable; + void (*pGetMnemonic)(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); + void (*pGetOperands)(INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + MIPS_BRANCH_TYPE(*pIsBranch) + (INSTRUCTION*, CMIPS*, uint32); + uint32 (*pGetEffectiveAddress)(INSTRUCTION*, CMIPS*, uint32, uint32); }; - INSTRUCTION* DereferenceInstruction(SUBTABLE*, uint32); + INSTRUCTION* DereferenceInstruction(SUBTABLE*, uint32); - void CopyMnemonic(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); - void SubTableMnemonic(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); + void CopyMnemonic(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); + void SubTableMnemonic(INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); - void SubTableOperands(INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void SubTableOperands(INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - MIPS_BRANCH_TYPE IsBranch(INSTRUCTION*, CMIPS*, uint32); - MIPS_BRANCH_TYPE IsNoDelayBranch(INSTRUCTION*, CMIPS*, uint32); - MIPS_BRANCH_TYPE SubTableIsBranch(INSTRUCTION*, CMIPS*, uint32); + MIPS_BRANCH_TYPE IsBranch(INSTRUCTION*, CMIPS*, uint32); + MIPS_BRANCH_TYPE IsNoDelayBranch(INSTRUCTION*, CMIPS*, uint32); + MIPS_BRANCH_TYPE SubTableIsBranch(INSTRUCTION*, CMIPS*, uint32); - uint32 SubTableEffAddr(INSTRUCTION*, CMIPS*, uint32, uint32); + uint32 SubTableEffAddr(INSTRUCTION*, CMIPS*, uint32, uint32); }; #endif diff --git a/Source/MIPSTags.cpp b/Source/MIPSTags.cpp index ab42f6b45..a21228a27 100644 --- a/Source/MIPSTags.cpp +++ b/Source/MIPSTags.cpp @@ -3,9 +3,9 @@ #include "lexical_cast_ex.h" #include "xml/FilteringNodeIterator.h" -#define TAG_ELEMENT_NAME ("tag") -#define TAG_ELEMENT_ATTRIBUTE_ADDRESS ("address") -#define TAG_ELEMENT_ATTRIBUTE_VALUE ("value") +#define TAG_ELEMENT_NAME ("tag") +#define TAG_ELEMENT_ATTRIBUTE_ADDRESS ("address") +#define TAG_ELEMENT_ATTRIBUTE_VALUE ("value") void CMIPSTags::InsertTag(uint32 nAddress, const char* sTag) { @@ -75,8 +75,8 @@ void CMIPSTags::Unserialize(const char* sPath) { char sTag[256]; - uint32 nKey = Stream.Read32(); - uint8 nLength = Stream.Read8(); + uint32 nKey = Stream.Read32(); + uint8 nLength = Stream.Read8(); Stream.Read(sTag, nLength); sTag[nLength] = 0; @@ -86,15 +86,14 @@ void CMIPSTags::Unserialize(const char* sPath) } catch(...) { - } } void CMIPSTags::Serialize(Framework::Xml::CNode* parentNode, const char* sectionName) const { - auto section = new Framework::Xml::CNode(sectionName, true); - Serialize(section); - parentNode->InsertNode(section); + auto section = new Framework::Xml::CNode(sectionName, true); + Serialize(section); + parentNode->InsertNode(section); } void CMIPSTags::Unserialize(Framework::Xml::CNode* parentNode, const char* sectionName) @@ -118,11 +117,11 @@ void CMIPSTags::Serialize(Framework::Xml::CNode* parentNode) const void CMIPSTags::Unserialize(Framework::Xml::CNode* parentNode) { for(Framework::Xml::CFilteringNodeIterator nodeIterator(parentNode, TAG_ELEMENT_NAME); - !nodeIterator.IsEnd(); nodeIterator++) + !nodeIterator.IsEnd(); nodeIterator++) { auto node = *nodeIterator; auto addressText = node->GetAttribute(TAG_ELEMENT_ATTRIBUTE_ADDRESS); - auto valueText = node->GetAttribute(TAG_ELEMENT_ATTRIBUTE_VALUE); + auto valueText = node->GetAttribute(TAG_ELEMENT_ATTRIBUTE_VALUE); if(!addressText || !valueText) continue; uint32 address = lexical_cast_hex(addressText); InsertTag(address, valueText); diff --git a/Source/MIPSTags.h b/Source/MIPSTags.h index 6d8f04bb1..93579817b 100644 --- a/Source/MIPSTags.h +++ b/Source/MIPSTags.h @@ -9,27 +9,27 @@ class CMIPSTags { public: - typedef std::map TagMap; - typedef TagMap::const_iterator TagIterator; + typedef std::map TagMap; + typedef TagMap::const_iterator TagIterator; - boost::signals2::signal OnTagListChange; + boost::signals2::signal OnTagListChange; - void InsertTag(uint32, const char*); - void RemoveTags(); - const char* Find(uint32) const; + void InsertTag(uint32, const char*); + void RemoveTags(); + const char* Find(uint32) const; - void Serialize(Framework::Xml::CNode*, const char*) const; - void Unserialize(Framework::Xml::CNode*, const char*); + void Serialize(Framework::Xml::CNode*, const char*) const; + void Unserialize(Framework::Xml::CNode*, const char*); - void Serialize(Framework::Xml::CNode*) const; - void Unserialize(Framework::Xml::CNode*); + void Serialize(Framework::Xml::CNode*) const; + void Unserialize(Framework::Xml::CNode*); - void Serialize(const char*) const; - void Unserialize(const char*); + void Serialize(const char*) const; + void Unserialize(const char*); - TagIterator GetTagsBegin() const; - TagIterator GetTagsEnd() const; + TagIterator GetTagsBegin() const; + TagIterator GetTagsEnd() const; private: - TagMap m_tags; + TagMap m_tags; }; diff --git a/Source/MailBox.cpp b/Source/MailBox.cpp index fb008f6ce..f70ce4cbe 100644 --- a/Source/MailBox.cpp +++ b/Source/MailBox.cpp @@ -26,7 +26,7 @@ void CMailBox::WaitForCall(unsigned int timeOut) void CMailBox::FlushCalls() { - SendCall([] () { }, true); + SendCall([]() {}, true); } void CMailBox::SendCall(const FunctionType& function, bool waitForCompletion) @@ -36,10 +36,10 @@ void CMailBox::SendCall(const FunctionType& function, bool waitForCompletion) { MESSAGE message; message.function = function; - message.sync = waitForCompletion; + message.sync = waitForCompletion; m_calls.push_back(std::move(message)); } - + m_waitCondition.notify_all(); if(waitForCompletion) @@ -65,14 +65,14 @@ void CMailBox::SendCall(const FunctionType& function, bool waitForCompletion) void CMailBox::SendCall(FunctionType&& function) { std::lock_guard callLock(m_callMutex); - + { MESSAGE message; message.function = std::move(function); - message.sync = false; + message.sync = false; m_calls.push_back(std::move(message)); } - + m_waitCondition.notify_all(); } diff --git a/Source/MailBox.h b/Source/MailBox.h index c201f9f02..038ac8603 100644 --- a/Source/MailBox.h +++ b/Source/MailBox.h @@ -8,18 +8,18 @@ class CMailBox { public: - virtual ~CMailBox() = default; + virtual ~CMailBox() = default; - typedef std::function FunctionType; + typedef std::function FunctionType; - void SendCall(const FunctionType&, bool = false); - void SendCall(FunctionType&&); - void FlushCalls(); + void SendCall(const FunctionType&, bool = false); + void SendCall(FunctionType&&); + void FlushCalls(); - bool IsPending() const; - void ReceiveCall(); - void WaitForCall(); - void WaitForCall(unsigned int); + bool IsPending() const; + void ReceiveCall(); + void WaitForCall(); + void WaitForCall(unsigned int); private: struct MESSAGE @@ -29,18 +29,18 @@ private: MESSAGE(MESSAGE&&) = default; MESSAGE(const MESSAGE&) = delete; - MESSAGE& operator =(MESSAGE&&) = default; - MESSAGE& operator =(const MESSAGE&) = delete; + MESSAGE& operator=(MESSAGE&&) = default; + MESSAGE& operator=(const MESSAGE&) = delete; - FunctionType function; - bool sync; + FunctionType function; + bool sync; }; typedef std::deque FunctionCallQueue; - FunctionCallQueue m_calls; - std::mutex m_callMutex; - std::condition_variable m_callFinished; - std::condition_variable m_waitCondition; - bool m_callDone; + FunctionCallQueue m_calls; + std::mutex m_callMutex; + std::condition_variable m_callFinished; + std::condition_variable m_waitCondition; + bool m_callDone; }; diff --git a/Source/MemoryMap.cpp b/Source/MemoryMap.cpp index 35840abe6..1c8d25843 100644 --- a/Source/MemoryMap.cpp +++ b/Source/MemoryMap.cpp @@ -47,21 +47,21 @@ const CMemoryMap::MEMORYMAPELEMENT* CMemoryMap::GetWriteMap(uint32 address) cons void CMemoryMap::InsertMap(MemoryMapListType& memoryMap, uint32 start, uint32 end, void* pointer, unsigned char key) { MEMORYMAPELEMENT element; - element.nStart = start; - element.nEnd = end; - element.pPointer = pointer; - element.nType = MEMORYMAP_TYPE_MEMORY; + element.nStart = start; + element.nEnd = end; + element.pPointer = pointer; + element.nType = MEMORYMAP_TYPE_MEMORY; memoryMap.push_back(element); } void CMemoryMap::InsertMap(MemoryMapListType& memoryMap, uint32 start, uint32 end, const MemoryMapHandlerType& handler, unsigned char key) { MEMORYMAPELEMENT element; - element.nStart = start; - element.nEnd = end; - element.handler = handler; - element.pPointer = nullptr; - element.nType = MEMORYMAP_TYPE_FUNCTION; + element.nStart = start; + element.nEnd = end; + element.handler = handler; + element.pPointer = nullptr; + element.nType = MEMORYMAP_TYPE_FUNCTION; memoryMap.push_back(element); } diff --git a/Source/MemoryMap.h b/Source/MemoryMap.h index 3c134d1e4..619f339b5 100644 --- a/Source/MemoryMap.h +++ b/Source/MemoryMap.h @@ -14,7 +14,7 @@ enum MEMORYMAP_ENDIANESS class CMemoryMap { public: - typedef std::function MemoryMapHandlerType; + typedef std::function MemoryMapHandlerType; enum MEMORYMAP_TYPE { @@ -24,51 +24,51 @@ public: struct MEMORYMAPELEMENT { - uint32 nStart; - uint32 nEnd; - void* pPointer; - MemoryMapHandlerType handler; - MEMORYMAP_TYPE nType; + uint32 nStart; + uint32 nEnd; + void* pPointer; + MemoryMapHandlerType handler; + MEMORYMAP_TYPE nType; }; - virtual ~CMemoryMap() = default; - uint8 GetByte(uint32); - virtual uint16 GetHalf(uint32) = 0; - virtual uint32 GetWord(uint32) = 0; - virtual uint32 GetInstruction(uint32) = 0; - virtual void SetByte(uint32, uint8); - virtual void SetHalf(uint32, uint16) = 0; - virtual void SetWord(uint32, uint32) = 0; - void InsertReadMap(uint32, uint32, void*, unsigned char); - void InsertReadMap(uint32, uint32, const MemoryMapHandlerType&, unsigned char); - void InsertWriteMap(uint32, uint32, void*, unsigned char); - void InsertWriteMap(uint32, uint32, const MemoryMapHandlerType&, unsigned char); - void InsertInstructionMap(uint32, uint32, void*, unsigned char); - const MEMORYMAPELEMENT* GetReadMap(uint32) const; - const MEMORYMAPELEMENT* GetWriteMap(uint32) const; + virtual ~CMemoryMap() = default; + uint8 GetByte(uint32); + virtual uint16 GetHalf(uint32) = 0; + virtual uint32 GetWord(uint32) = 0; + virtual uint32 GetInstruction(uint32) = 0; + virtual void SetByte(uint32, uint8); + virtual void SetHalf(uint32, uint16) = 0; + virtual void SetWord(uint32, uint32) = 0; + void InsertReadMap(uint32, uint32, void*, unsigned char); + void InsertReadMap(uint32, uint32, const MemoryMapHandlerType&, unsigned char); + void InsertWriteMap(uint32, uint32, void*, unsigned char); + void InsertWriteMap(uint32, uint32, const MemoryMapHandlerType&, unsigned char); + void InsertInstructionMap(uint32, uint32, void*, unsigned char); + const MEMORYMAPELEMENT* GetReadMap(uint32) const; + const MEMORYMAPELEMENT* GetWriteMap(uint32) const; protected: typedef std::vector MemoryMapListType; - static const MEMORYMAPELEMENT* GetMap(const MemoryMapListType&, uint32); + static const MEMORYMAPELEMENT* GetMap(const MemoryMapListType&, uint32); - MemoryMapListType m_instructionMap; - MemoryMapListType m_readMap; - MemoryMapListType m_writeMap; + MemoryMapListType m_instructionMap; + MemoryMapListType m_readMap; + MemoryMapListType m_writeMap; private: - static void InsertMap(MemoryMapListType&, uint32, uint32, void*, unsigned char); - static void InsertMap(MemoryMapListType&, uint32, uint32, const MemoryMapHandlerType&, unsigned char); + static void InsertMap(MemoryMapListType&, uint32, uint32, void*, unsigned char); + static void InsertMap(MemoryMapListType&, uint32, uint32, const MemoryMapHandlerType&, unsigned char); }; class CMemoryMap_LSBF : public CMemoryMap { public: - uint16 GetHalf(uint32); - uint32 GetWord(uint32); - uint32 GetInstruction(uint32); - void SetHalf(uint32, uint16); - void SetWord(uint32, uint32); + uint16 GetHalf(uint32); + uint32 GetWord(uint32); + uint32 GetInstruction(uint32); + void SetHalf(uint32, uint16); + void SetWord(uint32, uint32); }; #endif diff --git a/Source/MemoryStateFile.cpp b/Source/MemoryStateFile.cpp index a2a6a2b52..c940a8e3b 100644 --- a/Source/MemoryStateFile.cpp +++ b/Source/MemoryStateFile.cpp @@ -1,11 +1,10 @@ #include "MemoryStateFile.h" -CMemoryStateFile::CMemoryStateFile(const char* name, const void* memory, size_t size) -: CZipFile(name) -, m_memory(memory) -, m_size(size) +CMemoryStateFile::CMemoryStateFile(const char* name, const void* memory, size_t size) + : CZipFile(name) + , m_memory(memory) + , m_size(size) { - } void CMemoryStateFile::Write(Framework::CStream& stream) diff --git a/Source/MemoryStateFile.h b/Source/MemoryStateFile.h index d806aee97..2967d8c6f 100644 --- a/Source/MemoryStateFile.h +++ b/Source/MemoryStateFile.h @@ -5,12 +5,12 @@ class CMemoryStateFile : public Framework::CZipFile { public: - CMemoryStateFile(const char*, const void*, size_t); - virtual ~CMemoryStateFile() = default; + CMemoryStateFile(const char*, const void*, size_t); + virtual ~CMemoryStateFile() = default; - void Write(Framework::CStream&) override; + void Write(Framework::CStream&) override; private: - const void* m_memory = nullptr; - size_t m_size = 0; + const void* m_memory = nullptr; + size_t m_size = 0; }; diff --git a/Source/MemoryUtils.cpp b/Source/MemoryUtils.cpp index 558d2bc29..6891140d1 100644 --- a/Source/MemoryUtils.cpp +++ b/Source/MemoryUtils.cpp @@ -101,7 +101,7 @@ void MemoryUtils_SetDoubleProxy(CMIPS* context, uint64 value64, uint32 address) if(!e) { CLog::GetInstance().Print(LOG_NAME, "Wrote to unmapped memory (0x%08X, [0x%08X, 0x%08X]).\r\n", - address, value.d0, value.d1); + address, value.d0, value.d1); return; } switch(e->nType) @@ -127,8 +127,8 @@ void MemoryUtils_SetQuadProxy(CMIPS* context, const uint128& value, uint32 addre auto e = context->m_pMemoryMap->GetWriteMap(address); if(!e) { - CLog::GetInstance().Print(LOG_NAME, "Wrote to unmapped memory (0x%08X, [0x%08X, 0x%08X, 0x%08X, 0x%08X]).\r\n", - address, value.nV0, value.nV1, value.nV2, value.nV3); + CLog::GetInstance().Print(LOG_NAME, "Wrote to unmapped memory (0x%08X, [0x%08X, 0x%08X, 0x%08X, 0x%08X]).\r\n", + address, value.nV0, value.nV1, value.nV2, value.nV3); return; } switch(e->nType) diff --git a/Source/MemoryUtils.h b/Source/MemoryUtils.h index fa0579504..bb50e605c 100644 --- a/Source/MemoryUtils.h +++ b/Source/MemoryUtils.h @@ -4,15 +4,15 @@ extern "C" { - uint32 MemoryUtils_GetByteProxy(CMIPS*, uint32); - uint32 MemoryUtils_GetHalfProxy(CMIPS*, uint32); - uint32 MemoryUtils_GetWordProxy(CMIPS*, uint32); - uint64 MemoryUtils_GetDoubleProxy(CMIPS*, uint32); - uint128 MemoryUtils_GetQuadProxy(CMIPS*, uint32); + uint32 MemoryUtils_GetByteProxy(CMIPS*, uint32); + uint32 MemoryUtils_GetHalfProxy(CMIPS*, uint32); + uint32 MemoryUtils_GetWordProxy(CMIPS*, uint32); + uint64 MemoryUtils_GetDoubleProxy(CMIPS*, uint32); + uint128 MemoryUtils_GetQuadProxy(CMIPS*, uint32); - void MemoryUtils_SetByteProxy(CMIPS*, uint32, uint32); - void MemoryUtils_SetHalfProxy(CMIPS*, uint32, uint32); - void MemoryUtils_SetWordProxy(CMIPS*, uint32, uint32); - void MemoryUtils_SetDoubleProxy(CMIPS*, uint64, uint32); - void MemoryUtils_SetQuadProxy(CMIPS*, const uint128&, uint32); + void MemoryUtils_SetByteProxy(CMIPS*, uint32, uint32); + void MemoryUtils_SetHalfProxy(CMIPS*, uint32, uint32); + void MemoryUtils_SetWordProxy(CMIPS*, uint32, uint32); + void MemoryUtils_SetDoubleProxy(CMIPS*, uint64, uint32); + void MemoryUtils_SetQuadProxy(CMIPS*, const uint128&, uint32); } diff --git a/Source/MipsExecutor.cpp b/Source/MipsExecutor.cpp index 7d3c7a5d8..96c94be35 100644 --- a/Source/MipsExecutor.cpp +++ b/Source/MipsExecutor.cpp @@ -10,8 +10,8 @@ static bool IsInsideRange(uint32 address, uint32 start, uint32 end) #define SUBTABLE_MASK (SUBTABLE_SIZE - 1) CMipsExecutor::CMipsExecutor(CMIPS& context, uint32 maxAddress) -: m_context(context) -, m_maxAddress(maxAddress) + : m_context(context) + , m_maxAddress(maxAddress) { m_subTableCount = (m_maxAddress + SUBTABLE_MASK) / SUBTABLE_SIZE; assert(m_subTableCount != 0); @@ -26,10 +26,10 @@ CMipsExecutor::~CMipsExecutor() CBasicBlock** subTable = m_blockTable[i]; if(subTable != NULL) { - delete [] subTable; + delete[] subTable; } } - delete [] m_blockTable; + delete[] m_blockTable; } void CMipsExecutor::Reset() @@ -44,11 +44,11 @@ void CMipsExecutor::ClearActiveBlocks() CBasicBlock** subTable = m_blockTable[i]; if(subTable != NULL) { - delete [] subTable; + delete[] subTable; m_blockTable[i] = NULL; } } - + m_blocks.clear(); } @@ -80,8 +80,7 @@ void CMipsExecutor::ClearActiveBlocksInRangeInternal(uint32 start, uint32 end, C auto block = table[lo / 4]; if(block == nullptr) continue; if(block == protectedBlock) continue; - if(!IsInsideRange(block->GetBeginAddress(), start, end) - && !IsInsideRange(block->GetEndAddress(), start, end)) continue; + if(!IsInsideRange(block->GetBeginAddress(), start, end) && !IsInsideRange(block->GetEndAddress(), start, end)) continue; table[lo / 4] = nullptr; blocksToDelete.insert(block); } @@ -89,7 +88,7 @@ void CMipsExecutor::ClearActiveBlocksInRangeInternal(uint32 start, uint32 end, C if(!blocksToDelete.empty()) { - m_blocks.remove_if([&] (const BasicBlockPtr& block) { return blocksToDelete.find(block.get()) != std::end(blocksToDelete); }); + m_blocks.remove_if([&](const BasicBlockPtr& block) { return blocksToDelete.find(block.get()) != std::end(blocksToDelete); }); } } @@ -214,7 +213,7 @@ void CMipsExecutor::DeleteBlock(CBasicBlock* block) } //Remove block from our lists - auto blockIterator = std::find_if(std::begin(m_blocks), std::end(m_blocks), [&] (const BasicBlockPtr& blockPtr) { return blockPtr.get() == block; }); + auto blockIterator = std::find_if(std::begin(m_blocks), std::end(m_blocks), [&](const BasicBlockPtr& blockPtr) { return blockPtr.get() == block; }); assert(blockIterator != std::end(m_blocks)); m_blocks.erase(blockIterator); } @@ -236,7 +235,7 @@ void CMipsExecutor::PartitionFunction(uint32 functionAddress) partitionPoints.insert(functionAddress); //Find the end - for(uint32 address = functionAddress; ; address += 4) + for(uint32 address = functionAddress;; address += 4) { //Probably going too far... if((address - functionAddress) > 0x10000) @@ -292,7 +291,7 @@ void CMipsExecutor::PartitionFunction(uint32 functionAddress) { uint32 currentPoint = -1; for(PartitionPointSet::const_iterator pointIterator(partitionPoints.begin()); - pointIterator != partitionPoints.end(); ++pointIterator) + pointIterator != partitionPoints.end(); ++pointIterator) { if(currentPoint != -1) { diff --git a/Source/MipsExecutor.h b/Source/MipsExecutor.h index e6b4706db..c01d63550 100644 --- a/Source/MipsExecutor.h +++ b/Source/MipsExecutor.h @@ -7,8 +7,8 @@ class CMipsExecutor { public: - CMipsExecutor(CMIPS&, uint32); - virtual ~CMipsExecutor(); + CMipsExecutor(CMIPS&, uint32); + virtual ~CMipsExecutor(); template int Execute(int cycles) @@ -40,36 +40,36 @@ public: return cycles; } - CBasicBlock* FindBlockAt(uint32) const; - CBasicBlock* FindBlockStartingAt(uint32) const; - void DeleteBlock(CBasicBlock*); - virtual void Reset(); - void ClearActiveBlocks(); - virtual void ClearActiveBlocksInRange(uint32, uint32); + CBasicBlock* FindBlockAt(uint32) const; + CBasicBlock* FindBlockStartingAt(uint32) const; + void DeleteBlock(CBasicBlock*); + virtual void Reset(); + void ClearActiveBlocks(); + virtual void ClearActiveBlocksInRange(uint32, uint32); #ifdef DEBUGGER_INCLUDED - bool MustBreak() const; - void DisableBreakpointsOnce(); + bool MustBreak() const; + void DisableBreakpointsOnce(); #endif protected: typedef std::shared_ptr BasicBlockPtr; typedef std::list BlockList; - void CreateBlock(uint32, uint32); - virtual BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32); - virtual void PartitionFunction(uint32); - - void ClearActiveBlocksInRangeInternal(uint32, uint32, CBasicBlock*); + void CreateBlock(uint32, uint32); + virtual BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32); + virtual void PartitionFunction(uint32); - BlockList m_blocks; - CMIPS& m_context; - uint32 m_maxAddress = 0; + void ClearActiveBlocksInRangeInternal(uint32, uint32, CBasicBlock*); - CBasicBlock*** m_blockTable = nullptr; - uint32 m_subTableCount = 0; + BlockList m_blocks; + CMIPS& m_context; + uint32 m_maxAddress = 0; + + CBasicBlock*** m_blockTable = nullptr; + uint32 m_subTableCount = 0; #ifdef DEBUGGER_INCLUDED - bool m_breakpointsDisabledOnce = false; + bool m_breakpointsDisabledOnce = false; #endif }; diff --git a/Source/MipsFunctionPatternDb.cpp b/Source/MipsFunctionPatternDb.cpp index 556e13a59..1b2bfa842 100644 --- a/Source/MipsFunctionPatternDb.cpp +++ b/Source/MipsFunctionPatternDb.cpp @@ -9,7 +9,6 @@ CMipsFunctionPatternDb::CMipsFunctionPatternDb(Framework::Xml::CNode* node) CMipsFunctionPatternDb::~CMipsFunctionPatternDb() { - } const CMipsFunctionPatternDb::PatternArray& CMipsFunctionPatternDb::GetPatterns() const @@ -24,8 +23,8 @@ void CMipsFunctionPatternDb::Read(Framework::Xml::CNode* node) m_patterns.reserve(patternsNode->GetChildCount()); - for(Framework::Xml::CFilteringNodeIterator patternNodeIterator(patternsNode, "FunctionPattern"); - !patternNodeIterator.IsEnd(); patternNodeIterator++) + for(Framework::Xml::CFilteringNodeIterator patternNodeIterator(patternsNode, "FunctionPattern"); + !patternNodeIterator.IsEnd(); patternNodeIterator++) { auto patternNode = (*patternNodeIterator); @@ -33,7 +32,7 @@ void CMipsFunctionPatternDb::Read(Framework::Xml::CNode* node) if(patternName == NULL) continue; const char* patternSource = patternNode->GetInnerText(); - + Pattern pattern = ParsePattern(patternSource); pattern.name = patternName; m_patterns.push_back(pattern); @@ -69,7 +68,7 @@ CMipsFunctionPatternDb::Pattern CMipsFunctionPatternDb::ParsePattern(const char* if(currValue.length() != 0) { //Parse value - PATTERNITEM item = { 0 }; + PATTERNITEM item = {0}; if(ParsePatternItem(currValue.c_str(), item)) { result.items.push_back(item); diff --git a/Source/MipsFunctionPatternDb.h b/Source/MipsFunctionPatternDb.h index 3957ba349..bf4826ba1 100644 --- a/Source/MipsFunctionPatternDb.h +++ b/Source/MipsFunctionPatternDb.h @@ -11,8 +11,8 @@ class CMipsFunctionPatternDb public: struct PATTERNITEM { - uint32 value; - uint32 mask; + uint32 value; + uint32 mask; }; class Pattern @@ -20,26 +20,25 @@ public: public: typedef std::vector ItemArray; - bool Matches(uint32*, uint32) const; + bool Matches(uint32*, uint32) const; - std::string name; - ItemArray items; + std::string name; + ItemArray items; }; - typedef std::vector PatternArray; - CMipsFunctionPatternDb(Framework::Xml::CNode*); - virtual ~CMipsFunctionPatternDb(); + CMipsFunctionPatternDb(Framework::Xml::CNode*); + virtual ~CMipsFunctionPatternDb(); - const PatternArray& GetPatterns() const; + const PatternArray& GetPatterns() const; private: - void Read(Framework::Xml::CNode*); - Pattern ParsePattern(const char*); - bool ParsePatternItem(const char*, PATTERNITEM&); + void Read(Framework::Xml::CNode*); + Pattern ParsePattern(const char*); + bool ParsePatternItem(const char*, PATTERNITEM&); - PatternArray m_patterns; + PatternArray m_patterns; }; #endif diff --git a/Source/MipsJitter.cpp b/Source/MipsJitter.cpp index 5e24bd8ec..4e07a3264 100644 --- a/Source/MipsJitter.cpp +++ b/Source/MipsJitter.cpp @@ -2,15 +2,13 @@ #include "MipsJitter.h" CMipsJitter::CMipsJitter(Jitter::CCodeGen* codeGen) -: CJitter(codeGen) -, m_lastBlockLabel(-1) + : CJitter(codeGen) + , m_lastBlockLabel(-1) { - } CMipsJitter::~CMipsJitter() { - } void CMipsJitter::Begin() diff --git a/Source/MipsJitter.h b/Source/MipsJitter.h index 6e9b99dae..d14ae8ad3 100644 --- a/Source/MipsJitter.h +++ b/Source/MipsJitter.h @@ -6,30 +6,30 @@ class CMipsJitter : public Jitter::CJitter { public: - CMipsJitter(Jitter::CCodeGen*); - virtual ~CMipsJitter(); + CMipsJitter(Jitter::CCodeGen*); + virtual ~CMipsJitter(); - virtual void Begin(); - virtual void End(); - virtual void PushRel(size_t); - virtual void PushRel64(size_t); + virtual void Begin(); + virtual void End(); + virtual void PushRel(size_t); + virtual void PushRel64(size_t); - void SetVariableAsConstant(size_t, uint32); - LABEL GetFinalBlockLabel(); + void SetVariableAsConstant(size_t, uint32); + LABEL GetFinalBlockLabel(); private: struct VARIABLESTATUS { - uint32 operandType; - uint32 operandValue; + uint32 operandType; + uint32 operandValue; }; typedef std::map VariableStatusMap; - VARIABLESTATUS* GetVariableStatus(size_t); - void SetVariableStatus(size_t, const VARIABLESTATUS&); - void SaveVariableStatus(size_t, const VARIABLESTATUS&); + VARIABLESTATUS* GetVariableStatus(size_t); + void SetVariableStatus(size_t, const VARIABLESTATUS&); + void SaveVariableStatus(size_t, const VARIABLESTATUS&); - VariableStatusMap m_variableStatus; - LABEL m_lastBlockLabel; + VariableStatusMap m_variableStatus; + LABEL m_lastBlockLabel; }; diff --git a/Source/OpticalMedia.cpp b/Source/OpticalMedia.cpp index 283cc7c6d..3ba4d4f4d 100644 --- a/Source/OpticalMedia.cpp +++ b/Source/OpticalMedia.cpp @@ -81,9 +81,8 @@ void COpticalMedia::CheckDualLayerDvd(const StreamPtr& stream) char blockHeader[blockHeaderSize]; stream->Read(blockHeader, blockHeaderSize); if( - (blockHeader[0] == 0x01) && - (!strncmp(blockHeader + 1, "CD001", 5)) - ) + (blockHeader[0] == 0x01) && + (!strncmp(blockHeader + 1, "CD001", 5))) { //We've found a valid ISO9660 descriptor m_dvdSecondLayerStart = lba; diff --git a/Source/OpticalMedia.h b/Source/OpticalMedia.h index 1bd45900c..229690533 100644 --- a/Source/OpticalMedia.h +++ b/Source/OpticalMedia.h @@ -18,19 +18,19 @@ public: COpticalMedia(const StreamPtr&); //TODO: Get Track Count - TRACK_DATA_TYPE GetTrackDataType(uint32) const; - CISO9660* GetFileSystem(); + TRACK_DATA_TYPE GetTrackDataType(uint32) const; + CISO9660* GetFileSystem(); - bool GetDvdIsDualLayer() const; - uint32 GetDvdSecondLayerStart() const; + bool GetDvdIsDualLayer() const; + uint32 GetDvdSecondLayerStart() const; private: typedef std::unique_ptr Iso9660Ptr; - void CheckDualLayerDvd(const StreamPtr&); + void CheckDualLayerDvd(const StreamPtr&); TRACK_DATA_TYPE m_track0DataType = TRACK_DATA_TYPE_MODE1_2048; - bool m_dvdIsDualLayer = false; - uint32 m_dvdSecondLayerStart = 0; - Iso9660Ptr m_fileSystem; + bool m_dvdIsDualLayer = false; + uint32 m_dvdSecondLayerStart = 0; + Iso9660Ptr m_fileSystem; }; diff --git a/Source/OsStructManager.h b/Source/OsStructManager.h index 4c1093a9f..7e9e2d0e0 100644 --- a/Source/OsStructManager.h +++ b/Source/OsStructManager.h @@ -1,34 +1,38 @@ #pragma once #include -template +template class COsStructManager { public: class iterator { public: - iterator(const COsStructManager& container, uint32 id) : m_container(container), m_id(id) {} + iterator(const COsStructManager& container, uint32 id) + : m_container(container) + , m_id(id) + { + } - iterator& operator ++() + iterator& operator++() { m_id++; return (*this); } - iterator operator ++(int) + iterator operator++(int) { iterator copy(*this); m_id++; return copy; } - bool operator !=(const iterator& rhs) const + bool operator!=(const iterator& rhs) const { return m_id != rhs.m_id; } - StructType* operator *() const + StructType* operator*() const { return m_container[m_id]; } @@ -49,22 +53,22 @@ public: }; COsStructManager(StructType* structBase, uint32 idBase, uint32 structMax) - : m_structBase(structBase) - , m_structMax(structMax) - , m_idBase(idBase) + : m_structBase(structBase) + , m_structMax(structMax) + , m_idBase(idBase) { assert(m_idBase != 0); } COsStructManager(const COsStructManager&) = delete; - COsStructManager& operator =(const COsStructManager) = delete; + COsStructManager& operator=(const COsStructManager) = delete; StructType* GetBase() const { return m_structBase; } - StructType* operator [](uint32 index) const + StructType* operator[](uint32 index) const { index -= m_idBase; if(index >= m_structMax) @@ -121,7 +125,7 @@ public: } private: - StructType* m_structBase = nullptr; - uint32 m_structMax = 0; - uint32 m_idBase = 0; + StructType* m_structBase = nullptr; + uint32 m_structMax = 0; + uint32 m_idBase = 0; }; diff --git a/Source/OsStructQueue.h b/Source/OsStructQueue.h index f46563e3b..c3c045524 100644 --- a/Source/OsStructQueue.h +++ b/Source/OsStructQueue.h @@ -9,27 +9,31 @@ public: class iterator { public: - iterator(const StructManager& container, uint32* idPtr) : m_container(container), m_idPtr(idPtr) {} + iterator(const StructManager& container, uint32* idPtr) + : m_container(container) + , m_idPtr(idPtr) + { + } - iterator& operator ++() + iterator& operator++() { MoveNext(); return (*this); } - iterator operator ++(int) + iterator operator++(int) { iterator copy(*this); MoveNext(); return copy; } - bool operator !=(const iterator& rhs) const + bool operator!=(const iterator& rhs) const { return m_idPtr != rhs.m_idPtr; } - std::pair operator *() const + std::pair operator*() const { assert(m_idPtr); return std::make_pair(*m_idPtr, m_container[*m_idPtr]); @@ -52,14 +56,13 @@ public: }; COsStructQueue(StructManager& items, uint32* headIdPtr) - : m_items(items) - , m_headIdPtr(headIdPtr) + : m_items(items) + , m_headIdPtr(headIdPtr) { - } COsStructQueue(const COsStructQueue&) = delete; - COsStructQueue& operator =(const COsStructQueue) = delete; + COsStructQueue& operator=(const COsStructQueue) = delete; bool IsEmpty() const { @@ -142,6 +145,6 @@ public: } private: - StructManager& m_items; - uint32* m_headIdPtr = nullptr; + StructManager& m_items; + uint32* m_headIdPtr = nullptr; }; diff --git a/Source/OsVariableWrapper.h b/Source/OsVariableWrapper.h index ae6723f68..7d5dcd485 100644 --- a/Source/OsVariableWrapper.h +++ b/Source/OsVariableWrapper.h @@ -4,18 +4,21 @@ template struct OsVariableWrapper { public: - explicit OsVariableWrapper(Type* storage) : m_storage(storage) { } + explicit OsVariableWrapper(Type* storage) + : m_storage(storage) + { + } OsVariableWrapper(const OsVariableWrapper&) = delete; - OsVariableWrapper& operator =(const OsVariableWrapper&) = delete; + OsVariableWrapper& operator=(const OsVariableWrapper&) = delete; - OsVariableWrapper& operator =(const Type& value) + OsVariableWrapper& operator=(const Type& value) { (*m_storage) = value; return (*this); } - Type& operator +=(const Type& addend) + Type& operator+=(const Type& addend) { (*m_storage) += addend; return (*m_storage); @@ -32,5 +35,5 @@ public: } private: - Type* m_storage; + Type* m_storage; }; diff --git a/Source/PH_Generic.cpp b/Source/PH_Generic.cpp index d4e273739..693a9df47 100644 --- a/Source/PH_Generic.cpp +++ b/Source/PH_Generic.cpp @@ -10,12 +10,11 @@ CPH_Generic::CPH_Generic() CPH_Generic::~CPH_Generic() { - } CPadHandler::FactoryFunction CPH_Generic::GetFactoryFunction() { - return [] () { return new CPH_Generic(); }; + return []() { return new CPH_Generic(); }; } void CPH_Generic::Update(uint8* ram) diff --git a/Source/PH_Generic.h b/Source/PH_Generic.h index aa0313637..025af450d 100644 --- a/Source/PH_Generic.h +++ b/Source/PH_Generic.h @@ -5,17 +5,17 @@ class CPH_Generic : public CPadHandler { public: - CPH_Generic(); - virtual ~CPH_Generic(); - - static FactoryFunction GetFactoryFunction(); + CPH_Generic(); + virtual ~CPH_Generic(); - void Update(uint8*) override; + static FactoryFunction GetFactoryFunction(); + + void Update(uint8*) override; + + void SetButtonState(uint32, bool); + void SetAxisState(uint32, float); - void SetButtonState(uint32, bool); - void SetAxisState(uint32, float); - private: - bool m_buttonStates[PS2::CControllerInfo::MAX_BUTTONS]; - float m_axisStates[PS2::CControllerInfo::MAX_BUTTONS]; + bool m_buttonStates[PS2::CControllerInfo::MAX_BUTTONS]; + float m_axisStates[PS2::CControllerInfo::MAX_BUTTONS]; }; diff --git a/Source/PS2VM.cpp b/Source/PS2VM.cpp index c3d001c86..aa4cddfa4 100644 --- a/Source/PS2VM.cpp +++ b/Source/PS2VM.cpp @@ -28,43 +28,43 @@ #include "ISO9660/BlockProvider.h" #include "DiskUtils.h" -#define LOG_NAME ("ps2vm") +#define LOG_NAME ("ps2vm") -#define PREF_PS2_HOST_DIRECTORY_DEFAULT ("vfs/host") -#define PREF_PS2_MC0_DIRECTORY_DEFAULT ("vfs/mc0") -#define PREF_PS2_MC1_DIRECTORY_DEFAULT ("vfs/mc1") +#define PREF_PS2_HOST_DIRECTORY_DEFAULT ("vfs/host") +#define PREF_PS2_MC0_DIRECTORY_DEFAULT ("vfs/mc0") +#define PREF_PS2_MC1_DIRECTORY_DEFAULT ("vfs/mc1") -#define FRAME_TICKS (PS2::EE_CLOCK_FREQ / 60) -#define ONSCREEN_TICKS (FRAME_TICKS * 9 / 10) -#define VBLANK_TICKS (FRAME_TICKS / 10) +#define FRAME_TICKS (PS2::EE_CLOCK_FREQ / 60) +#define ONSCREEN_TICKS (FRAME_TICKS * 9 / 10) +#define VBLANK_TICKS (FRAME_TICKS / 10) namespace filesystem = boost::filesystem; CPS2VM::CPS2VM() -: m_nStatus(PAUSED) -, m_nEnd(false) -, m_pad(NULL) -, m_singleStepEe(false) -, m_singleStepIop(false) -, m_singleStepVu0(false) -, m_singleStepVu1(false) -, m_vblankTicks(0) -, m_inVblank(false) -, m_eeExecutionTicks(0) -, m_iopExecutionTicks(0) -, m_spuUpdateTicks(SPU_UPDATE_TICKS) -, m_eeProfilerZone(CProfiler::GetInstance().RegisterZone("EE")) -, m_iopProfilerZone(CProfiler::GetInstance().RegisterZone("IOP")) -, m_spuProfilerZone(CProfiler::GetInstance().RegisterZone("SPU")) -, m_gsSyncProfilerZone(CProfiler::GetInstance().RegisterZone("GSSYNC")) -, m_otherProfilerZone(CProfiler::GetInstance().RegisterZone("OTHER")) + : m_nStatus(PAUSED) + , m_nEnd(false) + , m_pad(NULL) + , m_singleStepEe(false) + , m_singleStepIop(false) + , m_singleStepVu0(false) + , m_singleStepVu1(false) + , m_vblankTicks(0) + , m_inVblank(false) + , m_eeExecutionTicks(0) + , m_iopExecutionTicks(0) + , m_spuUpdateTicks(SPU_UPDATE_TICKS) + , m_eeProfilerZone(CProfiler::GetInstance().RegisterZone("EE")) + , m_iopProfilerZone(CProfiler::GetInstance().RegisterZone("IOP")) + , m_spuProfilerZone(CProfiler::GetInstance().RegisterZone("SPU")) + , m_gsSyncProfilerZone(CProfiler::GetInstance().RegisterZone("GSSYNC")) + , m_otherProfilerZone(CProfiler::GetInstance().RegisterZone("OTHER")) { static const std::pair basicDirectorySettings[] = - { - std::make_pair(PREF_PS2_HOST_DIRECTORY, PREF_PS2_HOST_DIRECTORY_DEFAULT), - std::make_pair(PREF_PS2_MC0_DIRECTORY, PREF_PS2_MC0_DIRECTORY_DEFAULT), - std::make_pair(PREF_PS2_MC1_DIRECTORY, PREF_PS2_MC1_DIRECTORY_DEFAULT), - }; + { + std::make_pair(PREF_PS2_HOST_DIRECTORY, PREF_PS2_HOST_DIRECTORY_DEFAULT), + std::make_pair(PREF_PS2_MC0_DIRECTORY, PREF_PS2_MC0_DIRECTORY_DEFAULT), + std::make_pair(PREF_PS2_MC1_DIRECTORY, PREF_PS2_MC1_DIRECTORY_DEFAULT), + }; for(const auto& basicDirectorySetting : basicDirectorySettings) { @@ -75,7 +75,7 @@ CPS2VM::CPS2VM() Framework::PathUtils::EnsurePathExists(absolutePath); CAppConfig::GetInstance().RegisterPreferencePath(setting, absolutePath); } - + CAppConfig::GetInstance().RegisterPreferencePath(PREF_PS2_CDROM0_PATH, ""); m_iop = std::make_unique(true); @@ -101,7 +101,7 @@ CPS2VM::~CPS2VM() void CPS2VM::CreateGSHandler(const CGSHandler::FactoryFunction& factoryFunction) { if(m_ee->m_gs != nullptr) return; - m_mailBox.SendCall([this, factoryFunction] () { CreateGsHandlerImpl(factoryFunction); }, true); + m_mailBox.SendCall([this, factoryFunction]() { CreateGsHandlerImpl(factoryFunction); }, true); } CGSHandler* CPS2VM::GetGSHandler() @@ -112,13 +112,13 @@ CGSHandler* CPS2VM::GetGSHandler() void CPS2VM::DestroyGSHandler() { if(m_ee->m_gs == nullptr) return; - m_mailBox.SendCall([this] () { DestroyGsHandlerImpl(); }, true); + m_mailBox.SendCall([this]() { DestroyGsHandlerImpl(); }, true); } void CPS2VM::CreatePadHandler(const CPadHandler::FactoryFunction& factoryFunction) { if(m_pad != nullptr) return; - m_mailBox.SendCall([this, factoryFunction] () { CreatePadHandlerImpl(factoryFunction); }, true); + m_mailBox.SendCall([this, factoryFunction]() { CreatePadHandlerImpl(factoryFunction); }, true); } CPadHandler* CPS2VM::GetPadHandler() @@ -129,19 +129,19 @@ CPadHandler* CPS2VM::GetPadHandler() void CPS2VM::DestroyPadHandler() { if(m_pad == nullptr) return; - m_mailBox.SendCall([this] () { DestroyPadHandlerImpl(); }, true); + m_mailBox.SendCall([this]() { DestroyPadHandlerImpl(); }, true); } void CPS2VM::CreateSoundHandler(const CSoundHandler::FactoryFunction& factoryFunction) { if(m_soundHandler != nullptr) return; - m_mailBox.SendCall([this, factoryFunction] () { CreateSoundHandlerImpl(factoryFunction); }, true); + m_mailBox.SendCall([this, factoryFunction]() { CreateSoundHandlerImpl(factoryFunction); }, true); } void CPS2VM::DestroySoundHandler() { if(m_soundHandler == nullptr) return; - m_mailBox.SendCall([this] () { DestroySoundHandlerImpl(); }, true); + m_mailBox.SendCall([this]() { DestroySoundHandlerImpl(); }, true); } CVirtualMachine::STATUS CPS2VM::GetStatus() const @@ -200,14 +200,14 @@ void CPS2VM::Reset() void CPS2VM::DumpEEIntcHandlers() { -// if(m_pOS == NULL) return; + // if(m_pOS == NULL) return; if(m_nStatus != PAUSED) return; m_ee->m_os->DumpIntcHandlers(); } void CPS2VM::DumpEEDmacHandlers() { -// if(m_pOS == NULL) return; + // if(m_pOS == NULL) return; if(m_nStatus != PAUSED) return; m_ee->m_os->DumpDmacHandlers(); } @@ -216,7 +216,7 @@ void CPS2VM::Initialize() { CreateVM(); m_nEnd = false; - m_thread = std::thread([&] () { EmuThread(); }); + m_thread = std::thread([&]() { EmuThread(); }); } void CPS2VM::Destroy() @@ -242,12 +242,10 @@ std::future CPS2VM::SaveState(const filesystem::path& statePath) auto promise = std::make_shared>(); auto future = promise->get_future(); m_mailBox.SendCall( - [this, promise, statePath] () - { - auto result = SaveVMState(statePath); - promise->set_value(result); - } - ); + [this, promise, statePath]() { + auto result = SaveVMState(statePath); + promise->set_value(result); + }); return future; } @@ -256,26 +254,22 @@ std::future CPS2VM::LoadState(const filesystem::path& statePath) auto promise = std::make_shared>(); auto future = promise->get_future(); m_mailBox.SendCall( - [this, promise, statePath] () - { - auto result = LoadVMState(statePath); - promise->set_value(result); - } - ); + [this, promise, statePath]() { + auto result = LoadVMState(statePath); + promise->set_value(result); + }); return future; } void CPS2VM::TriggerFrameDump(const FrameDumpCallback& frameDumpCallback) { m_mailBox.SendCall( - [=] () - { - std::unique_lock frameDumpCallbackMutexLock(m_frameDumpCallbackMutex); - if(m_frameDumpCallback) return; - m_frameDumpCallback = frameDumpCallback; - }, - false - ); + [=]() { + std::unique_lock frameDumpCallbackMutexLock(m_frameDumpCallbackMutex); + if(m_frameDumpCallback) return; + m_frameDumpCallback = frameDumpCallback; + }, + false); } CPS2VM::CPU_UTILISATION_INFO CPS2VM::GetCpuUtilisationInfo() const @@ -285,16 +279,16 @@ CPS2VM::CPU_UTILISATION_INFO CPS2VM::GetCpuUtilisationInfo() const #ifdef DEBUGGER_INCLUDED -#define TAGS_SECTION_TAGS ("tags") -#define TAGS_SECTION_EE_FUNCTIONS ("ee_functions") -#define TAGS_SECTION_EE_COMMENTS ("ee_comments") -#define TAGS_SECTION_VU1_FUNCTIONS ("vu1_functions") -#define TAGS_SECTION_VU1_COMMENTS ("vu1_comments") -#define TAGS_SECTION_IOP ("iop") -#define TAGS_SECTION_IOP_FUNCTIONS ("functions") -#define TAGS_SECTION_IOP_COMMENTS ("comments") +#define TAGS_SECTION_TAGS ("tags") +#define TAGS_SECTION_EE_FUNCTIONS ("ee_functions") +#define TAGS_SECTION_EE_COMMENTS ("ee_comments") +#define TAGS_SECTION_VU1_FUNCTIONS ("vu1_functions") +#define TAGS_SECTION_VU1_COMMENTS ("vu1_comments") +#define TAGS_SECTION_IOP ("iop") +#define TAGS_SECTION_IOP_FUNCTIONS ("functions") +#define TAGS_SECTION_IOP_COMMENTS ("comments") -#define TAGS_PATH ("tags/") +#define TAGS_PATH ("tags/") std::string CPS2VM::MakeDebugTagsPackagePath(const char* packageName) { @@ -329,7 +323,6 @@ void CPS2VM::LoadDebugTags(const char* packageName) } catch(...) { - } } @@ -339,7 +332,7 @@ void CPS2VM::SaveDebugTags(const char* packageName) { std::string packagePath = MakeDebugTagsPackagePath(packageName); Framework::CStdStream stream(packagePath.c_str(), "wb"); - boost::scoped_ptr document(new Framework::Xml::CNode(TAGS_SECTION_TAGS, true)); + boost::scoped_ptr document(new Framework::Xml::CNode(TAGS_SECTION_TAGS, true)); m_ee->m_EE.m_Functions.Serialize(document.get(), TAGS_SECTION_EE_FUNCTIONS); m_ee->m_EE.m_Comments.Serialize(document.get(), TAGS_SECTION_EE_COMMENTS); m_ee->m_VU1.m_Functions.Serialize(document.get(), TAGS_SECTION_VU1_FUNCTIONS); @@ -355,7 +348,6 @@ void CPS2VM::SaveDebugTags(const char* packageName) } catch(...) { - } } @@ -452,7 +444,7 @@ bool CPS2VM::LoadVMState(const filesystem::path& statePath) { auto stateStream = Framework::CreateInputStdStream(statePath.native()); Framework::CZipArchiveReader archive(stateStream); - + try { m_ee->LoadState(archive); @@ -800,10 +792,10 @@ void CPS2VM::EmuThread() } #ifdef DEBUGGER_INCLUDED if( - m_ee->m_executor.MustBreak() || - m_iop->m_executor.MustBreak() || - m_ee->m_vpu1->MustBreak() || - m_singleStepEe || m_singleStepIop || m_singleStepVu0 || m_singleStepVu1) + m_ee->m_executor.MustBreak() || + m_iop->m_executor.MustBreak() || + m_ee->m_vpu1->MustBreak() || + m_singleStepEe || m_singleStepIop || m_singleStepVu0 || m_singleStepVu1) { m_nStatus = PAUSED; m_singleStepEe = false; diff --git a/Source/PS2VM.h b/Source/PS2VM.h index e4f90044a..2ac323f72 100644 --- a/Source/PS2VM.h +++ b/Source/PS2VM.h @@ -31,146 +31,146 @@ public: typedef std::unique_ptr EeSubSystemPtr; typedef std::unique_ptr IopSubSystemPtr; - typedef std::function FrameDumpCallback; - typedef boost::signals2::signal ProfileFrameDoneSignal; + typedef std::function FrameDumpCallback; + typedef boost::signals2::signal ProfileFrameDoneSignal; - CPS2VM(); - virtual ~CPS2VM(); + CPS2VM(); + virtual ~CPS2VM(); - void Initialize(); - void Destroy(); + void Initialize(); + void Destroy(); - void StepEe(); - void StepIop(); - void StepVu0(); - void StepVu1(); + void StepEe(); + void StepIop(); + void StepVu0(); + void StepVu1(); - void Resume() override; - void Pause() override; - void Reset(); + void Resume() override; + void Pause() override; + void Reset(); - STATUS GetStatus() const override; + STATUS GetStatus() const override; - void DumpEEIntcHandlers(); - void DumpEEDmacHandlers(); + void DumpEEIntcHandlers(); + void DumpEEDmacHandlers(); - void CreateGSHandler(const CGSHandler::FactoryFunction&); - CGSHandler* GetGSHandler(); - void DestroyGSHandler(); + void CreateGSHandler(const CGSHandler::FactoryFunction&); + CGSHandler* GetGSHandler(); + void DestroyGSHandler(); - void CreatePadHandler(const CPadHandler::FactoryFunction&); - CPadHandler* GetPadHandler(); - void DestroyPadHandler(); + void CreatePadHandler(const CPadHandler::FactoryFunction&); + CPadHandler* GetPadHandler(); + void DestroyPadHandler(); - void CreateSoundHandler(const CSoundHandler::FactoryFunction&); - void DestroySoundHandler(); + void CreateSoundHandler(const CSoundHandler::FactoryFunction&); + void DestroySoundHandler(); - static boost::filesystem::path GetStateDirectoryPath(); - boost::filesystem::path GenerateStatePath(unsigned int) const; + static boost::filesystem::path GetStateDirectoryPath(); + boost::filesystem::path GenerateStatePath(unsigned int) const; - std::future SaveState(const boost::filesystem::path&); - std::future LoadState(const boost::filesystem::path&); + std::future SaveState(const boost::filesystem::path&); + std::future LoadState(const boost::filesystem::path&); - void TriggerFrameDump(const FrameDumpCallback&); + void TriggerFrameDump(const FrameDumpCallback&); - CPU_UTILISATION_INFO GetCpuUtilisationInfo() const; + CPU_UTILISATION_INFO GetCpuUtilisationInfo() const; #ifdef DEBUGGER_INCLUDED - std::string MakeDebugTagsPackagePath(const char*); - void LoadDebugTags(const char*); - void SaveDebugTags(const char*); + std::string MakeDebugTagsPackagePath(const char*); + void LoadDebugTags(const char*); + void SaveDebugTags(const char*); #endif - CPadHandler* m_pad; + CPadHandler* m_pad; - EeSubSystemPtr m_ee; - IopSubSystemPtr m_iop; + EeSubSystemPtr m_ee; + IopSubSystemPtr m_iop; - IopBiosPtr m_iopOs; + IopBiosPtr m_iopOs; - ProfileFrameDoneSignal ProfileFrameDone; + ProfileFrameDoneSignal ProfileFrameDone; private: typedef std::unique_ptr OpticalMediaPtr; - void CreateVM(); - void ResetVM(); - void DestroyVM(); - bool SaveVMState(const boost::filesystem::path&); - bool LoadVMState(const boost::filesystem::path&); + void CreateVM(); + void ResetVM(); + void DestroyVM(); + bool SaveVMState(const boost::filesystem::path&); + bool LoadVMState(const boost::filesystem::path&); - void ReloadExecutable(const char*, const CPS2OS::ArgumentList&); + void ReloadExecutable(const char*, const CPS2OS::ArgumentList&); - void ResumeImpl(); - void PauseImpl(); - void DestroyImpl(); - - void CreateGsHandlerImpl(const CGSHandler::FactoryFunction&); - void DestroyGsHandlerImpl(); + void ResumeImpl(); + void PauseImpl(); + void DestroyImpl(); - void CreatePadHandlerImpl(const CPadHandler::FactoryFunction&); - void DestroyPadHandlerImpl(); - - void CreateSoundHandlerImpl(const CSoundHandler::FactoryFunction&); - void DestroySoundHandlerImpl(); + void CreateGsHandlerImpl(const CGSHandler::FactoryFunction&); + void DestroyGsHandlerImpl(); - void UpdateEe(); - void UpdateIop(); - void UpdateSpu(); + void CreatePadHandlerImpl(const CPadHandler::FactoryFunction&); + void DestroyPadHandlerImpl(); - void OnGsNewFrame(); + void CreateSoundHandlerImpl(const CSoundHandler::FactoryFunction&); + void DestroySoundHandlerImpl(); - void CDROM0_SyncPath(); - void CDROM0_Reset(); - void SetIopOpticalMedia(COpticalMedia*); + void UpdateEe(); + void UpdateIop(); + void UpdateSpu(); - void RegisterModulesInPadHandler(); + void OnGsNewFrame(); - void EmuThread(); + void CDROM0_SyncPath(); + void CDROM0_Reset(); + void SetIopOpticalMedia(COpticalMedia*); - std::thread m_thread; - CMailBox m_mailBox; - STATUS m_nStatus; - bool m_nEnd; + void RegisterModulesInPadHandler(); - int m_vblankTicks = 0; - bool m_inVblank = 0; - int m_spuUpdateTicks = 0; - int m_eeExecutionTicks = 0; - int m_iopExecutionTicks = 0; + void EmuThread(); - CPU_UTILISATION_INFO m_cpuUtilisation; + std::thread m_thread; + CMailBox m_mailBox; + STATUS m_nStatus; + bool m_nEnd; - bool m_singleStepEe; - bool m_singleStepIop; - bool m_singleStepVu0; - bool m_singleStepVu1; + int m_vblankTicks = 0; + bool m_inVblank = 0; + int m_spuUpdateTicks = 0; + int m_eeExecutionTicks = 0; + int m_iopExecutionTicks = 0; - CFrameDump m_frameDump; - FrameDumpCallback m_frameDumpCallback; - std::mutex m_frameDumpCallbackMutex; - bool m_dumpingFrame = false; + CPU_UTILISATION_INFO m_cpuUtilisation; - OpticalMediaPtr m_cdrom0; + bool m_singleStepEe; + bool m_singleStepIop; + bool m_singleStepVu0; + bool m_singleStepVu1; + + CFrameDump m_frameDump; + FrameDumpCallback m_frameDumpCallback; + std::mutex m_frameDumpCallbackMutex; + bool m_dumpingFrame = false; + + OpticalMediaPtr m_cdrom0; //SPU update parameters enum { DST_SAMPLE_RATE = 44100, - UPDATE_RATE = 1000, //Number of SPU updates per second (on PS2 time scale) + UPDATE_RATE = 1000, //Number of SPU updates per second (on PS2 time scale) SPU_UPDATE_TICKS = PS2::IOP_CLOCK_OVER_FREQ / UPDATE_RATE, SAMPLE_COUNT = DST_SAMPLE_RATE / UPDATE_RATE, BLOCK_SIZE = SAMPLE_COUNT * 2, BLOCK_COUNT = 400, }; - int16 m_samples[BLOCK_SIZE * BLOCK_COUNT]; - int m_currentSpuBlock = 0; - CSoundHandler* m_soundHandler = nullptr; + int16 m_samples[BLOCK_SIZE * BLOCK_COUNT]; + int m_currentSpuBlock = 0; + CSoundHandler* m_soundHandler = nullptr; - CProfiler::ZoneHandle m_eeProfilerZone = 0; - CProfiler::ZoneHandle m_iopProfilerZone = 0; - CProfiler::ZoneHandle m_spuProfilerZone = 0; - CProfiler::ZoneHandle m_gsSyncProfilerZone = 0; - CProfiler::ZoneHandle m_otherProfilerZone = 0; + CProfiler::ZoneHandle m_eeProfilerZone = 0; + CProfiler::ZoneHandle m_iopProfilerZone = 0; + CProfiler::ZoneHandle m_spuProfilerZone = 0; + CProfiler::ZoneHandle m_gsSyncProfilerZone = 0; + CProfiler::ZoneHandle m_otherProfilerZone = 0; }; diff --git a/Source/PS2VM_Preferences.h b/Source/PS2VM_Preferences.h index 775dfd999..4b3aa5a67 100644 --- a/Source/PS2VM_Preferences.h +++ b/Source/PS2VM_Preferences.h @@ -1,7 +1,7 @@ #pragma once -#define PREF_PS2_CDROM0_PATH ("ps2.cdrom0.path.v2") +#define PREF_PS2_CDROM0_PATH ("ps2.cdrom0.path.v2") -#define PREF_PS2_HOST_DIRECTORY ("ps2.host.directory.v2") -#define PREF_PS2_MC0_DIRECTORY ("ps2.mc0.directory.v2") -#define PREF_PS2_MC1_DIRECTORY ("ps2.mc1.directory.v2") +#define PREF_PS2_HOST_DIRECTORY ("ps2.host.directory.v2") +#define PREF_PS2_MC0_DIRECTORY ("ps2.mc0.directory.v2") +#define PREF_PS2_MC1_DIRECTORY ("ps2.mc1.directory.v2") diff --git a/Source/PadHandler.cpp b/Source/PadHandler.cpp index 4127267a3..7df56d319 100644 --- a/Source/PadHandler.cpp +++ b/Source/PadHandler.cpp @@ -2,12 +2,10 @@ CPadHandler::CPadHandler() { - } CPadHandler::~CPadHandler() { - } void CPadHandler::InsertListener(CPadListener* pListener) @@ -17,5 +15,5 @@ void CPadHandler::InsertListener(CPadListener* pListener) void CPadHandler::RemoveAllListeners() { - m_listeners.clear(); + m_listeners.clear(); } diff --git a/Source/PadHandler.h b/Source/PadHandler.h index 9ce8794b7..ae708a70d 100644 --- a/Source/PadHandler.h +++ b/Source/PadHandler.h @@ -8,17 +8,17 @@ class CPadHandler { public: - typedef std::function FactoryFunction; + typedef std::function FactoryFunction; - CPadHandler(); - virtual ~CPadHandler(); - virtual void Update(uint8*) = 0; - void InsertListener(CPadListener*); - void RemoveAllListeners(); + CPadHandler(); + virtual ~CPadHandler(); + virtual void Update(uint8*) = 0; + void InsertListener(CPadListener*); + void RemoveAllListeners(); protected: - typedef std::list ListenerList; - ListenerList m_listeners; + typedef std::list ListenerList; + ListenerList m_listeners; }; #endif diff --git a/Source/PadListener.cpp b/Source/PadListener.cpp index 5c5f15f62..aa53e095a 100644 --- a/Source/PadListener.cpp +++ b/Source/PadListener.cpp @@ -6,28 +6,28 @@ using namespace PS2; uint32 CPadListener::GetButtonMask(CControllerInfo::BUTTON button) { static uint32 buttonMask[CControllerInfo::MAX_BUTTONS] = - { - static_cast(-1), - static_cast(-1), - static_cast(-1), - static_cast(-1), - 0x1000, - 0x4000, - 0x8000, - 0x2000, - 0x0100, - 0x0800, - 0x0080, - 0x0010, - 0x0020, - 0x0040, - 0x0004, //L1 - 0x0001, //L2 - 0x0200, //L3 - 0x0008, //R1 - 0x0002, //R2 - 0x0400, //R3 - }; + { + static_cast(-1), + static_cast(-1), + static_cast(-1), + static_cast(-1), + 0x1000, + 0x4000, + 0x8000, + 0x2000, + 0x0100, + 0x0800, + 0x0080, + 0x0010, + 0x0020, + 0x0040, + 0x0004, //L1 + 0x0001, //L2 + 0x0200, //L3 + 0x0008, //R1 + 0x0002, //R2 + 0x0400, //R3 + }; uint32 result = buttonMask[button]; assert(result != -1); diff --git a/Source/PadListener.h b/Source/PadListener.h index c191aa799..ca0a53023 100644 --- a/Source/PadListener.h +++ b/Source/PadListener.h @@ -6,8 +6,10 @@ class CPadListener { public: - virtual ~CPadListener() {} - virtual void SetButtonState(unsigned int, PS2::CControllerInfo::BUTTON, bool, uint8*) = 0; - virtual void SetAxisState(unsigned int, PS2::CControllerInfo::BUTTON, uint8, uint8*) = 0; - static uint32 GetButtonMask(PS2::CControllerInfo::BUTTON); + virtual ~CPadListener() + { + } + virtual void SetButtonState(unsigned int, PS2::CControllerInfo::BUTTON, bool, uint8*) = 0; + virtual void SetAxisState(unsigned int, PS2::CControllerInfo::BUTTON, uint8, uint8*) = 0; + static uint32 GetButtonMask(PS2::CControllerInfo::BUTTON); }; diff --git a/Source/Posix_VolumeStream.cpp b/Source/Posix_VolumeStream.cpp index 31dbedce5..78a3373b4 100644 --- a/Source/Posix_VolumeStream.cpp +++ b/Source/Posix_VolumeStream.cpp @@ -13,7 +13,6 @@ #include #endif - #include "Posix_VolumeStream.h" using namespace Framework::Posix; @@ -21,7 +20,7 @@ using namespace Framework::Posix; CVolumeStream::CVolumeStream(const char* volumePath) { m_fd = open(volumePath, O_RDONLY); - if(m_fd < 0) + if(m_fd < 0) { throw std::runtime_error("Couldn't open volume for reading."); } @@ -76,21 +75,21 @@ uint64 CVolumeStream::Read(void* buffer, uint64 size) uint64 retSize = size; uint8* dst = reinterpret_cast(buffer); uint8* src = reinterpret_cast(m_cache); - + while(size != 0) { SyncCache(); - + size_t sectorOffset = static_cast(m_position & (m_sectorSize - 1)); size_t sectorRemain = static_cast(m_sectorSize - sectorOffset); size_t copy = std::min(size, sectorRemain); - + memcpy(dst, src + sectorOffset, copy); m_position += copy; size -= copy; dst += copy; } - + return retSize; } diff --git a/Source/Posix_VolumeStream.h b/Source/Posix_VolumeStream.h index 8cbf09bb2..ed5a17b7a 100644 --- a/Source/Posix_VolumeStream.h +++ b/Source/Posix_VolumeStream.h @@ -10,24 +10,24 @@ namespace Framework class CVolumeStream : public CStream { public: - CVolumeStream(const char*); - virtual ~CVolumeStream(); - - virtual void Seek(int64, STREAM_SEEK_DIRECTION); - virtual uint64 Tell(); - virtual uint64 Read(void*, uint64); - virtual uint64 Write(const void*, uint64); - virtual bool IsEOF(); - + CVolumeStream(const char*); + virtual ~CVolumeStream(); + + virtual void Seek(int64, STREAM_SEEK_DIRECTION); + virtual uint64 Tell(); + virtual uint64 Read(void*, uint64); + virtual uint64 Write(const void*, uint64); + virtual bool IsEOF(); + private: - void SyncCache(); - - int m_fd; - void* m_cache; - uint64 m_cacheSector; - - uint64 m_position; - uint32 m_sectorSize; + void SyncCache(); + + int m_fd; + void* m_cache; + uint64 m_cacheSector; + + uint64 m_position; + uint32 m_sectorSize; }; } } diff --git a/Source/Profiler.cpp b/Source/Profiler.cpp index 43ad70868..732e397f1 100644 --- a/Source/Profiler.cpp +++ b/Source/Profiler.cpp @@ -4,12 +4,10 @@ CProfiler::CProfiler() { - } CProfiler::~CProfiler() { - } CProfiler::ZoneHandle CProfiler::RegisterZone(const char* name) @@ -49,7 +47,7 @@ void CProfiler::CountCurrentZone() void CProfiler::EnterZone(ZoneHandle zoneHandle) { assert(std::this_thread::get_id() == m_workThreadId); - + auto thisTime = std::chrono::high_resolution_clock::now(); if(!m_zoneStack.empty()) diff --git a/Source/Profiler.h b/Source/Profiler.h index 120b9e105..dfb160163 100644 --- a/Source/Profiler.h +++ b/Source/Profiler.h @@ -15,45 +15,45 @@ public: struct ZONE { - std::string name; - uint64 totalTime = 0; + std::string name; + uint64 totalTime = 0; }; typedef std::vector ZoneArray; typedef std::chrono::high_resolution_clock::time_point TimePoint; - CProfiler(); - virtual ~CProfiler(); + CProfiler(); + virtual ~CProfiler(); - ZoneHandle RegisterZone(const char*); + ZoneHandle RegisterZone(const char*); - void CountCurrentZone(); + void CountCurrentZone(); - void EnterZone(ZoneHandle); - void ExitZone(); + void EnterZone(ZoneHandle); + void ExitZone(); - ZoneArray GetStats() const; - void Reset(); + ZoneArray GetStats() const; + void Reset(); + + void SetWorkThread(); - void SetWorkThread(); - private: typedef std::stack ZoneStack; - - void AddTimeToZone(ZoneHandle, uint64); - ZoneArray m_zones; - ZoneStack m_zoneStack; - TimePoint m_currentTime; - + void AddTimeToZone(ZoneHandle, uint64); + + ZoneArray m_zones; + ZoneStack m_zoneStack; + TimePoint m_currentTime; + #ifdef _DEBUG - std::thread::id m_workThreadId; + std::thread::id m_workThreadId; #endif }; class CProfilerZone { public: - CProfilerZone(CProfiler::ZoneHandle); - ~CProfilerZone(); + CProfilerZone(CProfiler::ZoneHandle); + ~CProfilerZone(); }; diff --git a/Source/Ps2Const.h b/Source/Ps2Const.h index e2d5538b6..afefede72 100644 --- a/Source/Ps2Const.h +++ b/Source/Ps2Const.h @@ -39,7 +39,7 @@ namespace PS2 enum { IOP_CLOCK_BASE_FREQ = (44100 * 256 * 3), - IOP_CLOCK_OVER_FREQ = (48000 * 256 * 3) + IOP_CLOCK_OVER_FREQ = (48000 * 256 * 3) }; enum diff --git a/Source/RegisterStateFile.cpp b/Source/RegisterStateFile.cpp index e1ddf8623..fa97215a6 100644 --- a/Source/RegisterStateFile.cpp +++ b/Source/RegisterStateFile.cpp @@ -7,20 +7,18 @@ #include "lexical_cast_ex.h" CRegisterStateFile::CRegisterStateFile(const char* name) -: CZipFile(name) + : CZipFile(name) { - } CRegisterStateFile::CRegisterStateFile(Framework::CStream& stream) -: CZipFile("") + : CZipFile("") { Read(stream); } CRegisterStateFile::~CRegisterStateFile() { - } void CRegisterStateFile::Read(Framework::CStream& stream) @@ -29,7 +27,7 @@ void CRegisterStateFile::Read(Framework::CStream& stream) auto rootNode = std::unique_ptr(Framework::Xml::CParser::ParseDocument(stream)); auto registerList = rootNode->SelectNodes("RegisterFile/Register"); for(Framework::Xml::CNode::NodeIterator nodeIterator(registerList.begin()); - nodeIterator != registerList.end(); nodeIterator++) + nodeIterator != registerList.end(); nodeIterator++) { try { @@ -52,7 +50,6 @@ void CRegisterStateFile::Read(Framework::CStream& stream) } catch(...) { - } } } @@ -61,7 +58,7 @@ void CRegisterStateFile::Write(Framework::CStream& stream) { auto rootNode = new Framework::Xml::CNode("RegisterFile", true); for(auto registerIterator(m_registers.begin()); - registerIterator != m_registers.end(); registerIterator++) + registerIterator != m_registers.end(); registerIterator++) { const Register& reg(registerIterator->second); auto registerNode = new Framework::Xml::CNode("Register", true); diff --git a/Source/RegisterStateFile.h b/Source/RegisterStateFile.h index c3d1e5b0f..a748166c9 100644 --- a/Source/RegisterStateFile.h +++ b/Source/RegisterStateFile.h @@ -7,24 +7,24 @@ class CRegisterStateFile : public Framework::CZipFile { public: - CRegisterStateFile(const char*); - CRegisterStateFile(Framework::CStream&); - virtual ~CRegisterStateFile(); + CRegisterStateFile(const char*); + CRegisterStateFile(Framework::CStream&); + virtual ~CRegisterStateFile(); - void SetRegister32(const char*, uint32); - void SetRegister64(const char*, uint64); - void SetRegister128(const char*, uint128); + void SetRegister32(const char*, uint32); + void SetRegister64(const char*, uint64); + void SetRegister128(const char*, uint128); - uint32 GetRegister32(const char*) const; - uint64 GetRegister64(const char*) const; - uint128 GetRegister128(const char*) const; + uint32 GetRegister32(const char*) const; + uint64 GetRegister64(const char*) const; + uint128 GetRegister128(const char*) const; - void Read(Framework::CStream&); - void Write(Framework::CStream&) override; + void Read(Framework::CStream&); + void Write(Framework::CStream&) override; private: typedef std::pair Register; typedef std::map RegisterList; - RegisterList m_registers; + RegisterList m_registers; }; diff --git a/Source/ScopedVmPauser.cpp b/Source/ScopedVmPauser.cpp index dcc70d4c2..e245bcfd3 100644 --- a/Source/ScopedVmPauser.cpp +++ b/Source/ScopedVmPauser.cpp @@ -2,7 +2,7 @@ #include "VirtualMachine.h" CScopedVmPauser::CScopedVmPauser(CVirtualMachine& virtualMachine) -: m_virtualMachine(virtualMachine) + : m_virtualMachine(virtualMachine) { if(m_virtualMachine.GetStatus() == CVirtualMachine::RUNNING) { diff --git a/Source/ScopedVmPauser.h b/Source/ScopedVmPauser.h index 0f7090809..4c45a5319 100644 --- a/Source/ScopedVmPauser.h +++ b/Source/ScopedVmPauser.h @@ -5,10 +5,10 @@ class CVirtualMachine; class CScopedVmPauser { public: - CScopedVmPauser(CVirtualMachine&); - virtual ~CScopedVmPauser(); + CScopedVmPauser(CVirtualMachine&); + virtual ~CScopedVmPauser(); private: - CVirtualMachine& m_virtualMachine; - bool m_paused = false; + CVirtualMachine& m_virtualMachine; + bool m_paused = false; }; diff --git a/Source/ScreenShotUtils.cpp b/Source/ScreenShotUtils.cpp index ea91bc6ea..53ae9cf21 100644 --- a/Source/ScreenShotUtils.cpp +++ b/Source/ScreenShotUtils.cpp @@ -13,25 +13,23 @@ void CScreenShotUtils::TriggerGetScreenshot(CPS2VM* virtualMachine, Callback completionCallback) { virtualMachine->m_ee->m_gs->OnFlipComplete.connect_extended( - [=](const boost::signals2::connection &c)->void - { - c.disconnect(); - try - { - auto buffer = virtualMachine->m_ee->m_gs->GetScreenshot(); - auto name = GenerateScreenShotPath(virtualMachine->m_ee->m_os->GetExecutableName()); - Framework::CStdStream outputStream(name.string().c_str(), "wb"); - Framework::CBMP::WriteBitmap(buffer, outputStream); + [=](const boost::signals2::connection& c) -> void { + c.disconnect(); + try + { + auto buffer = virtualMachine->m_ee->m_gs->GetScreenshot(); + auto name = GenerateScreenShotPath(virtualMachine->m_ee->m_os->GetExecutableName()); + Framework::CStdStream outputStream(name.string().c_str(), "wb"); + Framework::CBMP::WriteBitmap(buffer, outputStream); - auto msgstr = string_format("Screenshot saved as '%s'.", name.filename().string().c_str()); - completionCallback(0, msgstr.c_str()); - } - catch(const std::exception&) - { - completionCallback(-1, "Error occured while trying to save screenshot."); - } - } - ); + auto msgstr = string_format("Screenshot saved as '%s'.", name.filename().string().c_str()); + completionCallback(0, msgstr.c_str()); + } + catch(const std::exception&) + { + completionCallback(-1, "Error occured while trying to save screenshot."); + } + }); } Framework::CConfig::PathType CScreenShotUtils::GetScreenShotDirectoryPath() diff --git a/Source/ScreenShotUtils.h b/Source/ScreenShotUtils.h index 509f43343..8c8cdca5e 100644 --- a/Source/ScreenShotUtils.h +++ b/Source/ScreenShotUtils.h @@ -5,11 +5,11 @@ class CScreenShotUtils : public Framework::CConfig { public: - typedef std::function Callback; + typedef std::function Callback; - static void TriggerGetScreenshot(CPS2VM*, Callback); + static void TriggerGetScreenshot(CPS2VM*, Callback); private: - static CConfig::PathType GetScreenShotDirectoryPath(); - static CConfig::PathType GenerateScreenShotPath(const char* gameID); + static CConfig::PathType GetScreenShotDirectoryPath(); + static CConfig::PathType GenerateScreenShotPath(const char* gameID); }; diff --git a/Source/SifDefs.h b/Source/SifDefs.h index 5c4b108e5..0a3cf61da 100644 --- a/Source/SifDefs.h +++ b/Source/SifDefs.h @@ -4,12 +4,12 @@ enum CONST_SIF_CMD { - SIF_CMD_SETSREG = 0x80000001, - SIF_CMD_INIT = 0x80000002, - SIF_CMD_REND = 0x80000008, - SIF_CMD_BIND = 0x80000009, - SIF_CMD_CALL = 0x8000000A, - SIF_CMD_OTHERDATA = 0x8000000C, + SIF_CMD_SETSREG = 0x80000001, + SIF_CMD_INIT = 0x80000002, + SIF_CMD_REND = 0x80000008, + SIF_CMD_BIND = 0x80000009, + SIF_CMD_CALL = 0x8000000A, + SIF_CMD_OTHERDATA = 0x8000000C, }; struct SIFDMAREG @@ -24,7 +24,7 @@ static_assert(sizeof(SIFDMAREG) == 0x10, "sizeof(SIFDMAREG) must be 16 bytes."); struct SIFCMDHEADER { uint32 packetSize : 8; - uint32 destSize : 24; + uint32 destSize : 24; uint32 dest; uint32 commandId; uint32 optional; @@ -33,83 +33,83 @@ static_assert(sizeof(SIFCMDHEADER) == 0x10, "sizeof(SIFCMDHEADER) must be 16 byt struct SIFSETSREG { - SIFCMDHEADER header; - uint32 index; - uint32 value; + SIFCMDHEADER header; + uint32 index; + uint32 value; }; static_assert(sizeof(SIFSETSREG) == 0x18, "sizeof(SIFSETREG) must be 24 bytes."); struct SIFRPCBIND { - SIFCMDHEADER header; - uint32 recordId; - uint32 packetAddr; - uint32 rpcId; - uint32 clientDataAddr; - uint32 serverId; + SIFCMDHEADER header; + uint32 recordId; + uint32 packetAddr; + uint32 rpcId; + uint32 clientDataAddr; + uint32 serverId; }; static_assert(sizeof(SIFRPCBIND) == 0x24, "sizeof(SIFRPCBIND) must be 36 bytes."); struct SIFRPCCALL { - SIFCMDHEADER header; - uint32 recordId; - uint32 packetAddr; - uint32 rpcId; - uint32 clientDataAddr; - uint32 rpcNumber; - uint32 sendSize; - uint32 recv; - uint32 recvSize; - uint32 recvMode; - uint32 serverDataAddr; + SIFCMDHEADER header; + uint32 recordId; + uint32 packetAddr; + uint32 rpcId; + uint32 clientDataAddr; + uint32 rpcNumber; + uint32 sendSize; + uint32 recv; + uint32 recvSize; + uint32 recvMode; + uint32 serverDataAddr; }; static_assert(sizeof(SIFRPCCALL) == 0x38, "sizeof(SIFRPCCALL) must be 56 bytes."); struct SIFRPCREQUESTEND { - SIFCMDHEADER header; - uint32 recordId; - uint32 packetAddr; - uint32 rpcId; - uint32 clientDataAddr; - uint32 commandId; - uint32 serverDataAddr; - uint32 buffer; - uint32 cbuffer; + SIFCMDHEADER header; + uint32 recordId; + uint32 packetAddr; + uint32 rpcId; + uint32 clientDataAddr; + uint32 commandId; + uint32 serverDataAddr; + uint32 buffer; + uint32 cbuffer; }; static_assert(sizeof(SIFRPCREQUESTEND) == 0x30, "sizeof(SIFRPCREQUESTEND) must be 48 bytes."); struct SIFRPCOTHERDATA { - SIFCMDHEADER header; - uint32 recordId; - uint32 packetAddr; - uint32 rpcId; - uint32 receiveDataAddr; - uint32 srcPtr; - uint32 dstPtr; - uint32 size; + SIFCMDHEADER header; + uint32 recordId; + uint32 packetAddr; + uint32 rpcId; + uint32 receiveDataAddr; + uint32 srcPtr; + uint32 dstPtr; + uint32 size; }; static_assert(sizeof(SIFRPCOTHERDATA) == 0x2C, "sizeof(SIFRPCOTHERDATA) must be 44 bytes."); struct SIFRPCHEADER { - uint32 packetAddr; - uint32 rpcId; - uint32 semaId; - uint32 mode; + uint32 packetAddr; + uint32 rpcId; + uint32 semaId; + uint32 mode; }; static_assert(sizeof(SIFRPCHEADER) == 0x10, "sizeof(SIFRPCHEADER) must be 16 bytes."); struct SIFRPCCLIENTDATA { - SIFRPCHEADER header; - uint32 command; - uint32 buffPtr; - uint32 cbuffPtr; - uint32 endFctPtr; - uint32 endParam; - uint32 serverDataAddr; + SIFRPCHEADER header; + uint32 command; + uint32 buffPtr; + uint32 cbuffPtr; + uint32 endFctPtr; + uint32 endParam; + uint32 serverDataAddr; }; static_assert(sizeof(SIFRPCCLIENTDATA) == 0x28, "sizeof(SIFRPCCLIENTDATA) must be 40 bytes."); diff --git a/Source/SifModule.h b/Source/SifModule.h index 2896fa4ec..6250c7846 100644 --- a/Source/SifModule.h +++ b/Source/SifModule.h @@ -5,6 +5,6 @@ class CSifModule { public: - virtual ~CSifModule() = default; - virtual bool Invoke(uint32, uint32*, uint32, uint32*, uint32, uint8*) = 0; + virtual ~CSifModule() = default; + virtual bool Invoke(uint32, uint32*, uint32, uint32*, uint32, uint8*) = 0; }; diff --git a/Source/SifModuleAdapter.h b/Source/SifModuleAdapter.h index b285376dc..cfbabb2e7 100644 --- a/Source/SifModuleAdapter.h +++ b/Source/SifModuleAdapter.h @@ -6,22 +6,19 @@ class CSifModuleAdapter : public CSifModule { public: - typedef std::function SifCommandHandler; + typedef std::function SifCommandHandler; CSifModuleAdapter() { - } CSifModuleAdapter(const SifCommandHandler& handler) - : m_handler(handler) + : m_handler(handler) { - } - + virtual ~CSifModuleAdapter() { - } virtual bool Invoke(uint32 method, uint32* args, uint32 argsSize, uint32* ret, uint32 retSize, uint8* ram) override diff --git a/Source/StructCollectionStateFile.cpp b/Source/StructCollectionStateFile.cpp index 3ea950c0c..922f98236 100644 --- a/Source/StructCollectionStateFile.cpp +++ b/Source/StructCollectionStateFile.cpp @@ -5,18 +5,17 @@ #include "xml/Parser.h" #include "lexical_cast_ex.h" -#define STRUCT_DOCUMENT_HEADER ("StructCollection") -#define STRUCT_DOCUMENT_DETAIL ("Struct") -#define STRUCT_DOCUMENT_DETAIL_NAME ("Name") +#define STRUCT_DOCUMENT_HEADER ("StructCollection") +#define STRUCT_DOCUMENT_DETAIL ("Struct") +#define STRUCT_DOCUMENT_DETAIL_NAME ("Name") CStructCollectionStateFile::CStructCollectionStateFile(const char* name) -: CZipFile(name) + : CZipFile(name) { - } CStructCollectionStateFile::CStructCollectionStateFile(Framework::CStream& stream) -: CZipFile("") + : CZipFile("") { Read(stream); } @@ -52,7 +51,7 @@ void CStructCollectionStateFile::Read(Framework::CStream& stream) auto rootNode = std::unique_ptr(Framework::Xml::CParser::ParseDocument(stream)); auto registerList = rootNode->SelectNodes((std::string(STRUCT_DOCUMENT_HEADER) + "/" + std::string(STRUCT_DOCUMENT_DETAIL)).c_str()); for(auto nodeIterator(registerList.begin()); - nodeIterator != registerList.end(); nodeIterator++) + nodeIterator != registerList.end(); nodeIterator++) { try { @@ -65,7 +64,6 @@ void CStructCollectionStateFile::Read(Framework::CStream& stream) } catch(...) { - } } } @@ -74,7 +72,7 @@ void CStructCollectionStateFile::Write(Framework::CStream& stream) { auto rootNode = new Framework::Xml::CNode(STRUCT_DOCUMENT_HEADER, true); for(auto structIterator(m_structs.begin()); - structIterator != m_structs.end(); structIterator++) + structIterator != m_structs.end(); structIterator++) { const auto& structFile(structIterator->second); auto structNode = new Framework::Xml::CNode(STRUCT_DOCUMENT_DETAIL, true); diff --git a/Source/StructCollectionStateFile.h b/Source/StructCollectionStateFile.h index 09f9bc07c..73d0e470e 100644 --- a/Source/StructCollectionStateFile.h +++ b/Source/StructCollectionStateFile.h @@ -11,20 +11,20 @@ public: typedef std::map StructMap; typedef StructMap::const_iterator StructIterator; - CStructCollectionStateFile(const char*); - CStructCollectionStateFile(Framework::CStream&); - virtual ~CStructCollectionStateFile() = default; + CStructCollectionStateFile(const char*); + CStructCollectionStateFile(Framework::CStream&); + virtual ~CStructCollectionStateFile() = default; - void InsertStruct(const char*, const CStructFile&); - void Read(Framework::CStream&); - void Write(Framework::CStream&) override; + void InsertStruct(const char*, const CStructFile&); + void Read(Framework::CStream&); + void Write(Framework::CStream&) override; - StructIterator GetStructBegin() const; - StructIterator GetStructEnd() const; + StructIterator GetStructBegin() const; + StructIterator GetStructEnd() const; - StructIterator begin() const; - StructIterator end() const; + StructIterator begin() const; + StructIterator end() const; private: - StructMap m_structs; + StructMap m_structs; }; diff --git a/Source/StructFile.cpp b/Source/StructFile.cpp index 644782829..288166301 100644 --- a/Source/StructFile.cpp +++ b/Source/StructFile.cpp @@ -3,91 +3,89 @@ #include "xml/Node.h" #include "lexical_cast_ex.h" -#define STRUCT_FIELD ("Field") -#define STRUCT_FIELD_NAME ("Name") -#define STRUCT_FIELD_VALUE ("Value") +#define STRUCT_FIELD ("Field") +#define STRUCT_FIELD_NAME ("Name") +#define STRUCT_FIELD_VALUE ("Value") using namespace Framework; using namespace std; CStructFile::CStructFile() { - } CStructFile::~CStructFile() { - } void CStructFile::Read(Xml::CNode* rootNode) { - Xml::CNode::NodeList nodeList = rootNode->SelectNodes(STRUCT_FIELD); - for(Xml::CNode::NodeIterator nodeIterator(nodeList.begin()); - nodeIterator != nodeList.end(); nodeIterator++) - { - Xml::CNode* node = (*nodeIterator); - const char* namePtr = node->GetAttribute(STRUCT_FIELD_NAME); - const char* valuePtr = node->GetAttribute(STRUCT_FIELD_VALUE); - if(namePtr == NULL || valuePtr == NULL) continue; - string valueString(valuePtr); - uint128 value; - memset(&value, 0, sizeof(uint128)); - for(unsigned int i = 0; i < 4; i++) - { - if(valueString.length() == 0) break; - int start = max(0, static_cast(valueString.length()) - 8); - string subString(valueString.begin() + start, valueString.end()); - value.nV[i] = lexical_cast_hex(subString); - valueString = string(valueString.begin(), valueString.begin() + start); - } - m_registers[namePtr] = Register(4, value); - } + Xml::CNode::NodeList nodeList = rootNode->SelectNodes(STRUCT_FIELD); + for(Xml::CNode::NodeIterator nodeIterator(nodeList.begin()); + nodeIterator != nodeList.end(); nodeIterator++) + { + Xml::CNode* node = (*nodeIterator); + const char* namePtr = node->GetAttribute(STRUCT_FIELD_NAME); + const char* valuePtr = node->GetAttribute(STRUCT_FIELD_VALUE); + if(namePtr == NULL || valuePtr == NULL) continue; + string valueString(valuePtr); + uint128 value; + memset(&value, 0, sizeof(uint128)); + for(unsigned int i = 0; i < 4; i++) + { + if(valueString.length() == 0) break; + int start = max(0, static_cast(valueString.length()) - 8); + string subString(valueString.begin() + start, valueString.end()); + value.nV[i] = lexical_cast_hex(subString); + valueString = string(valueString.begin(), valueString.begin() + start); + } + m_registers[namePtr] = Register(4, value); + } } void CStructFile::Write(Xml::CNode* rootNode) const { - for(const auto& registerIterator : m_registers) - { - const Register& reg(registerIterator.second); - Xml::CNode* fieldNode = new Xml::CNode(STRUCT_FIELD, true); - string valueString; - for(unsigned int i = 0; i < reg.first; i++) - { - valueString = lexical_cast_hex(reg.second.nV[i], 8) + valueString; - } - fieldNode->InsertAttribute(STRUCT_FIELD_NAME, registerIterator.first.c_str()); - fieldNode->InsertAttribute(STRUCT_FIELD_VALUE, valueString.c_str()); - rootNode->InsertNode(fieldNode); - } + for(const auto& registerIterator : m_registers) + { + const Register& reg(registerIterator.second); + Xml::CNode* fieldNode = new Xml::CNode(STRUCT_FIELD, true); + string valueString; + for(unsigned int i = 0; i < reg.first; i++) + { + valueString = lexical_cast_hex(reg.second.nV[i], 8) + valueString; + } + fieldNode->InsertAttribute(STRUCT_FIELD_NAME, registerIterator.first.c_str()); + fieldNode->InsertAttribute(STRUCT_FIELD_VALUE, valueString.c_str()); + rootNode->InsertNode(fieldNode); + } } void CStructFile::SetRegister32(const char* name, uint32 value) { - uint128 longValue; - longValue.nD0 = value; - longValue.nD1 = 0; - m_registers[name] = Register(1, longValue); + uint128 longValue; + longValue.nD0 = value; + longValue.nD1 = 0; + m_registers[name] = Register(1, longValue); } void CStructFile::SetRegister64(const char* name, uint64 value) { - uint128 longValue; - longValue.nD0 = value; - longValue.nD1 = 0; - m_registers[name] = Register(2, longValue); + uint128 longValue; + longValue.nD0 = value; + longValue.nD1 = 0; + m_registers[name] = Register(2, longValue); } uint32 CStructFile::GetRegister32(const char* name) const { - RegisterList::const_iterator registerIterator(m_registers.find(name)); - if(registerIterator == m_registers.end()) return 0; - return registerIterator->second.second.nV0; + RegisterList::const_iterator registerIterator(m_registers.find(name)); + if(registerIterator == m_registers.end()) return 0; + return registerIterator->second.second.nV0; } uint64 CStructFile::GetRegister64(const char* name) const { - RegisterList::const_iterator registerIterator(m_registers.find(name)); - if(registerIterator == m_registers.end()) return 0; - return registerIterator->second.second.nD0; + RegisterList::const_iterator registerIterator(m_registers.find(name)); + if(registerIterator == m_registers.end()) return 0; + return registerIterator->second.second.nD0; } diff --git a/Source/StructFile.h b/Source/StructFile.h index 576b76bc2..9bf17efd2 100644 --- a/Source/StructFile.h +++ b/Source/StructFile.h @@ -8,25 +8,25 @@ class CStructFile { public: - CStructFile(); - virtual ~CStructFile(); + CStructFile(); + virtual ~CStructFile(); - void Read(Framework::Xml::CNode*); - void Write(Framework::Xml::CNode*) const; + void Read(Framework::Xml::CNode*); + void Write(Framework::Xml::CNode*) const; - void SetRegister32(const char*, uint32); - void SetRegister64(const char*, uint64); - void SetRegister128(const char*, uint128); + void SetRegister32(const char*, uint32); + void SetRegister64(const char*, uint64); + void SetRegister128(const char*, uint128); - uint32 GetRegister32(const char*) const; - uint64 GetRegister64(const char*) const; - uint128 GetRegister128(const char*) const; + uint32 GetRegister32(const char*) const; + uint64 GetRegister64(const char*) const; + uint128 GetRegister128(const char*) const; private: - typedef std::pair Register; - typedef std::map RegisterList; + typedef std::pair Register; + typedef std::map RegisterList; - RegisterList m_registers; + RegisterList m_registers; }; #endif diff --git a/Source/VirtualMachine.h b/Source/VirtualMachine.h index 961f75613..46e44bc67 100644 --- a/Source/VirtualMachine.h +++ b/Source/VirtualMachine.h @@ -11,11 +11,11 @@ public: PAUSED = 2, }; - virtual ~CVirtualMachine() {}; - virtual STATUS GetStatus() const = 0; - virtual void Pause() = 0; - virtual void Resume() = 0; + virtual ~CVirtualMachine(){}; + virtual STATUS GetStatus() const = 0; + virtual void Pause() = 0; + virtual void Resume() = 0; - boost::signals2::signal OnMachineStateChange; - boost::signals2::signal OnRunningStateChange; + boost::signals2::signal OnMachineStateChange; + boost::signals2::signal OnRunningStateChange; }; diff --git a/Source/VirtualPad.cpp b/Source/VirtualPad.cpp index 0457704f2..19999284f 100644 --- a/Source/VirtualPad.cpp +++ b/Source/VirtualPad.cpp @@ -40,64 +40,64 @@ CVirtualPad::ItemArray CVirtualPad::GetItems(float screenWidth, float screenHeig float lr3ButtonPosY = screenHeight - padButtonSize - margin; items.push_back(CreateButtonItem( - leftButtonsPosX, leftButtonsPosY, leftButtonsPosX + lrButtonWidth, leftButtonsPosY + lrButtonHeight, - PS2::CControllerInfo::L2, "lr", "L2")); + leftButtonsPosX, leftButtonsPosY, leftButtonsPosX + lrButtonWidth, leftButtonsPosY + lrButtonHeight, + PS2::CControllerInfo::L2, "lr", "L2")); items.push_back(CreateButtonItem( - leftButtonsPosX, leftButtonsPosY + lrButtonHeight, leftButtonsPosX + lrButtonWidth, leftButtonsPosY + lrButtonHeight * 2, - PS2::CControllerInfo::L1, "lr", "L1")); + leftButtonsPosX, leftButtonsPosY + lrButtonHeight, leftButtonsPosX + lrButtonWidth, leftButtonsPosY + lrButtonHeight * 2, + PS2::CControllerInfo::L1, "lr", "L1")); items.push_back(CreateButtonItem( - rightButtonsPosX, rightButtonsPosY, rightButtonsPosX + lrButtonWidth, rightButtonsPosY + lrButtonHeight, - PS2::CControllerInfo::R2, "lr", "R2")); + rightButtonsPosX, rightButtonsPosY, rightButtonsPosX + lrButtonWidth, rightButtonsPosY + lrButtonHeight, + PS2::CControllerInfo::R2, "lr", "R2")); items.push_back(CreateButtonItem( - rightButtonsPosX, rightButtonsPosY + lrButtonHeight, rightButtonsPosX + lrButtonWidth, rightButtonsPosY + lrButtonHeight * 2, - PS2::CControllerInfo::R1, "lr", "R1")); + rightButtonsPosX, rightButtonsPosY + lrButtonHeight, rightButtonsPosX + lrButtonWidth, rightButtonsPosY + lrButtonHeight * 2, + PS2::CControllerInfo::R1, "lr", "R1")); items.push_back(CreateButtonItem( - startSelPadPosX + padButtonSize * 0, startSelPadPosY + padButtonSize / 2, startSelPadPosX + padButtonSize * 1, startSelPadPosY + padButtonSize, - PS2::CControllerInfo::SELECT, "select")); + startSelPadPosX + padButtonSize * 0, startSelPadPosY + padButtonSize / 2, startSelPadPosX + padButtonSize * 1, startSelPadPosY + padButtonSize, + PS2::CControllerInfo::SELECT, "select")); items.push_back(CreateButtonItem( - startSelPadPosX + padButtonSize * 2, startSelPadPosY + padButtonSize / 2, startSelPadPosX + padButtonSize * 3, startSelPadPosY + padButtonSize, - PS2::CControllerInfo::START, "start")); + startSelPadPosX + padButtonSize * 2, startSelPadPosY + padButtonSize / 2, startSelPadPosX + padButtonSize * 3, startSelPadPosY + padButtonSize, + PS2::CControllerInfo::START, "start")); items.push_back(CreateButtonItem( - dpadPosX + dpadButtonSize * 2, dpadPosY + dpadButtonSize * 0, dpadPosX + dpadButtonSize * 4, dpadPosY + dpadButtonSize * 3, - PS2::CControllerInfo::DPAD_UP, "up")); + dpadPosX + dpadButtonSize * 2, dpadPosY + dpadButtonSize * 0, dpadPosX + dpadButtonSize * 4, dpadPosY + dpadButtonSize * 3, + PS2::CControllerInfo::DPAD_UP, "up")); items.push_back(CreateButtonItem( - dpadPosX + dpadButtonSize * 2, dpadPosY + dpadButtonSize * 3, dpadPosX + dpadButtonSize * 4, dpadPosY + dpadButtonSize * 6, - PS2::CControllerInfo::DPAD_DOWN, "down")); + dpadPosX + dpadButtonSize * 2, dpadPosY + dpadButtonSize * 3, dpadPosX + dpadButtonSize * 4, dpadPosY + dpadButtonSize * 6, + PS2::CControllerInfo::DPAD_DOWN, "down")); items.push_back(CreateButtonItem( - dpadPosX + dpadButtonSize * 0, dpadPosY + dpadButtonSize * 2, dpadPosX + dpadButtonSize * 3, dpadPosY + dpadButtonSize * 4, - PS2::CControllerInfo::DPAD_LEFT, "left")); + dpadPosX + dpadButtonSize * 0, dpadPosY + dpadButtonSize * 2, dpadPosX + dpadButtonSize * 3, dpadPosY + dpadButtonSize * 4, + PS2::CControllerInfo::DPAD_LEFT, "left")); items.push_back(CreateButtonItem( - dpadPosX + dpadButtonSize * 3, dpadPosY + dpadButtonSize * 2, dpadPosX + dpadButtonSize * 6, dpadPosY + dpadButtonSize * 4, - PS2::CControllerInfo::DPAD_RIGHT, "right")); + dpadPosX + dpadButtonSize * 3, dpadPosY + dpadButtonSize * 2, dpadPosX + dpadButtonSize * 6, dpadPosY + dpadButtonSize * 4, + PS2::CControllerInfo::DPAD_RIGHT, "right")); items.push_back(CreateButtonItem( - actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 0, actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 1, - PS2::CControllerInfo::TRIANGLE, "triangle")); + actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 0, actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 1, + PS2::CControllerInfo::TRIANGLE, "triangle")); items.push_back(CreateButtonItem( - actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 2, actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 3, - PS2::CControllerInfo::CROSS, "cross")); + actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 2, actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 3, + PS2::CControllerInfo::CROSS, "cross")); items.push_back(CreateButtonItem( - actionPadPosX + padButtonSize * 0, actionPadPosY + padButtonSize * 1, actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 2, - PS2::CControllerInfo::SQUARE, "square")); + actionPadPosX + padButtonSize * 0, actionPadPosY + padButtonSize * 1, actionPadPosX + padButtonSize * 1, actionPadPosY + padButtonSize * 2, + PS2::CControllerInfo::SQUARE, "square")); items.push_back(CreateButtonItem( - actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 1, actionPadPosX + padButtonSize * 3, actionPadPosY + padButtonSize * 2, - PS2::CControllerInfo::CIRCLE, "circle")); + actionPadPosX + padButtonSize * 2, actionPadPosY + padButtonSize * 1, actionPadPosX + padButtonSize * 3, actionPadPosY + padButtonSize * 2, + PS2::CControllerInfo::CIRCLE, "circle")); items.push_back(CreateAnalogStickItem( - leftAnalogStickPosX, analogStickPosY, leftAnalogStickPosX + analogStickSize, analogStickPosY + analogStickSize, - PS2::CControllerInfo::ANALOG_LEFT_X, PS2::CControllerInfo::ANALOG_LEFT_Y, "analogStick")); + leftAnalogStickPosX, analogStickPosY, leftAnalogStickPosX + analogStickSize, analogStickPosY + analogStickSize, + PS2::CControllerInfo::ANALOG_LEFT_X, PS2::CControllerInfo::ANALOG_LEFT_Y, "analogStick")); items.push_back(CreateAnalogStickItem( - rightAnalogStickPosX, analogStickPosY, rightAnalogStickPosX + analogStickSize, analogStickPosY + analogStickSize, - PS2::CControllerInfo::ANALOG_RIGHT_X, PS2::CControllerInfo::ANALOG_RIGHT_Y, "analogStick")); + rightAnalogStickPosX, analogStickPosY, rightAnalogStickPosX + analogStickSize, analogStickPosY + analogStickSize, + PS2::CControllerInfo::ANALOG_RIGHT_X, PS2::CControllerInfo::ANALOG_RIGHT_Y, "analogStick")); items.push_back(CreateButtonItem( - l3ButtonPosX, lr3ButtonPosY, l3ButtonPosX + lr3ButtonSize, lr3ButtonPosY + lr3ButtonSize, - PS2::CControllerInfo::L3, "lr", "L3")); + l3ButtonPosX, lr3ButtonPosY, l3ButtonPosX + lr3ButtonSize, lr3ButtonPosY + lr3ButtonSize, + PS2::CControllerInfo::L3, "lr", "L3")); items.push_back(CreateButtonItem( - r3ButtonPosX, lr3ButtonPosY, r3ButtonPosX + lr3ButtonSize, lr3ButtonPosY + lr3ButtonSize, - PS2::CControllerInfo::R3, "lr", "R3")); + r3ButtonPosX, lr3ButtonPosY, r3ButtonPosX + lr3ButtonSize, lr3ButtonPosY + lr3ButtonSize, + PS2::CControllerInfo::R3, "lr", "R3")); return items; } diff --git a/Source/VirtualPad.h b/Source/VirtualPad.h index c4138ccfe..d15bd28c7 100644 --- a/Source/VirtualPad.h +++ b/Source/VirtualPad.h @@ -9,21 +9,21 @@ class CVirtualPad public: struct ITEM { - float x1 = 0; - float y1 = 0; - float x2 = 0; - float y2 = 0; - bool isAnalog = false; - PS2::CControllerInfo::BUTTON code0 = PS2::CControllerInfo::MAX_BUTTONS; - PS2::CControllerInfo::BUTTON code1 = PS2::CControllerInfo::MAX_BUTTONS; - std::string imageName; - std::string caption; + float x1 = 0; + float y1 = 0; + float x2 = 0; + float y2 = 0; + bool isAnalog = false; + PS2::CControllerInfo::BUTTON code0 = PS2::CControllerInfo::MAX_BUTTONS; + PS2::CControllerInfo::BUTTON code1 = PS2::CControllerInfo::MAX_BUTTONS; + std::string imageName; + std::string caption; }; typedef std::vector ItemArray; - static ItemArray GetItems(float, float); + static ItemArray GetItems(float, float); private: - static ITEM CreateButtonItem(float, float, float, float, PS2::CControllerInfo::BUTTON, const std::string&, const std::string& = ""); - static ITEM CreateAnalogStickItem(float, float, float, float, PS2::CControllerInfo::BUTTON, PS2::CControllerInfo::BUTTON, const std::string&); + static ITEM CreateButtonItem(float, float, float, float, PS2::CControllerInfo::BUTTON, const std::string&, const std::string& = ""); + static ITEM CreateAnalogStickItem(float, float, float, float, PS2::CControllerInfo::BUTTON, PS2::CControllerInfo::BUTTON, const std::string&); }; diff --git a/Source/VolumeStream.cpp b/Source/VolumeStream.cpp index b02a4e725..db2ed251b 100644 --- a/Source/VolumeStream.cpp +++ b/Source/VolumeStream.cpp @@ -7,16 +7,15 @@ using namespace std; CVolumeStream::CVolumeStream(char nDriveLetter) { - char sPath[7] = - { - '\\', - '\\', - '.', - '\\', - nDriveLetter, - ':', - '\0' - }; + char sPath[7] = + { + '\\', + '\\', + '.', + '\\', + nDriveLetter, + ':', + '\0'}; m_nVolume = CreateFileA(sPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); m_nPosition = 0; @@ -72,7 +71,7 @@ uint64 CVolumeStream::Read(void* pBuffer, uint64 nSize) nSectorOffset = (size_t)(m_nPosition & (m_nSectorSize - 1)); nSectorRemain = (size_t)(m_nSectorSize - nSectorOffset); nCopy = min((size_t)nSize, nSectorRemain); - + memcpy(pDst, pSrc + nSectorOffset, nCopy); m_nPosition += nCopy; diff --git a/Source/VolumeStream.h b/Source/VolumeStream.h index adf309b0b..b4eec9a09 100644 --- a/Source/VolumeStream.h +++ b/Source/VolumeStream.h @@ -11,23 +11,23 @@ namespace Framework class CVolumeStream : public CStream { public: - CVolumeStream(char); - virtual ~CVolumeStream(); - virtual void Seek(int64, STREAM_SEEK_DIRECTION); - virtual uint64 Tell(); - virtual uint64 Read(void*, uint64); - virtual uint64 Write(const void*, uint64); - virtual bool IsEOF(); + CVolumeStream(char); + virtual ~CVolumeStream(); + virtual void Seek(int64, STREAM_SEEK_DIRECTION); + virtual uint64 Tell(); + virtual uint64 Read(void*, uint64); + virtual uint64 Write(const void*, uint64); + virtual bool IsEOF(); private: - void SyncCache(); + void SyncCache(); - HANDLE m_nVolume; - void* m_pCache; - uint64 m_nCacheSector; + HANDLE m_nVolume; + void* m_pCache; + uint64 m_nCacheSector; - uint64 m_nPosition; - uint64 m_nSectorSize; + uint64 m_nPosition; + uint64 m_nSectorSize; }; } } diff --git a/Source/ee/COP_VU.cpp b/Source/ee/COP_VU.cpp index b8b27e6f1..db6216109 100644 --- a/Source/ee/COP_VU.cpp +++ b/Source/ee/COP_VU.cpp @@ -9,25 +9,25 @@ #undef MAX -#define LOG_NAME ("vpu") +#define LOG_NAME ("vpu") enum CTRL_REG { - CTRL_REG_STATUS = 16, - CTRL_REG_MAC = 17, - CTRL_REG_CLIP = 18, - CTRL_REG_R = 20, - CTRL_REG_I = 21, - CTRL_REG_Q = 22, - CTRL_REG_TPC = 26, - CTRL_REG_CMSAR0 = 27, - CTRL_REG_FBRST = 28, + CTRL_REG_STATUS = 16, + CTRL_REG_MAC = 17, + CTRL_REG_CLIP = 18, + CTRL_REG_R = 20, + CTRL_REG_I = 21, + CTRL_REG_Q = 22, + CTRL_REG_TPC = 26, + CTRL_REG_CMSAR0 = 27, + CTRL_REG_FBRST = 28, CTRL_REG_VPU_STAT = 29, - CTRL_REG_CMSAR1 = 31, + CTRL_REG_CMSAR1 = 31, }; CCOP_VU::CCOP_VU(MIPS_REGSIZE nRegSize) -: CMIPSCoprocessor(nRegSize) + : CMIPSCoprocessor(nRegSize) { SetupReflectionTables(); } @@ -36,22 +36,22 @@ void CCOP_VU::CompileInstruction(uint32 nAddress, CMipsJitter* codeGen, CMIPS* p { SetupQuickVariables(nAddress, codeGen, pCtx); - m_nDest = (uint8)((m_nOpcode >> 21) & 0x0F); - - m_nFSF = ((m_nDest >> 0) & 0x03); - m_nFTF = ((m_nDest >> 2) & 0x03); + m_nDest = (uint8)((m_nOpcode >> 21) & 0x0F); - m_nFT = (uint8)((m_nOpcode >> 16) & 0x1F); - m_nFS = (uint8)((m_nOpcode >> 11) & 0x1F); - m_nFD = (uint8)((m_nOpcode >> 6) & 0x1F); + m_nFSF = ((m_nDest >> 0) & 0x03); + m_nFTF = ((m_nDest >> 2) & 0x03); - m_nBc = (uint8)((m_nOpcode >> 0) & 0x03); + m_nFT = (uint8)((m_nOpcode >> 16) & 0x1F); + m_nFS = (uint8)((m_nOpcode >> 11) & 0x1F); + m_nFD = (uint8)((m_nOpcode >> 6) & 0x1F); - m_nIT = m_nFT; - m_nIS = m_nFS; - m_nID = m_nFD; - m_nImm5 = m_nID; - m_nImm15 = (uint16)((m_nOpcode >> 6) & 0x7FFF); + m_nBc = (uint8)((m_nOpcode >> 0) & 0x03); + + m_nIT = m_nFT; + m_nIS = m_nFS; + m_nID = m_nFD; + m_nImm5 = m_nID; + m_nImm15 = (uint16)((m_nOpcode >> 6) & 0x7FFF); switch((m_nOpcode >> 26) & 0x3F) { @@ -243,22 +243,23 @@ void CCOP_VU::CTC2() m_codeGen->PullTop(); break; case CTRL_REG_CMSAR1: - { - m_codeGen->PushCst(0xFFFF); - m_codeGen->And(); - uint32 valueCursor = m_codeGen->GetTopCursor(); + { + m_codeGen->PushCst(0xFFFF); + m_codeGen->And(); + uint32 valueCursor = m_codeGen->GetTopCursor(); - //Push context - m_codeGen->PushCtx(); - //Push value - m_codeGen->PushCursor(valueCursor); - //Compute Address - m_codeGen->PushCst(CVpu::VU_CMSAR1); - m_codeGen->Call(reinterpret_cast(&MemoryUtils_SetWordProxy), 3, false); - //Clear stack - assert(m_codeGen->GetTopCursor() == valueCursor); m_codeGen->PullTop(); - } - break; + //Push context + m_codeGen->PushCtx(); + //Push value + m_codeGen->PushCursor(valueCursor); + //Compute Address + m_codeGen->PushCst(CVpu::VU_CMSAR1); + m_codeGen->Call(reinterpret_cast(&MemoryUtils_SetWordProxy), 3, false); + //Clear stack + assert(m_codeGen->GetTopCursor() == valueCursor); + m_codeGen->PullTop(); + } + break; default: assert(false); m_codeGen->PullTop(); diff --git a/Source/ee/COP_VU.h b/Source/ee/COP_VU.h index 03157a721..3d71427ac 100644 --- a/Source/ee/COP_VU.h +++ b/Source/ee/COP_VU.h @@ -7,189 +7,188 @@ class CCOP_VU : public CMIPSCoprocessor { public: - CCOP_VU(MIPS_REGSIZE); + CCOP_VU(MIPS_REGSIZE); - void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - void GetInstruction(uint32, char*) override; - void GetArguments(uint32, uint32, char*) override; - uint32 GetEffectiveAddress(uint32, uint32) override; - MIPS_BRANCH_TYPE IsBranch(uint32) override; + void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + void GetInstruction(uint32, char*) override; + void GetArguments(uint32, uint32, char*) override; + uint32 GetEffectiveAddress(uint32, uint32) override; + MIPS_BRANCH_TYPE IsBranch(uint32) override; protected: typedef void (CCOP_VU::*InstructionFuncConstant)(); - void SetupReflectionTables(); + void SetupReflectionTables(); - static void ReflMnemI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); + static void ReflMnemI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, char*, unsigned int); - static void ReflOpOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtFd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRtId(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpImm15(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpAccFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpVi27(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpOff(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtFd(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRtId(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpImm15(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpAccFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtOffRs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpVi27(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - MIPSReflection::INSTRUCTION m_ReflGeneral[64]; - MIPSReflection::INSTRUCTION m_ReflCop2[32]; - MIPSReflection::INSTRUCTION m_ReflBc2[4]; - MIPSReflection::INSTRUCTION m_ReflV[64]; - MIPSReflection::INSTRUCTION m_ReflVX0[32]; - MIPSReflection::INSTRUCTION m_ReflVX1[32]; - MIPSReflection::INSTRUCTION m_ReflVX2[32]; - MIPSReflection::INSTRUCTION m_ReflVX3[32]; + MIPSReflection::INSTRUCTION m_ReflGeneral[64]; + MIPSReflection::INSTRUCTION m_ReflCop2[32]; + MIPSReflection::INSTRUCTION m_ReflBc2[4]; + MIPSReflection::INSTRUCTION m_ReflV[64]; + MIPSReflection::INSTRUCTION m_ReflVX0[32]; + MIPSReflection::INSTRUCTION m_ReflVX1[32]; + MIPSReflection::INSTRUCTION m_ReflVX2[32]; + MIPSReflection::INSTRUCTION m_ReflVX3[32]; - MIPSReflection::SUBTABLE m_ReflGeneralTable; - MIPSReflection::SUBTABLE m_ReflCop2Table; - MIPSReflection::SUBTABLE m_ReflBc2Table; - MIPSReflection::SUBTABLE m_ReflVTable; - MIPSReflection::SUBTABLE m_ReflVX0Table; - MIPSReflection::SUBTABLE m_ReflVX1Table; - MIPSReflection::SUBTABLE m_ReflVX2Table; - MIPSReflection::SUBTABLE m_ReflVX3Table; + MIPSReflection::SUBTABLE m_ReflGeneralTable; + MIPSReflection::SUBTABLE m_ReflCop2Table; + MIPSReflection::SUBTABLE m_ReflBc2Table; + MIPSReflection::SUBTABLE m_ReflVTable; + MIPSReflection::SUBTABLE m_ReflVX0Table; + MIPSReflection::SUBTABLE m_ReflVX1Table; + MIPSReflection::SUBTABLE m_ReflVX2Table; + MIPSReflection::SUBTABLE m_ReflVX3Table; - static InstructionFuncConstant m_pOpCop2[0x20]; - static InstructionFuncConstant m_pOpVector[0x40]; - static InstructionFuncConstant m_pOpVx0[0x20]; - static InstructionFuncConstant m_pOpVx1[0x20]; - static InstructionFuncConstant m_pOpVx2[0x20]; - static InstructionFuncConstant m_pOpVx3[0x20]; + static InstructionFuncConstant m_pOpCop2[0x20]; + static InstructionFuncConstant m_pOpVector[0x40]; + static InstructionFuncConstant m_pOpVx0[0x20]; + static InstructionFuncConstant m_pOpVx1[0x20]; + static InstructionFuncConstant m_pOpVx2[0x20]; + static InstructionFuncConstant m_pOpVx3[0x20]; private: //General - void LQC2(); - void SQC2(); + void LQC2(); + void SQC2(); //COP2 - void QMFC2(); - void CFC2(); - void QMTC2(); - void CTC2(); - void BC2(); - void V(); + void QMFC2(); + void CFC2(); + void QMTC2(); + void CTC2(); + void BC2(); + void V(); //Vector - void VADDbc(); - void VSUBbc(); - void VMADDbc(); - void VMSUBbc(); - void VMAXbc(); - void VMINIbc(); - void VMULbc(); - void VMULq(); - void VMAXi(); - void VMULi(); - void VMINIi(); - void VADDq(); - void VMADDq(); - void VADDi(); - void VMADDi(); - void VSUBq(); - void VMSUBq(); - void VSUBi(); - void VMSUBi(); - void VADD(); - void VMADD(); - void VMUL(); - void VMAX(); - void VSUB(); - void VMSUB(); - void VOPMSUB(); - void VMINI(); - void VIADD(); - void VISUB(); - void VIADDI(); - void VIAND(); - void VIOR(); - void VCALLMS(); - void VCALLMSR(); - void VX0(); - void VX1(); - void VX2(); - void VX3(); + void VADDbc(); + void VSUBbc(); + void VMADDbc(); + void VMSUBbc(); + void VMAXbc(); + void VMINIbc(); + void VMULbc(); + void VMULq(); + void VMAXi(); + void VMULi(); + void VMINIi(); + void VADDq(); + void VMADDq(); + void VADDi(); + void VMADDi(); + void VSUBq(); + void VMSUBq(); + void VSUBi(); + void VMSUBi(); + void VADD(); + void VMADD(); + void VMUL(); + void VMAX(); + void VSUB(); + void VMSUB(); + void VOPMSUB(); + void VMINI(); + void VIADD(); + void VISUB(); + void VIADDI(); + void VIAND(); + void VIOR(); + void VCALLMS(); + void VCALLMSR(); + void VX0(); + void VX1(); + void VX2(); + void VX3(); //Vx (Common) - void VADDAbc(); - void VSUBAbc(); - void VMULAbc(); - void VMULAq(); - void VMADDAbc(); - void VMSUBAbc(); + void VADDAbc(); + void VSUBAbc(); + void VMULAbc(); + void VMULAq(); + void VMADDAbc(); + void VMSUBAbc(); //V0 - void VITOF0(); - void VFTOI0(); - void VADDA(); - void VSUBA(); - void VMOVE(); - void VLQI(); - void VDIV(); - void VMTIR(); - void VRNEXT(); + void VITOF0(); + void VFTOI0(); + void VADDA(); + void VSUBA(); + void VMOVE(); + void VLQI(); + void VDIV(); + void VMTIR(); + void VRNEXT(); //V1 - void VITOF4(); - void VFTOI4(); - void VABS(); - void VMADDAq(); - void VMSUBAq(); - void VMADDA(); - void VMSUBA(); - void VMR32(); - void VSQI(); - void VSQRT(); - void VMFIR(); - void VRGET(); + void VITOF4(); + void VFTOI4(); + void VABS(); + void VMADDAq(); + void VMSUBAq(); + void VMADDA(); + void VMSUBA(); + void VMR32(); + void VSQI(); + void VSQRT(); + void VMFIR(); + void VRGET(); //V2 - void VITOF12(); - void VFTOI12(); - void VMULAi(); - void VMULA(); - void VOPMULA(); - void VLQD(); - void VRSQRT(); - void VILWR(); - void VRINIT(); + void VITOF12(); + void VFTOI12(); + void VMULAi(); + void VMULA(); + void VOPMULA(); + void VLQD(); + void VRSQRT(); + void VILWR(); + void VRINIT(); //V3 - void VITOF15(); - void VFTOI15(); - void VCLIP(); - void VMADDAi(); - void VMSUBAi(); - void VNOP(); - void VSQD(); - void VWAITQ(); - void VISWR(); - void VRXOR(); + void VITOF15(); + void VFTOI15(); + void VCLIP(); + void VMADDAi(); + void VMSUBAi(); + void VNOP(); + void VSQD(); + void VWAITQ(); + void VISWR(); + void VRXOR(); - uint8 m_nBc = 0; - uint8 m_nDest = 0; - uint8 m_nFSF = 0; - uint8 m_nFTF = 0; + uint8 m_nBc = 0; + uint8 m_nDest = 0; + uint8 m_nFSF = 0; + uint8 m_nFTF = 0; - uint8 m_nFS = 0; - uint8 m_nFT = 0; - uint8 m_nFD = 0; + uint8 m_nFS = 0; + uint8 m_nFT = 0; + uint8 m_nFD = 0; - uint8 m_nIT = 0; - uint8 m_nIS = 0; - uint8 m_nID = 0; - uint8 m_nImm5 = 0; - uint16 m_nImm15 = 0; - static const uint32 m_vuMemAddressMask = (PS2::VUMEM0SIZE - 1); + uint8 m_nIT = 0; + uint8 m_nIS = 0; + uint8 m_nID = 0; + uint8 m_nImm5 = 0; + uint16 m_nImm15 = 0; + static const uint32 m_vuMemAddressMask = (PS2::VUMEM0SIZE - 1); //Reflection tables - static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; - static MIPSReflection::INSTRUCTION m_cReflCop2[32]; - static MIPSReflection::INSTRUCTION m_cReflBc2[4]; - static MIPSReflection::INSTRUCTION m_cReflV[64]; - static MIPSReflection::INSTRUCTION m_cReflVX0[32]; - static MIPSReflection::INSTRUCTION m_cReflVX1[32]; - static MIPSReflection::INSTRUCTION m_cReflVX2[32]; - static MIPSReflection::INSTRUCTION m_cReflVX3[32]; - + static MIPSReflection::INSTRUCTION m_cReflGeneral[64]; + static MIPSReflection::INSTRUCTION m_cReflCop2[32]; + static MIPSReflection::INSTRUCTION m_cReflBc2[4]; + static MIPSReflection::INSTRUCTION m_cReflV[64]; + static MIPSReflection::INSTRUCTION m_cReflVX0[32]; + static MIPSReflection::INSTRUCTION m_cReflVX1[32]; + static MIPSReflection::INSTRUCTION m_cReflVX2[32]; + static MIPSReflection::INSTRUCTION m_cReflVX3[32]; }; diff --git a/Source/ee/COP_VU_Reflection.cpp b/Source/ee/COP_VU_Reflection.cpp index e9d54726e..a11090359 100644 --- a/Source/ee/COP_VU_Reflection.cpp +++ b/Source/ee/COP_VU_Reflection.cpp @@ -46,25 +46,25 @@ void CCOP_VU::ReflOpRtId(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint void CCOP_VU::ReflOpImm15(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint16 nImm = static_cast((nOpcode >> 6) & 0x7FFF); + uint16 nImm = static_cast((nOpcode >> 6) & 0x7FFF); sprintf(sText, "$%04X", nImm); } void CCOP_VU::ReflOpAccFsFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); sprintf(sText, "ACC%s, VF%i%s, VF%i%s", m_sDestination[nDest], nFS, m_sDestination[nDest], nFT, m_sDestination[nDest]); } void CCOP_VU::ReflOpFtOffRs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nRS = static_cast ((nOpcode >> 21) & 0x001F); - uint8 nFT = static_cast ((nOpcode >> 16) & 0x001F); - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint8 nRS = static_cast((nOpcode >> 21) & 0x001F); + uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); sprintf(sText, "VF%i, $%04X(%s)", nFT, nImm, CMIPS::m_sGPRName[nRS]); } @@ -76,7 +76,7 @@ void CCOP_VU::ReflOpVi27(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint uint32 CCOP_VU::ReflEaOffset(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { - auto imm = static_cast((nOpcode >> 0) & 0xFFFF); + auto imm = static_cast((nOpcode >> 0) & 0xFFFF); nAddress += 4; return (nAddress + CMIPS::GetBranch(imm)); } @@ -446,68 +446,68 @@ INSTRUCTION CCOP_VU::m_cReflVX3[32] = void CCOP_VU::SetupReflectionTables() { - static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_ReflCop2) == sizeof(m_cReflCop2), "Array sizes don't match"); - static_assert(sizeof(m_ReflBc2) == sizeof(m_cReflBc2), "Array sizes don't match"); - static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); + static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_ReflCop2) == sizeof(m_cReflCop2), "Array sizes don't match"); + static_assert(sizeof(m_ReflBc2) == sizeof(m_cReflBc2), "Array sizes don't match"); + static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); - memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); - memcpy(m_ReflCop2, m_cReflCop2, sizeof(m_cReflCop2)); - memcpy(m_ReflBc2, m_cReflBc2, sizeof(m_cReflBc2)); - memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); - memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); - memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); - memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); - memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); + memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); + memcpy(m_ReflCop2, m_cReflCop2, sizeof(m_cReflCop2)); + memcpy(m_ReflBc2, m_cReflBc2, sizeof(m_cReflBc2)); + memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); + memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); + memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); + memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); + memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); - m_ReflGeneralTable.nShift = 26; - m_ReflGeneralTable.nMask = 0x3F; - m_ReflGeneralTable.pTable = m_ReflGeneral; + m_ReflGeneralTable.nShift = 26; + m_ReflGeneralTable.nMask = 0x3F; + m_ReflGeneralTable.pTable = m_ReflGeneral; - m_ReflCop2Table.nShift = 21; - m_ReflCop2Table.nMask = 0x1F; - m_ReflCop2Table.pTable = m_ReflCop2; + m_ReflCop2Table.nShift = 21; + m_ReflCop2Table.nMask = 0x1F; + m_ReflCop2Table.pTable = m_ReflCop2; - m_ReflBc2Table.nShift = 16; - m_ReflBc2Table.nMask = 0x03; - m_ReflBc2Table.pTable = m_ReflBc2; + m_ReflBc2Table.nShift = 16; + m_ReflBc2Table.nMask = 0x03; + m_ReflBc2Table.pTable = m_ReflBc2; - m_ReflVTable.nShift = 0; - m_ReflVTable.nMask = 0x3F; - m_ReflVTable.pTable = m_ReflV; + m_ReflVTable.nShift = 0; + m_ReflVTable.nMask = 0x3F; + m_ReflVTable.pTable = m_ReflV; - m_ReflVX0Table.nShift = 6; - m_ReflVX0Table.nMask = 0x1F; - m_ReflVX0Table.pTable = m_ReflVX0; + m_ReflVX0Table.nShift = 6; + m_ReflVX0Table.nMask = 0x1F; + m_ReflVX0Table.pTable = m_ReflVX0; - m_ReflVX1Table.nShift = 6; - m_ReflVX1Table.nMask = 0x1F; - m_ReflVX1Table.pTable = m_ReflVX1; + m_ReflVX1Table.nShift = 6; + m_ReflVX1Table.nMask = 0x1F; + m_ReflVX1Table.pTable = m_ReflVX1; - m_ReflVX2Table.nShift = 6; - m_ReflVX2Table.nMask = 0x1F; - m_ReflVX2Table.pTable = m_ReflVX2; + m_ReflVX2Table.nShift = 6; + m_ReflVX2Table.nMask = 0x1F; + m_ReflVX2Table.pTable = m_ReflVX2; - m_ReflVX3Table.nShift = 6; - m_ReflVX3Table.nMask = 0x1F; - m_ReflVX3Table.pTable = m_ReflVX3; + m_ReflVX3Table.nShift = 6; + m_ReflVX3Table.nMask = 0x1F; + m_ReflVX3Table.pTable = m_ReflVX3; - m_ReflGeneral[0x12].pSubTable = &m_ReflCop2Table; + m_ReflGeneral[0x12].pSubTable = &m_ReflCop2Table; - m_ReflCop2[0x08].pSubTable = &m_ReflBc2Table; + m_ReflCop2[0x08].pSubTable = &m_ReflBc2Table; for(unsigned int i = 0x10; i < 0x20; i++) { - m_ReflCop2[i].pSubTable = &m_ReflVTable; + m_ReflCop2[i].pSubTable = &m_ReflVTable; } - m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; - m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; - m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; - m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; + m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; + m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; + m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; + m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; } void CCOP_VU::GetInstruction(uint32 nOpcode, char* sText) @@ -523,8 +523,8 @@ void CCOP_VU::GetInstruction(uint32 nOpcode, char* sText) CMIPS* pCtx = NULL; INSTRUCTION Instr; - Instr.pGetMnemonic = SubTableMnemonic; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetMnemonic = SubTableMnemonic; + Instr.pSubTable = &m_ReflGeneralTable; Instr.pGetMnemonic(&Instr, pCtx, nOpcode, sText, nCount); } @@ -541,9 +541,9 @@ void CCOP_VU::GetArguments(uint32 nAddress, uint32 nOpcode, char* sText) CMIPS* pCtx = NULL; INSTRUCTION Instr; - Instr.pGetOperands = SubTableOperands; - Instr.pSubTable = &m_ReflGeneralTable; - Instr.pGetOperands(&Instr, pCtx, nAddress, nOpcode, sText, 256); + Instr.pGetOperands = SubTableOperands; + Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetOperands(&Instr, pCtx, nAddress, nOpcode, sText, 256); } MIPS_BRANCH_TYPE CCOP_VU::IsBranch(uint32 nOpcode) @@ -553,8 +553,8 @@ MIPS_BRANCH_TYPE CCOP_VU::IsBranch(uint32 nOpcode) CMIPS* pCtx = NULL; INSTRUCTION Instr; - Instr.pIsBranch = SubTableIsBranch; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pIsBranch = SubTableIsBranch; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pIsBranch(&Instr, pCtx, nOpcode); } @@ -565,7 +565,7 @@ uint32 CCOP_VU::GetEffectiveAddress(uint32 nAddress, uint32 nOpcode) CMIPS* pCtx = NULL; INSTRUCTION Instr; - Instr.pGetEffectiveAddress = SubTableEffAddr; - Instr.pSubTable = &m_ReflGeneralTable; + Instr.pGetEffectiveAddress = SubTableEffAddr; + Instr.pSubTable = &m_ReflGeneralTable; return Instr.pGetEffectiveAddress(&Instr, pCtx, nAddress, nOpcode); } diff --git a/Source/ee/DMAC.cpp b/Source/ee/DMAC.cpp index 06f213004..5f5f1fd7a 100644 --- a/Source/ee/DMAC.cpp +++ b/Source/ee/DMAC.cpp @@ -7,32 +7,32 @@ #include "../COP_SCU.h" #include "placeholder_def.h" -#define LOG_NAME ("dmac") -#define STATE_REGS_XML ("dmac/regs.xml") -#define STATE_REGS_CTRL ("D_CTRL") -#define STATE_REGS_STAT ("D_STAT") -#define STATE_REGS_ENABLE ("D_ENABLE") -#define STATE_REGS_PCR ("D_PCR") -#define STATE_REGS_SQWC ("D_SQWC") -#define STATE_REGS_RBSR ("D_RBSR") -#define STATE_REGS_RBOR ("D_RBOR") -#define STATE_REGS_STADR ("D_STADR") -#define STATE_REGS_D8_SADR ("D8_SADR") -#define STATE_REGS_D9_SADR ("D9_SADR") +#define LOG_NAME ("dmac") +#define STATE_REGS_XML ("dmac/regs.xml") +#define STATE_REGS_CTRL ("D_CTRL") +#define STATE_REGS_STAT ("D_STAT") +#define STATE_REGS_ENABLE ("D_ENABLE") +#define STATE_REGS_PCR ("D_PCR") +#define STATE_REGS_SQWC ("D_SQWC") +#define STATE_REGS_RBSR ("D_RBSR") +#define STATE_REGS_RBOR ("D_RBOR") +#define STATE_REGS_STADR ("D_STADR") +#define STATE_REGS_D8_SADR ("D8_SADR") +#define STATE_REGS_D9_SADR ("D9_SADR") -#define MADR_WRITE_MASK (~0x0000000F) -#define SPR_MADR_WRITE_MASK (~0x8000000F) +#define MADR_WRITE_MASK (~0x0000000F) +#define SPR_MADR_WRITE_MASK (~0x8000000F) -#define SADR_WRITE_MASK ((PS2::EE_SPR_SIZE - 1) & ~0x0F) +#define SADR_WRITE_MASK ((PS2::EE_SPR_SIZE - 1) & ~0x0F) -#define REGISTER_READ(addr, value) \ - case (addr) + 0x0: \ - return (value); \ - break; \ - case (addr) + 0x4: \ - case (addr) + 0x8: \ - case (addr) + 0xC: \ - return 0; \ +#define REGISTER_READ(addr, value) \ + case(addr) + 0x0: \ + return (value); \ + break; \ + case(addr) + 0x4: \ + case(addr) + 0x8: \ + case(addr) + 0xC: \ + return 0; \ break; using namespace Dmac; @@ -43,44 +43,44 @@ static uint32 DummyTransferFunction(uint32 address, uint32 size, uint32, bool) } CDMAC::CDMAC(uint8* ram, uint8* spr, uint8* vuMem0, CMIPS& ee) -: m_ram(ram) -, m_spr(spr) -, m_vuMem0(vuMem0) -, m_ee(ee) -, m_D_STAT(0) -, m_D_ENABLE(0) -, m_D0(*this, 0, DummyTransferFunction) -, m_D1(*this, 1, DummyTransferFunction) -, m_D2(*this, 2, DummyTransferFunction) -, m_D3_CHCR(0) -, m_D3_MADR(0) -, m_D3_QWC(0) -, m_D4(*this, 4, DummyTransferFunction) -, m_D5_CHCR(0) -, m_D5_MADR(0) -, m_D5_QWC(0) -, m_D6_CHCR(0) -, m_D6_MADR(0) -, m_D6_QWC(0) -, m_D6_TADR(0) -, m_D8(*this, 8, std::bind(&CDMAC::ReceiveDMA8, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)) -, m_D8_SADR(0) -, m_D9(*this, 9, std::bind(&CDMAC::ReceiveDMA9, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)) -, m_D9_SADR(0) + : m_ram(ram) + , m_spr(spr) + , m_vuMem0(vuMem0) + , m_ee(ee) + , m_D_STAT(0) + , m_D_ENABLE(0) + , m_D0(*this, 0, DummyTransferFunction) + , m_D1(*this, 1, DummyTransferFunction) + , m_D2(*this, 2, DummyTransferFunction) + , m_D3_CHCR(0) + , m_D3_MADR(0) + , m_D3_QWC(0) + , m_D4(*this, 4, DummyTransferFunction) + , m_D5_CHCR(0) + , m_D5_MADR(0) + , m_D5_QWC(0) + , m_D6_CHCR(0) + , m_D6_MADR(0) + , m_D6_QWC(0) + , m_D6_TADR(0) + , m_D8(*this, 8, std::bind(&CDMAC::ReceiveDMA8, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)) + , m_D8_SADR(0) + , m_D9(*this, 9, std::bind(&CDMAC::ReceiveDMA9, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)) + , m_D9_SADR(0) { Reset(); } void CDMAC::Reset() { - m_D_CTRL <<= 0; - m_D_STAT = 0; - m_D_ENABLE = 0; - m_D_PCR = 0; - m_D_SQWC <<= 0; - m_D_RBSR = 0; - m_D_RBOR = 0; - m_D_STADR = 0; + m_D_CTRL <<= 0; + m_D_STAT = 0; + m_D_ENABLE = 0; + m_D_PCR = 0; + m_D_SQWC <<= 0; + m_D_RBSR = 0; + m_D_RBOR = 0; + m_D_STADR = 0; //Reset Channel 0 m_D0.Reset(); @@ -149,8 +149,8 @@ void CDMAC::SetChannelTransferFunction(unsigned int channel, const DmaReceiveHan bool CDMAC::IsInterruptPending() { - uint16 mask = static_cast((m_D_STAT & 0x63FF0000) >> 16); - uint16 status = static_cast((m_D_STAT & 0x0000E3FF) >> 0); + uint16 mask = static_cast((m_D_STAT & 0x63FF0000) >> 16); + uint16 status = static_cast((m_D_STAT & 0x0000E3FF) >> 0); return ((mask & status) != 0); } @@ -188,8 +188,8 @@ uint32 CDMAC::ResumeDMA3(const void* pBuffer, uint32 nSize) memcpy(pDst, pBuffer, nSize * 0x10); - m_D3_MADR += (nSize * 0x10); - m_D3_QWC -= nSize; + m_D3_MADR += (nSize * 0x10); + m_D3_QWC -= nSize; if(m_D3_QWC == 0) { @@ -299,17 +299,17 @@ uint32 CDMAC::GetRegister(uint32 nAddress) switch(nAddress) { - //Channel 0 - REGISTER_READ(D0_CHCR, m_D0.ReadCHCR()) - REGISTER_READ(D0_MADR, m_D0.m_nMADR) - REGISTER_READ(D0_QWC, m_D0.m_nQWC) - REGISTER_READ(D0_TADR, m_D0.m_nTADR) - - //Channel 1 - REGISTER_READ(D1_CHCR, m_D1.ReadCHCR()) - REGISTER_READ(D1_MADR, m_D1.m_nMADR) - REGISTER_READ(D1_QWC, m_D1.m_nQWC) - REGISTER_READ(D1_TADR, m_D1.m_nTADR) + //Channel 0 + REGISTER_READ(D0_CHCR, m_D0.ReadCHCR()) + REGISTER_READ(D0_MADR, m_D0.m_nMADR) + REGISTER_READ(D0_QWC, m_D0.m_nQWC) + REGISTER_READ(D0_TADR, m_D0.m_nTADR) + + //Channel 1 + REGISTER_READ(D1_CHCR, m_D1.ReadCHCR()) + REGISTER_READ(D1_MADR, m_D1.m_nMADR) + REGISTER_READ(D1_QWC, m_D1.m_nQWC) + REGISTER_READ(D1_TADR, m_D1.m_nTADR) case D1_CHCR + 0x1: //This is done by FFXII @@ -321,11 +321,11 @@ uint32 CDMAC::GetRegister(uint32 nAddress) return m_D1.ReadCHCR() >> 16; break; - //Channel 2 - REGISTER_READ(D2_CHCR, m_D2.ReadCHCR()) - REGISTER_READ(D2_MADR, m_D2.m_nMADR) - REGISTER_READ(D2_QWC, m_D2.m_nQWC) - REGISTER_READ(D2_TADR, m_D2.m_nTADR) + //Channel 2 + REGISTER_READ(D2_CHCR, m_D2.ReadCHCR()) + REGISTER_READ(D2_MADR, m_D2.m_nMADR) + REGISTER_READ(D2_QWC, m_D2.m_nQWC) + REGISTER_READ(D2_TADR, m_D2.m_nTADR) case D2_CHCR + 0x1: //This is done by Parappa The Rapper 2 @@ -400,23 +400,23 @@ uint32 CDMAC::GetRegister(uint32 nAddress) return 0; break; - //Channel 8 - REGISTER_READ(D8_CHCR, m_D8.ReadCHCR()) - REGISTER_READ(D8_MADR, m_D8.m_nMADR) - REGISTER_READ(D8_QWC, m_D8.m_nQWC) - REGISTER_READ(D8_SADR, m_D8_SADR) + //Channel 8 + REGISTER_READ(D8_CHCR, m_D8.ReadCHCR()) + REGISTER_READ(D8_MADR, m_D8.m_nMADR) + REGISTER_READ(D8_QWC, m_D8.m_nQWC) + REGISTER_READ(D8_SADR, m_D8_SADR) case D8_CHCR + 0x1: //This is done by Front Mission 4 return m_D8.ReadCHCR() >> 8; break; - //Channel 9 - REGISTER_READ(D9_CHCR, m_D9.ReadCHCR()) - REGISTER_READ(D9_MADR, m_D9.m_nMADR) - REGISTER_READ(D9_QWC, m_D9.m_nQWC) - REGISTER_READ(D9_TADR, m_D9.m_nTADR) - REGISTER_READ(D9_SADR, m_D9_SADR) + //Channel 9 + REGISTER_READ(D9_CHCR, m_D9.ReadCHCR()) + REGISTER_READ(D9_MADR, m_D9.m_nMADR) + REGISTER_READ(D9_QWC, m_D9.m_nQWC) + REGISTER_READ(D9_TADR, m_D9.m_nTADR) + REGISTER_READ(D9_SADR, m_D9_SADR) //General Registers case D_CTRL: @@ -635,7 +635,7 @@ void CDMAC::SetRegister(uint32 nAddress, uint32 nData) { m_receiveDma5(m_D5_MADR, m_D5_QWC * 0x10, 0, false); m_D5_CHCR &= ~CHCR_STR; - m_D_STAT |= (1 << CHANNEL_ID_SIF0); + m_D_STAT |= (1 << CHANNEL_ID_SIF0); } break; case D5_CHCR + 0x4: @@ -789,19 +789,19 @@ void CDMAC::SetRegister(uint32 nAddress, uint32 nData) break; case D_STAT + 0x0: - { - uint32 nStat = nData & 0x0000FFFF; - uint32 nMask = nData & 0xFFFF0000; + { + uint32 nStat = nData & 0x0000FFFF; + uint32 nMask = nData & 0xFFFF0000; - //Set the masks - m_D_STAT ^= nMask; + //Set the masks + m_D_STAT ^= nMask; - //Clear the interrupt status - m_D_STAT &= ~nStat; + //Clear the interrupt status + m_D_STAT &= ~nStat; - UpdateCpCond(); - } - break; + UpdateCpCond(); + } + break; case D_STAT + 0x4: case D_STAT + 0x8: case D_STAT + 0xC: @@ -866,22 +866,21 @@ void CDMAC::SetRegister(uint32 nAddress, uint32 nData) #ifdef _DEBUG DisassembleSet(nAddress, nData); #endif - } void CDMAC::LoadState(Framework::CZipArchiveReader& archive) { CRegisterStateFile registerFile(*archive.BeginReadFile(STATE_REGS_XML)); - m_D_CTRL <<= registerFile.GetRegister32(STATE_REGS_CTRL); - m_D_STAT = registerFile.GetRegister32(STATE_REGS_STAT); - m_D_ENABLE = registerFile.GetRegister32(STATE_REGS_ENABLE); - m_D_PCR = registerFile.GetRegister32(STATE_REGS_PCR); - m_D_SQWC <<= registerFile.GetRegister32(STATE_REGS_SQWC); - m_D_RBSR = registerFile.GetRegister32(STATE_REGS_RBSR); - m_D_RBOR = registerFile.GetRegister32(STATE_REGS_RBOR); - m_D_STADR = registerFile.GetRegister32(STATE_REGS_STADR); - m_D8_SADR = registerFile.GetRegister32(STATE_REGS_D8_SADR); - m_D9_SADR = registerFile.GetRegister32(STATE_REGS_D9_SADR); + m_D_CTRL <<= registerFile.GetRegister32(STATE_REGS_CTRL); + m_D_STAT = registerFile.GetRegister32(STATE_REGS_STAT); + m_D_ENABLE = registerFile.GetRegister32(STATE_REGS_ENABLE); + m_D_PCR = registerFile.GetRegister32(STATE_REGS_PCR); + m_D_SQWC <<= registerFile.GetRegister32(STATE_REGS_SQWC); + m_D_RBSR = registerFile.GetRegister32(STATE_REGS_RBSR); + m_D_RBOR = registerFile.GetRegister32(STATE_REGS_RBOR); + m_D_STADR = registerFile.GetRegister32(STATE_REGS_STADR); + m_D8_SADR = registerFile.GetRegister32(STATE_REGS_D8_SADR); + m_D9_SADR = registerFile.GetRegister32(STATE_REGS_D9_SADR); m_D0.LoadState(archive); m_D1.LoadState(archive); @@ -894,14 +893,14 @@ void CDMAC::LoadState(Framework::CZipArchiveReader& archive) void CDMAC::SaveState(Framework::CZipArchiveWriter& archive) { CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML); - registerFile->SetRegister32(STATE_REGS_CTRL, m_D_CTRL); - registerFile->SetRegister32(STATE_REGS_STAT, m_D_STAT); - registerFile->SetRegister32(STATE_REGS_ENABLE, m_D_ENABLE); - registerFile->SetRegister32(STATE_REGS_PCR, m_D_PCR); - registerFile->SetRegister32(STATE_REGS_SQWC, m_D_SQWC); - registerFile->SetRegister32(STATE_REGS_RBSR, m_D_RBSR); - registerFile->SetRegister32(STATE_REGS_RBOR, m_D_RBOR); - registerFile->SetRegister32(STATE_REGS_STADR, m_D_STADR); + registerFile->SetRegister32(STATE_REGS_CTRL, m_D_CTRL); + registerFile->SetRegister32(STATE_REGS_STAT, m_D_STAT); + registerFile->SetRegister32(STATE_REGS_ENABLE, m_D_ENABLE); + registerFile->SetRegister32(STATE_REGS_PCR, m_D_PCR); + registerFile->SetRegister32(STATE_REGS_SQWC, m_D_SQWC); + registerFile->SetRegister32(STATE_REGS_RBSR, m_D_RBSR); + registerFile->SetRegister32(STATE_REGS_RBOR, m_D_RBOR); + registerFile->SetRegister32(STATE_REGS_STADR, m_D_STADR); registerFile->SetRegister32(STATE_REGS_D8_SADR, m_D8_SADR); registerFile->SetRegister32(STATE_REGS_D9_SADR, m_D9_SADR); archive.InsertFile(registerFile); @@ -931,7 +930,10 @@ void CDMAC::UpdateCpCond() void CDMAC::DisassembleGet(uint32 nAddress) { -#define LOG_GET(registerId) case registerId: CLog::GetInstance().Print(LOG_NAME, "= " #registerId ".\r\n"); break; +#define LOG_GET(registerId) \ + case registerId: \ + CLog::GetInstance().Print(LOG_NAME, "= " #registerId ".\r\n"); \ + break; switch(nAddress) { @@ -990,7 +992,10 @@ void CDMAC::DisassembleGet(uint32 nAddress) void CDMAC::DisassembleSet(uint32 nAddress, uint32 nData) { -#define LOG_SET(registerId) case registerId: CLog::GetInstance().Print(LOG_NAME, #registerId " = 0x%08X.\r\n", nData); break; +#define LOG_SET(registerId) \ + case registerId: \ + CLog::GetInstance().Print(LOG_NAME, #registerId " = 0x%08X.\r\n", nData); \ + break; switch(nAddress) { diff --git a/Source/ee/DMAC.h b/Source/ee/DMAC.h index 33094b7f7..53470f4fc 100644 --- a/Source/ee/DMAC.h +++ b/Source/ee/DMAC.h @@ -28,167 +28,167 @@ public: enum REGISTER { - D0_CHCR = 0x10008000, - D0_MADR = 0x10008010, - D0_QWC = 0x10008020, - D0_TADR = 0x10008030, + D0_CHCR = 0x10008000, + D0_MADR = 0x10008010, + D0_QWC = 0x10008020, + D0_TADR = 0x10008030, - D1_CHCR = 0x10009000, - D1_MADR = 0x10009010, - D1_QWC = 0x10009020, - D1_TADR = 0x10009030, + D1_CHCR = 0x10009000, + D1_MADR = 0x10009010, + D1_QWC = 0x10009020, + D1_TADR = 0x10009030, - D2_CHCR = 0x1000A000, - D2_MADR = 0x1000A010, - D2_QWC = 0x1000A020, - D2_TADR = 0x1000A030, - - D3_CHCR = 0x1000B000, - D3_MADR = 0x1000B010, - D3_QWC = 0x1000B020, + D2_CHCR = 0x1000A000, + D2_MADR = 0x1000A010, + D2_QWC = 0x1000A020, + D2_TADR = 0x1000A030, - D4_CHCR = 0x1000B400, - D4_MADR = 0x1000B410, - D4_QWC = 0x1000B420, - D4_TADR = 0x1000B430, + D3_CHCR = 0x1000B000, + D3_MADR = 0x1000B010, + D3_QWC = 0x1000B020, - D5_CHCR = 0x1000C000, - D5_MADR = 0x1000C010, - D5_QWC = 0x1000C020, + D4_CHCR = 0x1000B400, + D4_MADR = 0x1000B410, + D4_QWC = 0x1000B420, + D4_TADR = 0x1000B430, - D6_CHCR = 0x1000C400, - D6_MADR = 0x1000C410, - D6_QWC = 0x1000C420, - D6_TADR = 0x1000C430, + D5_CHCR = 0x1000C000, + D5_MADR = 0x1000C010, + D5_QWC = 0x1000C020, - D8_CHCR = 0x1000D000, - D8_MADR = 0x1000D010, - D8_QWC = 0x1000D020, - D8_SADR = 0x1000D080, + D6_CHCR = 0x1000C400, + D6_MADR = 0x1000C410, + D6_QWC = 0x1000C420, + D6_TADR = 0x1000C430, - D9_CHCR = 0x1000D400, - D9_MADR = 0x1000D410, - D9_QWC = 0x1000D420, - D9_TADR = 0x1000D430, - D9_SADR = 0x1000D480, + D8_CHCR = 0x1000D000, + D8_MADR = 0x1000D010, + D8_QWC = 0x1000D020, + D8_SADR = 0x1000D080, - D_CTRL = 0x1000E000, - D_STAT = 0x1000E010, - D_PCR = 0x1000E020, - D_SQWC = 0x1000E030, - D_RBSR = 0x1000E040, - D_RBOR = 0x1000E050, - D_STADR = 0x1000E060, + D9_CHCR = 0x1000D400, + D9_MADR = 0x1000D410, + D9_QWC = 0x1000D420, + D9_TADR = 0x1000D430, + D9_SADR = 0x1000D480, - D_ENABLER = 0x1000F520, - D_ENABLEW = 0x1000F590, + D_CTRL = 0x1000E000, + D_STAT = 0x1000E010, + D_PCR = 0x1000E020, + D_SQWC = 0x1000E030, + D_RBSR = 0x1000E040, + D_RBOR = 0x1000E050, + D_STADR = 0x1000E060, + + D_ENABLER = 0x1000F520, + D_ENABLEW = 0x1000F590, }; enum CHCR_BIT { - CHCR_STR = 0x100, + CHCR_STR = 0x100, }; enum ENABLE_BIT { - ENABLE_CPND = 0x10000, + ENABLE_CPND = 0x10000, }; - CDMAC(uint8*, uint8*, uint8*, CMIPS&); - virtual ~CDMAC() = default; + CDMAC(uint8*, uint8*, uint8*, CMIPS&); + virtual ~CDMAC() = default; - void Reset(); + void Reset(); - void SetChannelTransferFunction(unsigned int, const Dmac::DmaReceiveHandler&); + void SetChannelTransferFunction(unsigned int, const Dmac::DmaReceiveHandler&); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); - void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); - void DisassembleGet(uint32); - void DisassembleSet(uint32, uint32); + void DisassembleGet(uint32); + void DisassembleSet(uint32, uint32); - bool IsInterruptPending(); - void ResumeDMA0(); - void ResumeDMA1(); - void ResumeDMA2(); - uint32 ResumeDMA3(const void*, uint32); - void ResumeDMA4(); - void ResumeDMA8(); - bool IsDMA4Started() const; - static bool IsEndTagId(uint32); + bool IsInterruptPending(); + void ResumeDMA0(); + void ResumeDMA1(); + void ResumeDMA2(); + uint32 ResumeDMA3(const void*, uint32); + void ResumeDMA4(); + void ResumeDMA8(); + bool IsDMA4Started() const; + static bool IsEndTagId(uint32); private: struct D_CTRL_REG : public convertible { - unsigned int dmae : 1; - unsigned int rele : 1; - unsigned int mfd : 2; - unsigned int sts : 2; - unsigned int std : 2; - unsigned int rcyc : 3; - unsigned int reserved : 21; + unsigned int dmae : 1; + unsigned int rele : 1; + unsigned int mfd : 2; + unsigned int sts : 2; + unsigned int std : 2; + unsigned int rcyc : 3; + unsigned int reserved : 21; }; static_assert(sizeof(D_CTRL_REG) == sizeof(uint32), "Size of D_CTRL_REG struct must be 4 bytes."); struct D_SQWC_REG : public convertible { - unsigned int sqwc : 8; - unsigned int reserved0 : 8; - unsigned int tqwc : 8; - unsigned int reserved1 : 8; + unsigned int sqwc : 8; + unsigned int reserved0 : 8; + unsigned int tqwc : 8; + unsigned int reserved1 : 8; }; static_assert(sizeof(D_SQWC_REG) == sizeof(uint32), "Size of D_SQWC_REG struct must be 4 bytes."); - uint64 FetchDMATag(uint32); + uint64 FetchDMATag(uint32); - uint32 ReceiveDMA8(uint32, uint32, uint32, bool); - uint32 ReceiveDMA9(uint32, uint32, uint32, bool); + uint32 ReceiveDMA8(uint32, uint32, uint32, bool); + uint32 ReceiveDMA9(uint32, uint32, uint32, bool); - void UpdateCpCond(); + void UpdateCpCond(); - D_CTRL_REG m_D_CTRL; - uint32 m_D_STAT; - uint32 m_D_ENABLE; - uint32 m_D_PCR; - D_SQWC_REG m_D_SQWC; - uint32 m_D_RBSR; - uint32 m_D_RBOR; - uint32 m_D_STADR; + D_CTRL_REG m_D_CTRL; + uint32 m_D_STAT; + uint32 m_D_ENABLE; + uint32 m_D_PCR; + D_SQWC_REG m_D_SQWC; + uint32 m_D_RBSR; + uint32 m_D_RBOR; + uint32 m_D_STADR; - Dmac::CChannel m_D0; - Dmac::CChannel m_D1; + Dmac::CChannel m_D0; + Dmac::CChannel m_D1; - Dmac::CChannel m_D2; + Dmac::CChannel m_D2; - uint32 m_D3_CHCR; - uint32 m_D3_MADR; - uint32 m_D3_QWC; + uint32 m_D3_CHCR; + uint32 m_D3_MADR; + uint32 m_D3_QWC; - Dmac::CChannel m_D4; + Dmac::CChannel m_D4; - uint32 m_D5_CHCR; - uint32 m_D5_MADR; - uint32 m_D5_QWC; + uint32 m_D5_CHCR; + uint32 m_D5_MADR; + uint32 m_D5_QWC; - uint32 m_D6_CHCR; - uint32 m_D6_MADR; - uint32 m_D6_QWC; - uint32 m_D6_TADR; + uint32 m_D6_CHCR; + uint32 m_D6_MADR; + uint32 m_D6_QWC; + uint32 m_D6_TADR; - Dmac::CChannel m_D8; - uint32 m_D8_SADR; + Dmac::CChannel m_D8; + uint32 m_D8_SADR; - Dmac::CChannel m_D9; - uint32 m_D9_SADR; + Dmac::CChannel m_D9; + uint32 m_D9_SADR; - uint8* m_ram; - uint8* m_spr; - uint8* m_vuMem0; + uint8* m_ram; + uint8* m_spr; + uint8* m_vuMem0; - CMIPS& m_ee; + CMIPS& m_ee; Dmac::DmaReceiveHandler m_receiveDma5; Dmac::DmaReceiveHandler m_receiveDma6; diff --git a/Source/ee/Dmac_Channel.cpp b/Source/ee/Dmac_Channel.cpp index eb2532914..903fe3e4c 100644 --- a/Source/ee/Dmac_Channel.cpp +++ b/Source/ee/Dmac_Channel.cpp @@ -6,51 +6,50 @@ #include "Dmac_Channel.h" #include "DMAC.h" -#define LOG_NAME ("dmac") -#define STATE_REGS_XML_FORMAT ("dmac/channel_%d.xml") -#define STATE_REGS_CHCR ("CHCR") -#define STATE_REGS_MADR ("MADR") -#define STATE_REGS_QWC ("QWC") -#define STATE_REGS_TADR ("TADR") -#define STATE_REGS_SCCTRL ("SCCTRL") -#define STATE_REGS_ASR0 ("ASR0") -#define STATE_REGS_ASR1 ("ASR1") +#define LOG_NAME ("dmac") +#define STATE_REGS_XML_FORMAT ("dmac/channel_%d.xml") +#define STATE_REGS_CHCR ("CHCR") +#define STATE_REGS_MADR ("MADR") +#define STATE_REGS_QWC ("QWC") +#define STATE_REGS_TADR ("TADR") +#define STATE_REGS_SCCTRL ("SCCTRL") +#define STATE_REGS_ASR0 ("ASR0") +#define STATE_REGS_ASR1 ("ASR1") #define DMATAG_IRQ 0x8000 -#define DMATAG_ID 0x7000 +#define DMATAG_ID 0x7000 using namespace Dmac; -CChannel::CChannel(CDMAC& dmac, unsigned int nNumber, const DmaReceiveHandler& pReceive) -: m_dmac(dmac) -, m_number(nNumber) -, m_receive(pReceive) +CChannel::CChannel(CDMAC& dmac, unsigned int nNumber, const DmaReceiveHandler& pReceive) + : m_dmac(dmac) + , m_number(nNumber) + , m_receive(pReceive) { - } void CChannel::Reset() { memset(&m_CHCR, 0, sizeof(CHCR)); - m_nMADR = 0; - m_nQWC = 0; - m_nTADR = 0; - m_nSCCTRL = 0; - m_nASR[0] = 0; - m_nASR[1] = 0; + m_nMADR = 0; + m_nQWC = 0; + m_nTADR = 0; + m_nSCCTRL = 0; + m_nASR[0] = 0; + m_nASR[1] = 0; } void CChannel::SaveState(Framework::CZipArchiveWriter& archive) { auto path = string_format(STATE_REGS_XML_FORMAT, m_number); CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str()); - registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR); - registerFile->SetRegister32(STATE_REGS_MADR, m_nMADR); - registerFile->SetRegister32(STATE_REGS_QWC, m_nQWC); - registerFile->SetRegister32(STATE_REGS_TADR, m_nTADR); - registerFile->SetRegister32(STATE_REGS_SCCTRL, m_nSCCTRL); - registerFile->SetRegister32(STATE_REGS_ASR0, m_nASR[0]); - registerFile->SetRegister32(STATE_REGS_ASR1, m_nASR[1]); + registerFile->SetRegister32(STATE_REGS_CHCR, m_CHCR); + registerFile->SetRegister32(STATE_REGS_MADR, m_nMADR); + registerFile->SetRegister32(STATE_REGS_QWC, m_nQWC); + registerFile->SetRegister32(STATE_REGS_TADR, m_nTADR); + registerFile->SetRegister32(STATE_REGS_SCCTRL, m_nSCCTRL); + registerFile->SetRegister32(STATE_REGS_ASR0, m_nASR[0]); + registerFile->SetRegister32(STATE_REGS_ASR1, m_nASR[1]); archive.InsertFile(registerFile); } @@ -58,13 +57,13 @@ void CChannel::LoadState(Framework::CZipArchiveReader& archive) { auto path = string_format(STATE_REGS_XML_FORMAT, m_number); CRegisterStateFile registerFile(*archive.BeginReadFile(path.c_str())); - m_CHCR <<= registerFile.GetRegister32(STATE_REGS_CHCR); - m_nMADR = registerFile.GetRegister32(STATE_REGS_MADR); - m_nQWC = registerFile.GetRegister32(STATE_REGS_QWC); - m_nTADR = registerFile.GetRegister32(STATE_REGS_TADR); - m_nSCCTRL = registerFile.GetRegister32(STATE_REGS_SCCTRL); - m_nASR[0] = registerFile.GetRegister32(STATE_REGS_ASR0); - m_nASR[1] = registerFile.GetRegister32(STATE_REGS_ASR1); + m_CHCR <<= registerFile.GetRegister32(STATE_REGS_CHCR); + m_nMADR = registerFile.GetRegister32(STATE_REGS_MADR); + m_nQWC = registerFile.GetRegister32(STATE_REGS_QWC); + m_nTADR = registerFile.GetRegister32(STATE_REGS_TADR); + m_nSCCTRL = registerFile.GetRegister32(STATE_REGS_SCCTRL); + m_nASR[0] = registerFile.GetRegister32(STATE_REGS_ASR0); + m_nASR[1] = registerFile.GetRegister32(STATE_REGS_ASR1); } uint32 CChannel::ReadCHCR() @@ -130,7 +129,7 @@ void CChannel::Execute() } break; case 0x01: - case 0x03: //FFXII uses 3 here, assuming source chain mode + case 0x03: //FFXII uses 3 here, assuming source chain mode ExecuteSourceChain(); break; default: @@ -172,8 +171,8 @@ void CChannel::ExecuteNormal() uint32 nRecv = m_receive(m_nMADR, qwc, m_CHCR.nDIR, false); - m_nMADR += nRecv * 0x10; - m_nQWC -= nRecv; + m_nMADR += nRecv * 0x10; + m_nQWC -= nRecv; if(m_nQWC == 0) { @@ -198,12 +197,12 @@ void CChannel::ExecuteInterleave() { //Transfer { - uint32 qwc = m_dmac.m_D_SQWC.tqwc; + uint32 qwc = m_dmac.m_D_SQWC.tqwc; uint32 recv = m_receive(m_nMADR, qwc, CHCR_DIR_FROM, false); assert(recv == qwc); m_nMADR += recv * 0x10; - m_nQWC -= recv; + m_nQWC -= recv; } //Skip @@ -265,8 +264,8 @@ void CChannel::ExecuteSourceChain() { uint32 nRecv = m_receive(m_nMADR, m_nQWC, CHCR_DIR_FROM, false); - m_nMADR += nRecv * 0x10; - m_nQWC -= nRecv; + m_nMADR += nRecv * 0x10; + m_nQWC -= nRecv; if(m_nQWC != 0) { @@ -368,36 +367,36 @@ void CChannel::ExecuteSourceChain() { case DMATAG_REFE: //REFE - Data to transfer is pointer in memory address, transfer is done - m_nMADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); - m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); - m_nTADR = m_nTADR + 0x10; + m_nMADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); + m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); + m_nTADR = m_nTADR + 0x10; break; case DMATAG_CNT: //CNT - Data to transfer is after the tag, next tag is after the data - m_nMADR = m_nTADR + 0x10; - m_nQWC = (uint32)(nTag & 0xFFFF); - m_nTADR = (m_nQWC * 0x10) + m_nMADR; + m_nMADR = m_nTADR + 0x10; + m_nQWC = (uint32)(nTag & 0xFFFF); + m_nTADR = (m_nQWC * 0x10) + m_nMADR; break; case DMATAG_NEXT: //NEXT - Transfers data after tag, next tag is at position in ADDR field - m_nMADR = m_nTADR + 0x10; - m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); - m_nTADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); + m_nMADR = m_nTADR + 0x10; + m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); + m_nTADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); break; case DMATAG_REF: case DMATAG_REFS: //REF/REFS - Data to transfer is pointed in memory address, next tag is after this tag - m_nMADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); - m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); - m_nTADR = m_nTADR + 0x10; + m_nMADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); + m_nQWC = (uint32)((nTag >> 0) & 0x0000FFFF); + m_nTADR = m_nTADR + 0x10; break; case DMATAG_CALL: //CALL - Transfers QWC after the tag, saves next address in ASR, TADR = ADDR assert(m_CHCR.nASP < 2); - m_nMADR = m_nTADR + 0x10; - m_nQWC = (uint32)(nTag & 0xFFFF); - m_nASR[m_CHCR.nASP] = m_nMADR + (m_nQWC * 0x10); - m_nTADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); + m_nMADR = m_nTADR + 0x10; + m_nQWC = (uint32)(nTag & 0xFFFF); + m_nASR[m_CHCR.nASP] = m_nMADR + (m_nQWC * 0x10); + m_nTADR = (uint32)((nTag >> 32) & 0xFFFFFFFF); m_CHCR.nASP++; break; case DMATAG_RET: @@ -409,15 +408,15 @@ void CChannel::ExecuteSourceChain() m_CHCR.nASP--; m_nTADR = m_nASR[m_CHCR.nASP]; } - else + else { m_nSCCTRL |= SCCTRL_RETTOP; } break; case DMATAG_END: //END - Data to transfer is after the tag, transfer is finished - m_nMADR = m_nTADR + 0x10; - m_nQWC = (uint32)(nTag & 0xFFFF); + m_nMADR = m_nTADR + 0x10; + m_nQWC = (uint32)(nTag & 0xFFFF); break; default: m_nQWC = 0; @@ -446,8 +445,8 @@ void CChannel::ExecuteSourceChain() { uint32 nRecv = m_receive(m_nMADR, qwc, CHCR_DIR_FROM, false); - m_nMADR += nRecv * 0x10; - m_nQWC -= nRecv; + m_nMADR += nRecv * 0x10; + m_nQWC -= nRecv; } if(isMfifo) diff --git a/Source/ee/Dmac_Channel.h b/Source/ee/Dmac_Channel.h index 63d3aa959..cf4d18462 100644 --- a/Source/ee/Dmac_Channel.h +++ b/Source/ee/Dmac_Channel.h @@ -10,7 +10,7 @@ class CDMAC; namespace Dmac { - typedef std::function DmaReceiveHandler; + typedef std::function DmaReceiveHandler; class CChannel { @@ -29,57 +29,56 @@ namespace Dmac enum CHCR_DIR { - CHCR_DIR_TO = 0, + CHCR_DIR_TO = 0, CHCR_DIR_FROM = 1, }; struct CHCR : public convertible { - unsigned int nDIR : 1; - unsigned int nReserved0 : 1; - unsigned int nMOD : 2; - unsigned int nASP : 2; - unsigned int nTTE : 1; - unsigned int nTIE : 1; - unsigned int nSTR : 1; - unsigned int nReserved1 : 7; - unsigned int nTAG : 16; + unsigned int nDIR : 1; + unsigned int nReserved0 : 1; + unsigned int nMOD : 2; + unsigned int nASP : 2; + unsigned int nTTE : 1; + unsigned int nTIE : 1; + unsigned int nSTR : 1; + unsigned int nReserved1 : 7; + unsigned int nTAG : 16; }; + CChannel(CDMAC&, unsigned int, const DmaReceiveHandler&); + virtual ~CChannel() = default; - CChannel(CDMAC&, unsigned int, const DmaReceiveHandler&); - virtual ~CChannel() = default; + void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); - void LoadState(Framework::CZipArchiveReader&); + void Reset(); + uint32 ReadCHCR(); + void WriteCHCR(uint32); + void Execute(); + void ExecuteNormal(); + void ExecuteInterleave(); + void ExecuteSourceChain(); + void SetReceiveHandler(const DmaReceiveHandler&); - void Reset(); - uint32 ReadCHCR(); - void WriteCHCR(uint32); - void Execute(); - void ExecuteNormal(); - void ExecuteInterleave(); - void ExecuteSourceChain(); - void SetReceiveHandler(const DmaReceiveHandler&); - - CHCR m_CHCR; - uint32 m_nMADR; - uint32 m_nQWC; - uint32 m_nTADR; - uint32 m_nASR[2]; + CHCR m_CHCR; + uint32 m_nMADR; + uint32 m_nQWC; + uint32 m_nTADR; + uint32 m_nASR[2]; private: enum SCCTRL_BIT { - SCCTRL_RETTOP = 0x001, - SCCTRL_INITXFER = 0x200, + SCCTRL_RETTOP = 0x001, + SCCTRL_INITXFER = 0x200, }; - void ClearSTR(); + void ClearSTR(); - unsigned int m_number = 0; - uint32 m_nSCCTRL; - DmaReceiveHandler m_receive; - CDMAC& m_dmac; + unsigned int m_number = 0; + uint32 m_nSCCTRL; + DmaReceiveHandler m_receive; + CDMAC& m_dmac; }; }; diff --git a/Source/ee/EEAssembler.cpp b/Source/ee/EEAssembler.cpp index 7d9d1df2d..bd232124d 100644 --- a/Source/ee/EEAssembler.cpp +++ b/Source/ee/EEAssembler.cpp @@ -1,9 +1,8 @@ #include "EEAssembler.h" CEEAssembler::CEEAssembler(uint32* ptr) -: CMIPSAssembler(ptr) + : CMIPSAssembler(ptr) { - } void CEEAssembler::LQ(unsigned int rt, uint16 offset, unsigned int base) diff --git a/Source/ee/EEAssembler.h b/Source/ee/EEAssembler.h index e8cfed2e9..26e361960 100644 --- a/Source/ee/EEAssembler.h +++ b/Source/ee/EEAssembler.h @@ -5,26 +5,26 @@ class CEEAssembler : public CMIPSAssembler { public: - CEEAssembler(uint32*); + CEEAssembler(uint32*); - void LQ(unsigned int, uint16, unsigned int); - void MFHI1(unsigned int); - void MFLO1(unsigned int); - void MTHI1(unsigned int); - void MTLO1(unsigned int); - void PADDW(unsigned int, unsigned int, unsigned int); - void PEXCH(unsigned int, unsigned int); - void PEXTLB(unsigned int, unsigned int, unsigned int); - void PEXTUB(unsigned int, unsigned int, unsigned int); - void PEXTLH(unsigned int, unsigned int, unsigned int); - void PEXTUH(unsigned int, unsigned int, unsigned int); - void PEXCW(unsigned int, unsigned int); - void PMFLO(unsigned int); - void PMFHI(unsigned int); - void PMFHL_UW(unsigned int); - void PMFHL_LH(unsigned int); - void PMULTH(unsigned int, unsigned int, unsigned int); - void PPACH(unsigned int, unsigned int, unsigned int); - void PPACW(unsigned int, unsigned int, unsigned int); - void SQ(unsigned int, uint16, unsigned int); + void LQ(unsigned int, uint16, unsigned int); + void MFHI1(unsigned int); + void MFLO1(unsigned int); + void MTHI1(unsigned int); + void MTLO1(unsigned int); + void PADDW(unsigned int, unsigned int, unsigned int); + void PEXCH(unsigned int, unsigned int); + void PEXTLB(unsigned int, unsigned int, unsigned int); + void PEXTUB(unsigned int, unsigned int, unsigned int); + void PEXTLH(unsigned int, unsigned int, unsigned int); + void PEXTUH(unsigned int, unsigned int, unsigned int); + void PEXCW(unsigned int, unsigned int); + void PMFLO(unsigned int); + void PMFHI(unsigned int); + void PMFHL_UW(unsigned int); + void PMFHL_LH(unsigned int); + void PMULTH(unsigned int, unsigned int, unsigned int); + void PPACH(unsigned int, unsigned int, unsigned int); + void PPACW(unsigned int, unsigned int, unsigned int); + void SQ(unsigned int, uint16, unsigned int); }; diff --git a/Source/ee/EeExecutor.cpp b/Source/ee/EeExecutor.cpp index f4f74606f..d8fab6c6e 100644 --- a/Source/ee/EeExecutor.cpp +++ b/Source/ee/EeExecutor.cpp @@ -12,18 +12,18 @@ #if TARGET_CPU_ARM #define DISABLE_PROTECTION -#define STATE_FLAVOR ARM_THREAD_STATE32 -#define STATE_FLAVOR_COUNT ARM_THREAD_STATE32_COUNT +#define STATE_FLAVOR ARM_THREAD_STATE32 +#define STATE_FLAVOR_COUNT ARM_THREAD_STATE32_COUNT #elif TARGET_CPU_ARM64 #define DISABLE_PROTECTION -#define STATE_FLAVOR ARM_THREAD_STATE64 -#define STATE_FLAVOR_COUNT ARM_THREAD_STATE64_COUNT +#define STATE_FLAVOR ARM_THREAD_STATE64 +#define STATE_FLAVOR_COUNT ARM_THREAD_STATE64_COUNT #elif TARGET_CPU_X86 -#define STATE_FLAVOR x86_THREAD_STATE32 -#define STATE_FLAVOR_COUNT x86_THREAD_STATE32_COUNT +#define STATE_FLAVOR x86_THREAD_STATE32 +#define STATE_FLAVOR_COUNT x86_THREAD_STATE32_COUNT #elif TARGET_CPU_X86_64 -#define STATE_FLAVOR x86_THREAD_STATE64 -#define STATE_FLAVOR_COUNT x86_THREAD_STATE64_COUNT +#define STATE_FLAVOR x86_THREAD_STATE64 +#define STATE_FLAVOR_COUNT x86_THREAD_STATE64_COUNT #else #error Unsupported CPU architecture #endif @@ -33,8 +33,8 @@ static CEeExecutor* g_eeExecutor = nullptr; CEeExecutor::CEeExecutor(CMIPS& context, uint8* ram) -: CMipsExecutor(context, 0x20000000) -, m_ram(ram) + : CMipsExecutor(context, 0x20000000) + , m_ram(ram) { m_pageSize = framework_getpagesize(); } @@ -53,9 +53,9 @@ void CEeExecutor::AddExceptionHandler() assert(m_handler != NULL); #elif defined(__unix__) || defined(__ANDROID__) struct sigaction sigAction; - sigAction.sa_handler = nullptr; - sigAction.sa_sigaction = &HandleException; - sigAction.sa_flags = SA_SIGINFO; + sigAction.sa_handler = nullptr; + sigAction.sa_sigaction = &HandleException; + sigAction.sa_flags = SA_SIGINFO; sigemptyset(&sigAction.sa_mask); int result = sigaction(SIGSEGV, &sigAction, nullptr); assert(result >= 0); @@ -64,11 +64,11 @@ void CEeExecutor::AddExceptionHandler() assert(result == KERN_SUCCESS); m_running = true; - m_handlerThread = std::thread([this] () { HandlerThreadProc(); }); + m_handlerThread = std::thread([this]() { HandlerThreadProc(); }); result = mach_port_insert_right(mach_task_self(), m_port, m_port, MACH_MSG_TYPE_MAKE_SEND); assert(result == KERN_SUCCESS); - + result = thread_set_exception_ports(mach_thread_self(), EXC_MASK_BAD_ACCESS, m_port, EXCEPTION_STATE | MACH_EXCEPTION_CODES, STATE_FLAVOR); assert(result == KERN_SUCCESS); @@ -87,9 +87,9 @@ void CEeExecutor::RemoveExceptionHandler() m_running = false; m_handlerThread.join(); #endif - + #endif //!DISABLE_PROTECTION - + g_eeExecutor = nullptr; } @@ -221,38 +221,38 @@ void CEeExecutor::HandlerThreadProc() while(m_running) { kern_return_t result = KERN_SUCCESS; - + INPUT_MESSAGE inMsg; result = mach_msg(&inMsg.head, MACH_RCV_MSG | MACH_RCV_LARGE | MACH_RCV_TIMEOUT, 0, sizeof(inMsg), m_port, 1000, MACH_PORT_NULL); if(result == MACH_RCV_TIMED_OUT) continue; assert(result == KERN_SUCCESS); - - assert(inMsg.head.msgh_id == 2406); //MACH_EXCEPTION_RAISE_RPC - + + assert(inMsg.head.msgh_id == 2406); //MACH_EXCEPTION_RAISE_RPC + bool success = HandleAccessFault(inMsg.code[1]); - + OUTPUT_MESSAGE outMsg; - outMsg.head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(inMsg.head.msgh_bits), 0); - outMsg.head.msgh_remote_port = inMsg.head.msgh_remote_port; - outMsg.head.msgh_local_port = MACH_PORT_NULL; - outMsg.head.msgh_id = inMsg.head.msgh_id + 100; - outMsg.head.msgh_size = sizeof(outMsg); - outMsg.ndr = inMsg.ndr; + outMsg.head.msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(inMsg.head.msgh_bits), 0); + outMsg.head.msgh_remote_port = inMsg.head.msgh_remote_port; + outMsg.head.msgh_local_port = MACH_PORT_NULL; + outMsg.head.msgh_id = inMsg.head.msgh_id + 100; + outMsg.head.msgh_size = sizeof(outMsg); + outMsg.ndr = inMsg.ndr; if(success) { - outMsg.result = KERN_SUCCESS; - outMsg.flavor = STATE_FLAVOR; - outMsg.stateCount = STATE_FLAVOR_COUNT; + outMsg.result = KERN_SUCCESS; + outMsg.flavor = STATE_FLAVOR; + outMsg.stateCount = STATE_FLAVOR_COUNT; memcpy(outMsg.state, inMsg.state, STATE_FLAVOR_COUNT * sizeof(natural_t)); } else { - outMsg.result = KERN_FAILURE; - outMsg.flavor = 0; - outMsg.stateCount = 0; + outMsg.result = KERN_FAILURE; + outMsg.flavor = 0; + outMsg.stateCount = 0; } - + result = mach_msg(&outMsg.head, MACH_SEND_MSG | MACH_RCV_LARGE, sizeof(outMsg), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); assert(result == KERN_SUCCESS); } diff --git a/Source/ee/EeExecutor.h b/Source/ee/EeExecutor.h index ddb54055e..4e4709723 100644 --- a/Source/ee/EeExecutor.h +++ b/Source/ee/EeExecutor.h @@ -14,37 +14,37 @@ class CEeExecutor : public CMipsExecutor { public: - CEeExecutor(CMIPS&, uint8*); - virtual ~CEeExecutor() = default; + CEeExecutor(CMIPS&, uint8*); + virtual ~CEeExecutor() = default; - void AddExceptionHandler(); - void RemoveExceptionHandler(); - - void Reset() override; - void ClearActiveBlocksInRange(uint32, uint32) override; + void AddExceptionHandler(); + void RemoveExceptionHandler(); - BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32) override; + void Reset() override; + void ClearActiveBlocksInRange(uint32, uint32) override; + + BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32) override; private: - uint8* m_ram = nullptr; - size_t m_pageSize = 0; + uint8* m_ram = nullptr; + size_t m_pageSize = 0; + + bool HandleAccessFault(intptr_t); + void SetMemoryProtected(void*, size_t, bool); - bool HandleAccessFault(intptr_t); - void SetMemoryProtected(void*, size_t, bool); - #if defined(_WIN32) - static LONG CALLBACK HandleException(_EXCEPTION_POINTERS*); - LONG HandleExceptionInternal(_EXCEPTION_POINTERS*); + static LONG CALLBACK HandleException(_EXCEPTION_POINTERS*); + LONG HandleExceptionInternal(_EXCEPTION_POINTERS*); - LPVOID m_handler = NULL; + LPVOID m_handler = NULL; #elif defined(__unix__) || defined(__ANDROID__) - static void HandleException(int, siginfo_t*, void*); - void HandleExceptionInternal(int, siginfo_t*, void*); + static void HandleException(int, siginfo_t*, void*); + void HandleExceptionInternal(int, siginfo_t*, void*); #elif defined(__APPLE__) - void HandlerThreadProc(); - - mach_port_t m_port = MACH_PORT_NULL; - std::thread m_handlerThread; - std::atomic m_running; + void HandlerThreadProc(); + + mach_port_t m_port = MACH_PORT_NULL; + std::thread m_handlerThread; + std::atomic m_running; #endif }; diff --git a/Source/ee/Ee_SubSystem.cpp b/Source/ee/Ee_SubSystem.cpp index d178e28b0..2677ab3df 100644 --- a/Source/ee/Ee_SubSystem.cpp +++ b/Source/ee/Ee_SubSystem.cpp @@ -8,45 +8,45 @@ using namespace Ee; -#define LOG_NAME ("ee_subsystem") +#define LOG_NAME ("ee_subsystem") -#define STATE_EE ("ee") -#define STATE_VU0 ("vu0") -#define STATE_VU1 ("vu1") -#define STATE_RAM ("ram") -#define STATE_SPR ("spr") -#define STATE_VUMEM0 ("vumem0") -#define STATE_MICROMEM0 ("micromem0") -#define STATE_VUMEM1 ("vumem1") -#define STATE_MICROMEM1 ("micromem1") +#define STATE_EE ("ee") +#define STATE_VU0 ("vu0") +#define STATE_VU1 ("vu1") +#define STATE_RAM ("ram") +#define STATE_SPR ("spr") +#define STATE_VUMEM0 ("vumem0") +#define STATE_MICROMEM0 ("micromem0") +#define STATE_VUMEM1 ("vumem1") +#define STATE_MICROMEM1 ("micromem1") -#define FAKE_IOP_RAM_SIZE (0x1000) +#define FAKE_IOP_RAM_SIZE (0x1000) CSubSystem::CSubSystem(uint8* iopRam, CIopBios& iopBios) -: m_ram(reinterpret_cast(framework_aligned_alloc(PS2::EE_RAM_SIZE, framework_getpagesize()))) -, m_bios(new uint8[PS2::EE_BIOS_SIZE]) -, m_spr(new uint8[PS2::EE_SPR_SIZE]) -, m_fakeIopRam(new uint8[FAKE_IOP_RAM_SIZE]) -, m_vuMem0(reinterpret_cast(framework_aligned_alloc(PS2::VUMEM0SIZE, 0x10))) -, m_microMem0(new uint8[PS2::MICROMEM0SIZE]) -, m_vuMem1(reinterpret_cast(framework_aligned_alloc(PS2::VUMEM1SIZE, 0x10))) -, m_microMem1(new uint8[PS2::MICROMEM1SIZE]) -, m_EE(MEMORYMAP_ENDIAN_LSBF) -, m_VU0(MEMORYMAP_ENDIAN_LSBF) -, m_VU1(MEMORYMAP_ENDIAN_LSBF) -, m_executor(m_EE, m_ram) -, m_dmac(m_ram, m_spr, m_vuMem0, m_EE) -, m_gif(m_gs, m_ram, m_spr) -, m_sif(m_dmac, m_ram, iopRam) -, m_intc(m_dmac, m_gs) -, m_ipu(m_intc) -, m_timer(m_intc) -, m_MAVU0(PS2::VUMEM0SIZE - 1) -, m_MAVU1(PS2::VUMEM1SIZE - 1) -, m_COP_SCU(MIPS_REGSIZE_64) -, m_COP_FPU(MIPS_REGSIZE_64) -, m_COP_VU(MIPS_REGSIZE_64) -, m_iopBios(iopBios) + : m_ram(reinterpret_cast(framework_aligned_alloc(PS2::EE_RAM_SIZE, framework_getpagesize()))) + , m_bios(new uint8[PS2::EE_BIOS_SIZE]) + , m_spr(new uint8[PS2::EE_SPR_SIZE]) + , m_fakeIopRam(new uint8[FAKE_IOP_RAM_SIZE]) + , m_vuMem0(reinterpret_cast(framework_aligned_alloc(PS2::VUMEM0SIZE, 0x10))) + , m_microMem0(new uint8[PS2::MICROMEM0SIZE]) + , m_vuMem1(reinterpret_cast(framework_aligned_alloc(PS2::VUMEM1SIZE, 0x10))) + , m_microMem1(new uint8[PS2::MICROMEM1SIZE]) + , m_EE(MEMORYMAP_ENDIAN_LSBF) + , m_VU0(MEMORYMAP_ENDIAN_LSBF) + , m_VU1(MEMORYMAP_ENDIAN_LSBF) + , m_executor(m_EE, m_ram) + , m_dmac(m_ram, m_spr, m_vuMem0, m_EE) + , m_gif(m_gs, m_ram, m_spr) + , m_sif(m_dmac, m_ram, iopRam) + , m_intc(m_dmac, m_gs) + , m_ipu(m_intc) + , m_timer(m_intc) + , m_MAVU0(PS2::VUMEM0SIZE - 1) + , m_MAVU1(PS2::VUMEM1SIZE - 1) + , m_COP_SCU(MIPS_REGSIZE_64) + , m_COP_FPU(MIPS_REGSIZE_64) + , m_COP_VU(MIPS_REGSIZE_64) + , m_iopBios(iopBios) { //Some alignment checks, this is needed because of SIMD instructions used in generated code assert((reinterpret_cast(&m_EE.m_State) & 0x0F) == 0); @@ -61,83 +61,83 @@ CSubSystem::CSubSystem(uint8* iopRam, CIopBios& iopBios) //EmotionEngine context setup { //Read map - m_EE.m_pMemoryMap->InsertReadMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); - m_EE.m_pMemoryMap->InsertReadMap(PS2::EE_SPR_ADDR, PS2::EE_SPR_ADDR + PS2::EE_SPR_SIZE - 1, m_spr, 0x01); - m_EE.m_pMemoryMap->InsertReadMap(0x10000000, 0x10FFFFFF, std::bind(&CSubSystem::IOPortReadHandler, this, PLACEHOLDER_1), 0x02); - m_EE.m_pMemoryMap->InsertReadMap(PS2::MICROMEM0ADDR, PS2::MICROMEM0ADDR + PS2::MICROMEM0SIZE - 1, m_microMem0, 0x03); - m_EE.m_pMemoryMap->InsertReadMap(PS2::VUMEM0ADDR, PS2::VUMEM0ADDR + PS2::VUMEM0SIZE - 1, m_vuMem0, 0x04); - m_EE.m_pMemoryMap->InsertReadMap(PS2::MICROMEM1ADDR, PS2::MICROMEM1ADDR + PS2::MICROMEM1SIZE - 1, m_microMem1, 0x05); - m_EE.m_pMemoryMap->InsertReadMap(PS2::VUMEM1ADDR, PS2::VUMEM1ADDR + PS2::VUMEM1SIZE - 1, m_vuMem1, 0x06); - m_EE.m_pMemoryMap->InsertReadMap(0x12000000, 0x12FFFFFF, std::bind(&CSubSystem::IOPortReadHandler, this, PLACEHOLDER_1), 0x07); - m_EE.m_pMemoryMap->InsertReadMap(0x1C000000, 0x1C001000, m_fakeIopRam, 0x08); - m_EE.m_pMemoryMap->InsertReadMap(0x1FC00000, 0x1FFFFFFF, m_bios, 0x09); + m_EE.m_pMemoryMap->InsertReadMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); + m_EE.m_pMemoryMap->InsertReadMap(PS2::EE_SPR_ADDR, PS2::EE_SPR_ADDR + PS2::EE_SPR_SIZE - 1, m_spr, 0x01); + m_EE.m_pMemoryMap->InsertReadMap(0x10000000, 0x10FFFFFF, std::bind(&CSubSystem::IOPortReadHandler, this, PLACEHOLDER_1), 0x02); + m_EE.m_pMemoryMap->InsertReadMap(PS2::MICROMEM0ADDR, PS2::MICROMEM0ADDR + PS2::MICROMEM0SIZE - 1, m_microMem0, 0x03); + m_EE.m_pMemoryMap->InsertReadMap(PS2::VUMEM0ADDR, PS2::VUMEM0ADDR + PS2::VUMEM0SIZE - 1, m_vuMem0, 0x04); + m_EE.m_pMemoryMap->InsertReadMap(PS2::MICROMEM1ADDR, PS2::MICROMEM1ADDR + PS2::MICROMEM1SIZE - 1, m_microMem1, 0x05); + m_EE.m_pMemoryMap->InsertReadMap(PS2::VUMEM1ADDR, PS2::VUMEM1ADDR + PS2::VUMEM1SIZE - 1, m_vuMem1, 0x06); + m_EE.m_pMemoryMap->InsertReadMap(0x12000000, 0x12FFFFFF, std::bind(&CSubSystem::IOPortReadHandler, this, PLACEHOLDER_1), 0x07); + m_EE.m_pMemoryMap->InsertReadMap(0x1C000000, 0x1C001000, m_fakeIopRam, 0x08); + m_EE.m_pMemoryMap->InsertReadMap(0x1FC00000, 0x1FFFFFFF, m_bios, 0x09); //Write map - m_EE.m_pMemoryMap->InsertWriteMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); - m_EE.m_pMemoryMap->InsertWriteMap(PS2::EE_SPR_ADDR, PS2::EE_SPR_ADDR + PS2::EE_SPR_SIZE - 1, m_spr, 0x01); - m_EE.m_pMemoryMap->InsertWriteMap(0x10000000, 0x10FFFFFF, std::bind(&CSubSystem::IOPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x02); - m_EE.m_pMemoryMap->InsertWriteMap(PS2::MICROMEM0ADDR, PS2::MICROMEM0ADDR + PS2::MICROMEM0SIZE - 1, std::bind(&CSubSystem::Vu0MicroMemWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x03); - m_EE.m_pMemoryMap->InsertWriteMap(PS2::VUMEM0ADDR, PS2::VUMEM0ADDR + PS2::VUMEM0SIZE - 1, m_vuMem0, 0x04); - m_EE.m_pMemoryMap->InsertWriteMap(PS2::MICROMEM1ADDR, PS2::MICROMEM1ADDR + PS2::MICROMEM1SIZE - 1, std::bind(&CSubSystem::Vu1MicroMemWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x05); - m_EE.m_pMemoryMap->InsertWriteMap(PS2::VUMEM1ADDR, PS2::VUMEM1ADDR + PS2::VUMEM1SIZE - 1, m_vuMem1, 0x06); - m_EE.m_pMemoryMap->InsertWriteMap(0x12000000, 0x12FFFFFF, std::bind(&CSubSystem::IOPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x07); + m_EE.m_pMemoryMap->InsertWriteMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); + m_EE.m_pMemoryMap->InsertWriteMap(PS2::EE_SPR_ADDR, PS2::EE_SPR_ADDR + PS2::EE_SPR_SIZE - 1, m_spr, 0x01); + m_EE.m_pMemoryMap->InsertWriteMap(0x10000000, 0x10FFFFFF, std::bind(&CSubSystem::IOPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x02); + m_EE.m_pMemoryMap->InsertWriteMap(PS2::MICROMEM0ADDR, PS2::MICROMEM0ADDR + PS2::MICROMEM0SIZE - 1, std::bind(&CSubSystem::Vu0MicroMemWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x03); + m_EE.m_pMemoryMap->InsertWriteMap(PS2::VUMEM0ADDR, PS2::VUMEM0ADDR + PS2::VUMEM0SIZE - 1, m_vuMem0, 0x04); + m_EE.m_pMemoryMap->InsertWriteMap(PS2::MICROMEM1ADDR, PS2::MICROMEM1ADDR + PS2::MICROMEM1SIZE - 1, std::bind(&CSubSystem::Vu1MicroMemWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x05); + m_EE.m_pMemoryMap->InsertWriteMap(PS2::VUMEM1ADDR, PS2::VUMEM1ADDR + PS2::VUMEM1SIZE - 1, m_vuMem1, 0x06); + m_EE.m_pMemoryMap->InsertWriteMap(0x12000000, 0x12FFFFFF, std::bind(&CSubSystem::IOPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x07); //Instruction map - m_EE.m_pMemoryMap->InsertInstructionMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); + m_EE.m_pMemoryMap->InsertInstructionMap(0x00000000, 0x01FFFFFF, m_ram, 0x00); m_EE.m_pMemoryMap->InsertInstructionMap(0x1FC00000, 0x1FFFFFFF, m_bios, 0x01); - m_EE.m_pArch = &m_EEArch; - m_EE.m_pCOP[0] = &m_COP_SCU; - m_EE.m_pCOP[1] = &m_COP_FPU; - m_EE.m_pCOP[2] = &m_COP_VU; + m_EE.m_pArch = &m_EEArch; + m_EE.m_pCOP[0] = &m_COP_SCU; + m_EE.m_pCOP[1] = &m_COP_FPU; + m_EE.m_pCOP[2] = &m_COP_VU; - m_EE.m_pAddrTranslator = CPS2OS::TranslateAddress; + m_EE.m_pAddrTranslator = CPS2OS::TranslateAddress; } //Vector Unit 0 context setup { - m_VU0.m_pMemoryMap->InsertReadMap(0x00000000, 0x00000FFF, m_vuMem0, 0x01); - m_VU0.m_pMemoryMap->InsertReadMap(0x00001000, 0x00001FFF, m_vuMem0, 0x02); - m_VU0.m_pMemoryMap->InsertReadMap(0x00002000, 0x00002FFF, m_vuMem0, 0x03); - m_VU0.m_pMemoryMap->InsertReadMap(0x00003000, 0x00003FFF, m_vuMem0, 0x04); - m_VU0.m_pMemoryMap->InsertReadMap(0x00004000, 0x00008FFF, std::bind(&CSubSystem::Vu0IoPortReadHandler, this, PLACEHOLDER_1), 0x05); + m_VU0.m_pMemoryMap->InsertReadMap(0x00000000, 0x00000FFF, m_vuMem0, 0x01); + m_VU0.m_pMemoryMap->InsertReadMap(0x00001000, 0x00001FFF, m_vuMem0, 0x02); + m_VU0.m_pMemoryMap->InsertReadMap(0x00002000, 0x00002FFF, m_vuMem0, 0x03); + m_VU0.m_pMemoryMap->InsertReadMap(0x00003000, 0x00003FFF, m_vuMem0, 0x04); + m_VU0.m_pMemoryMap->InsertReadMap(0x00004000, 0x00008FFF, std::bind(&CSubSystem::Vu0IoPortReadHandler, this, PLACEHOLDER_1), 0x05); - m_VU0.m_pMemoryMap->InsertWriteMap(0x00000000, 0x00000FFF, m_vuMem0, 0x01); - m_VU0.m_pMemoryMap->InsertWriteMap(0x00001000, 0x00001FFF, m_vuMem0, 0x02); - m_VU0.m_pMemoryMap->InsertWriteMap(0x00002000, 0x00002FFF, m_vuMem0, 0x03); - m_VU0.m_pMemoryMap->InsertWriteMap(0x00003000, 0x00003FFF, m_vuMem0, 0x04); - m_VU0.m_pMemoryMap->InsertWriteMap(0x00004000, 0x00008FFF, std::bind(&CSubSystem::Vu0IoPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x05); + m_VU0.m_pMemoryMap->InsertWriteMap(0x00000000, 0x00000FFF, m_vuMem0, 0x01); + m_VU0.m_pMemoryMap->InsertWriteMap(0x00001000, 0x00001FFF, m_vuMem0, 0x02); + m_VU0.m_pMemoryMap->InsertWriteMap(0x00002000, 0x00002FFF, m_vuMem0, 0x03); + m_VU0.m_pMemoryMap->InsertWriteMap(0x00003000, 0x00003FFF, m_vuMem0, 0x04); + m_VU0.m_pMemoryMap->InsertWriteMap(0x00004000, 0x00008FFF, std::bind(&CSubSystem::Vu0IoPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x05); m_VU0.m_pMemoryMap->InsertInstructionMap(0x00000000, 0x00000FFF, m_microMem0, 0x00); - m_VU0.m_pArch = &m_MAVU0; - m_VU0.m_pAddrTranslator = CMIPS::TranslateAddress64; + m_VU0.m_pArch = &m_MAVU0; + m_VU0.m_pAddrTranslator = CMIPS::TranslateAddress64; } //Vector Unit 1 context setup { - m_VU1.m_pMemoryMap->InsertReadMap(0x00000000, 0x00003FFF, m_vuMem1, 0x00); - m_VU1.m_pMemoryMap->InsertReadMap(0x00008000, 0x00008FFF, std::bind(&CSubSystem::Vu1IoPortReadHandler, this, PLACEHOLDER_1), 0x01); + m_VU1.m_pMemoryMap->InsertReadMap(0x00000000, 0x00003FFF, m_vuMem1, 0x00); + m_VU1.m_pMemoryMap->InsertReadMap(0x00008000, 0x00008FFF, std::bind(&CSubSystem::Vu1IoPortReadHandler, this, PLACEHOLDER_1), 0x01); - m_VU1.m_pMemoryMap->InsertWriteMap(0x00000000, 0x00003FFF, m_vuMem1, 0x00); - m_VU1.m_pMemoryMap->InsertWriteMap(0x00008000, 0x00008FFF, std::bind(&CSubSystem::Vu1IoPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x01); + m_VU1.m_pMemoryMap->InsertWriteMap(0x00000000, 0x00003FFF, m_vuMem1, 0x00); + m_VU1.m_pMemoryMap->InsertWriteMap(0x00008000, 0x00008FFF, std::bind(&CSubSystem::Vu1IoPortWriteHandler, this, PLACEHOLDER_1, PLACEHOLDER_2), 0x01); m_VU1.m_pMemoryMap->InsertInstructionMap(0x00000000, 0x00003FFF, m_microMem1, 0x01); - m_VU1.m_pArch = &m_MAVU1; - m_VU1.m_pAddrTranslator = CMIPS::TranslateAddress64; + m_VU1.m_pArch = &m_MAVU1; + m_VU1.m_pAddrTranslator = CMIPS::TranslateAddress64; } m_EE.m_vuMem = m_vuMem0; m_VU0.m_vuMem = m_vuMem0; m_VU1.m_vuMem = m_vuMem1; - m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_VIF0, std::bind(&CVif::ReceiveDMA, &m_vpu0->GetVif(), PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); - m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_VIF1, std::bind(&CVif::ReceiveDMA, &m_vpu1->GetVif(), PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); - m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_GIF, std::bind(&CGIF::ReceiveDMA, &m_gif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); + m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_VIF0, std::bind(&CVif::ReceiveDMA, &m_vpu0->GetVif(), PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); + m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_VIF1, std::bind(&CVif::ReceiveDMA, &m_vpu1->GetVif(), PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); + m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_GIF, std::bind(&CGIF::ReceiveDMA, &m_gif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_TO_IPU, std::bind(&CIPU::ReceiveDMA4, &m_ipu, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_4, m_ram)); - m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_SIF0, std::bind(&CSIF::ReceiveDMA5, &m_sif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); - m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_SIF1, std::bind(&CSIF::ReceiveDMA6, &m_sif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); + m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_SIF0, std::bind(&CSIF::ReceiveDMA5, &m_sif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); + m_dmac.SetChannelTransferFunction(CDMAC::CHANNEL_ID_SIF1, std::bind(&CSIF::ReceiveDMA6, &m_sif, PLACEHOLDER_1, PLACEHOLDER_2, PLACEHOLDER_3, PLACEHOLDER_4)); m_ipu.SetDMA3ReceiveHandler(std::bind(&CDMAC::ResumeDMA3, &m_dmac, PLACEHOLDER_1, PLACEHOLDER_2)); @@ -150,13 +150,13 @@ CSubSystem::~CSubSystem() m_executor.Reset(); delete m_os; framework_aligned_free(m_ram); - delete [] m_bios; - delete [] m_spr; - delete [] m_fakeIopRam; + delete[] m_bios; + delete[] m_spr; + delete[] m_fakeIopRam; framework_aligned_free(m_vuMem0); - delete [] m_microMem0; + delete[] m_microMem0; framework_aligned_free(m_vuMem1); - delete [] m_microMem1; + delete[] m_microMem1; } void CSubSystem::SetVpu0(std::shared_ptr newVpu0) @@ -174,14 +174,14 @@ void CSubSystem::Reset() m_os->Release(); m_executor.Reset(); - memset(m_ram, 0, PS2::EE_RAM_SIZE); - memset(m_spr, 0, PS2::EE_SPR_SIZE); - memset(m_bios, 0, PS2::EE_BIOS_SIZE); - memset(m_fakeIopRam, 0, FAKE_IOP_RAM_SIZE); - memset(m_vuMem0, 0, PS2::VUMEM0SIZE); - memset(m_microMem0, 0, PS2::MICROMEM0SIZE); - memset(m_vuMem1, 0, PS2::VUMEM1SIZE); - memset(m_microMem1, 0, PS2::MICROMEM1SIZE); + memset(m_ram, 0, PS2::EE_RAM_SIZE); + memset(m_spr, 0, PS2::EE_SPR_SIZE); + memset(m_bios, 0, PS2::EE_BIOS_SIZE); + memset(m_fakeIopRam, 0, FAKE_IOP_RAM_SIZE); + memset(m_vuMem0, 0, PS2::VUMEM0SIZE); + memset(m_microMem0, 0, PS2::MICROMEM0SIZE); + memset(m_vuMem1, 0, PS2::VUMEM1SIZE); + memset(m_microMem1, 0, PS2::MICROMEM1SIZE); //Reset Contexts m_EE.Reset(); @@ -248,24 +248,24 @@ int CSubSystem::ExecuteCpu(int quota) } break; case MIPS_EXCEPTION_IDLE: - { - m_isIdle = true; - m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; - } - break; + { + m_isIdle = true; + m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; + } + break; case MIPS_EXCEPTION_CHECKPENDINGINT: - { - m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; - CheckPendingInterrupts(); - } - break; + { + m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; + CheckPendingInterrupts(); + } + break; case MIPS_EXCEPTION_RETURNFROMEXCEPTION: - { - m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; - m_os->HandleReturnFromException(); - CheckPendingInterrupts(); - } - break; + { + m_EE.m_State.nHasException = MIPS_EXCEPTION_NONE; + m_os->HandleReturnFromException(); + CheckPendingInterrupts(); + } + break; default: assert(0); break; @@ -340,15 +340,15 @@ void CSubSystem::NotifyVBlankEnd() void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive) { - archive.InsertFile(new CMemoryStateFile(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE))); - archive.InsertFile(new CMemoryStateFile(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE))); - archive.InsertFile(new CMemoryStateFile(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE))); - archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, PS2::EE_RAM_SIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_SPR, m_spr, PS2::EE_SPR_SIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_EE, &m_EE.m_State, sizeof(MIPSSTATE))); + archive.InsertFile(new CMemoryStateFile(STATE_VU0, &m_VU0.m_State, sizeof(MIPSSTATE))); + archive.InsertFile(new CMemoryStateFile(STATE_VU1, &m_VU1.m_State, sizeof(MIPSSTATE))); + archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_ram, PS2::EE_RAM_SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_SPR, m_spr, PS2::EE_SPR_SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_VUMEM0, m_vuMem0, PS2::VUMEM0SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM0, m_microMem0, PS2::MICROMEM0SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_VUMEM1, m_vuMem1, PS2::VUMEM1SIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_MICROMEM1, m_microMem1, PS2::MICROMEM1SIZE)); m_dmac.SaveState(archive); m_intc.SaveState(archive); @@ -361,15 +361,15 @@ void CSubSystem::SaveState(Framework::CZipArchiveWriter& archive) void CSubSystem::LoadState(Framework::CZipArchiveReader& archive) { - archive.BeginReadFile(STATE_EE )->Read(&m_EE.m_State, sizeof(MIPSSTATE)); - archive.BeginReadFile(STATE_VU0 )->Read(&m_VU0.m_State, sizeof(MIPSSTATE)); - archive.BeginReadFile(STATE_VU1 )->Read(&m_VU1.m_State, sizeof(MIPSSTATE)); - archive.BeginReadFile(STATE_RAM )->Read(m_ram, PS2::EE_RAM_SIZE); - archive.BeginReadFile(STATE_SPR )->Read(m_spr, PS2::EE_SPR_SIZE); - archive.BeginReadFile(STATE_VUMEM0 )->Read(m_vuMem0, PS2::VUMEM0SIZE); - archive.BeginReadFile(STATE_MICROMEM0 )->Read(m_microMem0, PS2::MICROMEM0SIZE); - archive.BeginReadFile(STATE_VUMEM1 )->Read(m_vuMem1, PS2::VUMEM1SIZE); - archive.BeginReadFile(STATE_MICROMEM1 )->Read(m_microMem1, PS2::MICROMEM1SIZE); + archive.BeginReadFile(STATE_EE)->Read(&m_EE.m_State, sizeof(MIPSSTATE)); + archive.BeginReadFile(STATE_VU0)->Read(&m_VU0.m_State, sizeof(MIPSSTATE)); + archive.BeginReadFile(STATE_VU1)->Read(&m_VU1.m_State, sizeof(MIPSSTATE)); + archive.BeginReadFile(STATE_RAM)->Read(m_ram, PS2::EE_RAM_SIZE); + archive.BeginReadFile(STATE_SPR)->Read(m_spr, PS2::EE_SPR_SIZE); + archive.BeginReadFile(STATE_VUMEM0)->Read(m_vuMem0, PS2::VUMEM0SIZE); + archive.BeginReadFile(STATE_MICROMEM0)->Read(m_microMem0, PS2::MICROMEM0SIZE); + archive.BeginReadFile(STATE_VUMEM1)->Read(m_vuMem1, PS2::VUMEM1SIZE); + archive.BeginReadFile(STATE_MICROMEM1)->Read(m_microMem1, PS2::MICROMEM1SIZE); m_dmac.LoadState(archive); m_intc.LoadState(archive); @@ -427,7 +427,7 @@ uint32 CSubSystem::IOPortReadHandler(uint32 nAddress) else { CLog::GetInstance().Print(LOG_NAME, "Read an unhandled IO port (0x%08X, PC: 0x%08X).\r\n", - nAddress, m_EE.m_State.nPC); + nAddress, m_EE.m_State.nPC); } if((nAddress == CINTC::INTC_STAT) || (nAddress == CGSHandler::GS_CSR)) @@ -516,14 +516,13 @@ uint32 CSubSystem::IOPortWriteHandler(uint32 nAddress, uint32 nData) else { CLog::GetInstance().Print(LOG_NAME, "Wrote to an unhandled IO port (0x%08X, 0x%08X, PC: 0x%08X).\r\n", - nAddress, nData, m_EE.m_State.nPC); + nAddress, nData, m_EE.m_State.nPC); } if( - m_intc.IsInterruptPending() && - (m_EE.m_State.nHasException == MIPS_EXCEPTION_NONE) && - ((m_EE.m_State.nCOP0[CCOP_SCU::STATUS] & INTERRUPTS_ENABLED_MASK) == INTERRUPTS_ENABLED_MASK) - ) + m_intc.IsInterruptPending() && + (m_EE.m_State.nHasException == MIPS_EXCEPTION_NONE) && + ((m_EE.m_State.nCOP0[CCOP_SCU::STATUS] & INTERRUPTS_ENABLED_MASK) == INTERRUPTS_ENABLED_MASK)) { m_EE.m_State.nHasException = MIPS_EXCEPTION_CHECKPENDINGINT; } @@ -558,8 +557,8 @@ uint32 CSubSystem::Vu0IoPortWriteHandler(uint32 address, uint32 value) switch(address) { default: - CLog::GetInstance().Print(LOG_NAME, "Wrote an unhandled VU0 IO port (0x%08X, 0x%08X).\r\n", - address, value); + CLog::GetInstance().Print(LOG_NAME, "Wrote an unhandled VU0 IO port (0x%08X, 0x%08X).\r\n", + address, value); break; } return 0; @@ -598,8 +597,8 @@ uint32 CSubSystem::Vu1IoPortWriteHandler(uint32 address, uint32 value) m_vpu1->ProcessXgKick(value); break; default: - CLog::GetInstance().Print(LOG_NAME, "Wrote an unhandled VU1 IO port (0x%08X, 0x%08X).\r\n", - address, value); + CLog::GetInstance().Print(LOG_NAME, "Wrote an unhandled VU1 IO port (0x%08X, 0x%08X).\r\n", + address, value); break; } return 0; @@ -607,8 +606,8 @@ uint32 CSubSystem::Vu1IoPortWriteHandler(uint32 address, uint32 value) void CSubSystem::CopyVuState(CMIPS& dst, const CMIPS& src) { - memcpy(&dst.m_State.nCOP2, &src.m_State.nCOP2, sizeof(dst.m_State.nCOP2)); - memcpy(&dst.m_State.nCOP2A, &src.m_State.nCOP2A, sizeof(dst.m_State.nCOP2A)); + memcpy(&dst.m_State.nCOP2, &src.m_State.nCOP2, sizeof(dst.m_State.nCOP2)); + memcpy(&dst.m_State.nCOP2A, &src.m_State.nCOP2A, sizeof(dst.m_State.nCOP2A)); memcpy(&dst.m_State.nCOP2VI, &src.m_State.nCOP2VI, sizeof(dst.m_State.nCOP2VI)); dst.m_State.nCOP2SF = src.m_State.nCOP2SF; dst.m_State.nCOP2CF = src.m_State.nCOP2CF; @@ -649,12 +648,12 @@ void CSubSystem::CheckPendingInterrupts() if(!m_EE.m_State.nHasException) { if( - m_intc.IsInterruptPending() + m_intc.IsInterruptPending() #ifdef DEBUGGER_INCLUDED -// && !m_singleStepEe - && !m_executor.MustBreak() + // && !m_singleStepEe + && !m_executor.MustBreak() #endif - ) + ) { m_os->HandleInterrupt(); } diff --git a/Source/ee/Ee_SubSystem.h b/Source/ee/Ee_SubSystem.h index be7bc2754..6cf956a10 100644 --- a/Source/ee/Ee_SubSystem.h +++ b/Source/ee/Ee_SubSystem.h @@ -23,50 +23,50 @@ namespace Ee class CSubSystem { public: - CSubSystem(uint8*, CIopBios&); - virtual ~CSubSystem(); + CSubSystem(uint8*, CIopBios&); + virtual ~CSubSystem(); - void Reset(); - int ExecuteCpu(int); - bool IsCpuIdle() const; - void CountTicks(int); + void Reset(); + int ExecuteCpu(int); + bool IsCpuIdle() const; + void CountTicks(int); - void NotifyVBlankStart(); - void NotifyVBlankEnd(); + void NotifyVBlankStart(); + void NotifyVBlankEnd(); - void SaveState(Framework::CZipArchiveWriter&); - void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); - void SetVpu0(std::shared_ptr); - void SetVpu1(std::shared_ptr); + void SetVpu0(std::shared_ptr); + void SetVpu1(std::shared_ptr); - uint8* m_ram = nullptr; - uint8* m_bios = nullptr; - uint8* m_spr = nullptr; - uint8* m_fakeIopRam = nullptr; + uint8* m_ram = nullptr; + uint8* m_bios = nullptr; + uint8* m_spr = nullptr; + uint8* m_fakeIopRam = nullptr; - uint8* m_vuMem0 = nullptr; - uint8* m_microMem0 = nullptr; + uint8* m_vuMem0 = nullptr; + uint8* m_microMem0 = nullptr; - uint8* m_vuMem1 = nullptr; - uint8* m_microMem1 = nullptr; + uint8* m_vuMem1 = nullptr; + uint8* m_microMem1 = nullptr; - CGSHandler* m_gs = nullptr; - CDMAC m_dmac; - CGIF m_gif; - CSIF m_sif; - std::shared_ptr m_vpu0; - std::shared_ptr m_vpu1; - CINTC m_intc; - CIPU m_ipu; - CTimer m_timer; - CPS2OS* m_os; - CIopBios& m_iopBios; + CGSHandler* m_gs = nullptr; + CDMAC m_dmac; + CGIF m_gif; + CSIF m_sif; + std::shared_ptr m_vpu0; + std::shared_ptr m_vpu1; + CINTC m_intc; + CIPU m_ipu; + CTimer m_timer; + CPS2OS* m_os; + CIopBios& m_iopBios; - CMIPS m_EE; - CMIPS m_VU0; - CMIPS m_VU1; - CEeExecutor m_executor; + CMIPS m_EE; + CMIPS m_VU0; + CMIPS m_VU1; + CEeExecutor m_executor; void* operator new(size_t allocSize) { @@ -81,38 +81,38 @@ namespace Ee private: typedef std::map StatusRegisterCheckerMap; - uint32 IOPortReadHandler(uint32); - uint32 IOPortWriteHandler(uint32, uint32); + uint32 IOPortReadHandler(uint32); + uint32 IOPortWriteHandler(uint32, uint32); - uint32 Vu0MicroMemWriteHandler(uint32, uint32); + uint32 Vu0MicroMemWriteHandler(uint32, uint32); - uint32 Vu0IoPortReadHandler(uint32); - uint32 Vu0IoPortWriteHandler(uint32, uint32); + uint32 Vu0IoPortReadHandler(uint32); + uint32 Vu0IoPortWriteHandler(uint32, uint32); - uint32 Vu1MicroMemWriteHandler(uint32, uint32); + uint32 Vu1MicroMemWriteHandler(uint32, uint32); - uint32 Vu1IoPortReadHandler(uint32); - uint32 Vu1IoPortWriteHandler(uint32, uint32); + uint32 Vu1IoPortReadHandler(uint32); + uint32 Vu1IoPortWriteHandler(uint32, uint32); - void CopyVuState(CMIPS&, const CMIPS&); + void CopyVuState(CMIPS&, const CMIPS&); - void ExecuteIpu(); + void ExecuteIpu(); - void CheckPendingInterrupts(); + void CheckPendingInterrupts(); - void FlushInstructionCache(); + void FlushInstructionCache(); - void LoadBIOS(); - void FillFakeIopRam(); + void LoadBIOS(); + void FillFakeIopRam(); - StatusRegisterCheckerMap m_statusRegisterCheckers; - bool m_isIdle = false; + StatusRegisterCheckerMap m_statusRegisterCheckers; + bool m_isIdle = false; - CMA_VU m_MAVU0; - CMA_VU m_MAVU1; - CMA_EE m_EEArch; - CCOP_SCU m_COP_SCU; - CCOP_FPU m_COP_FPU; - CCOP_VU m_COP_VU; + CMA_VU m_MAVU0; + CMA_VU m_MAVU1; + CMA_EE m_EEArch; + CCOP_SCU m_COP_SCU; + CCOP_FPU m_COP_FPU; + CCOP_VU m_COP_VU; }; }; diff --git a/Source/ee/FpAddTruncate.cpp b/Source/ee/FpAddTruncate.cpp index 053400244..c5ec1b6d3 100644 --- a/Source/ee/FpAddTruncate.cpp +++ b/Source/ee/FpAddTruncate.cpp @@ -12,148 +12,165 @@ typedef float fp_t; #define REP_C UINT32_C #define significandBits 23 -#define typeWidth (sizeof(rep_t)*CHAR_BIT) -#define exponentBits (typeWidth - significandBits - 1) -#define maxExponent ((1 << exponentBits) - 1) -#define exponentBias (maxExponent >> 1) +#define typeWidth (sizeof(rep_t) * CHAR_BIT) +#define exponentBits (typeWidth - significandBits - 1) +#define maxExponent ((1 << exponentBits) - 1) +#define exponentBias (maxExponent >> 1) -#define implicitBit (REP_C(1) << significandBits) +#define implicitBit (REP_C(1) << significandBits) #define significandMask (implicitBit - 1U) -#define signBit (REP_C(1) << (significandBits + exponentBits)) -#define absMask (signBit - 1U) -#define exponentMask (absMask ^ significandMask) -#define oneRep ((rep_t)exponentBias << significandBits) -#define infRep exponentMask -#define quietBit (implicitBit >> 1) -#define qnanRep (exponentMask | quietBit) +#define signBit (REP_C(1) << (significandBits + exponentBits)) +#define absMask (signBit - 1U) +#define exponentMask (absMask ^ significandMask) +#define oneRep ((rep_t)exponentBias << significandBits) +#define infRep exponentMask +#define quietBit (implicitBit >> 1) +#define qnanRep (exponentMask | quietBit) -static inline int rep_clz(rep_t a) { +static inline int rep_clz(rep_t a) +{ return __builtin_clz(a); } -uint32 FpAddTruncate(uint32 a, uint32 b) +uint32 FpAddTruncate(uint32 a, uint32 b) { - const rep_t aAbs = a & absMask; - const rep_t bAbs = b & absMask; - - // Detect if a or b is zero, infinity, or NaN. - if (aAbs - 1U >= infRep - 1U || bAbs - 1U >= infRep - 1U) { - - // NaN + anything = qNaN - if (aAbs > infRep) return (a | quietBit); - // anything + NaN = qNaN - if (bAbs > infRep) return (b | quietBit); - - if (aAbs == infRep) { - // +/-infinity + -/+infinity = qNaN - if ((a ^ b) == signBit) return qnanRep; - // +/-infinity + anything remaining = +/- infinity - else return a; - } - - // anything remaining + +/-infinity = +/-infinity - if (bAbs == infRep) return b; - - // zero + anything = anything - if (!aAbs) { - // but we need to get the sign right for zero + zero - if (!bAbs) return (a & b); - else return b; - } - - // anything + zero = anything - if (!bAbs) return a; - } - - // Swap a and b if necessary so that a has the larger absolute value. - if (bAbs > aAbs) { - const uint32 temp = a; - a = b; - b = temp; - } - - // Extract the exponent and significand from the (possibly swapped) a and b. - int aExponent = a >> significandBits & maxExponent; - int bExponent = b >> significandBits & maxExponent; - rep_t aSignificand = a & significandMask; - rep_t bSignificand = b & significandMask; - - // Normalize any denormals, and adjust the exponent accordingly. - //if (aExponent == 0) aExponent = normalize(&aSignificand); - //if (bExponent == 0) bExponent = normalize(&bSignificand); - - // The sign of the result is the sign of the larger operand, a. If they - // have opposite signs, we are performing a subtraction; otherwise addition. - const rep_t resultSign = a & signBit; - const bool subtraction = (a ^ b) & signBit; - - // Shift the significands to give us round, guard and sticky, and or in the - // implicit significand bit. (If we fell through from the denormal path it - // was already set by normalize( ), but setting it twice won't hurt - // anything.) - aSignificand = (aSignificand | implicitBit) << 3; - bSignificand = (bSignificand | implicitBit) << 3; - - // Shift the significand of b by the difference in exponents, with a sticky - // bottom bit to get rounding correct. - const unsigned int align = aExponent - bExponent; - if (align) { - if (align < typeWidth) { - //const bool sticky = bSignificand << (typeWidth - align); - bSignificand = bSignificand >> align; - } else { - bSignificand = 0; // sticky; b is known to be non-zero. - } - } - - if (subtraction) { - aSignificand -= bSignificand; - - // If a == -b, return +zero. - if (aSignificand == 0) return 0; - - // If partial cancellation occured, we need to left-shift the result - // and adjust the exponent: - if (aSignificand < implicitBit << 3) { - const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3); - aSignificand <<= shift; - aExponent -= shift; - } - } - - else /* addition */ { - aSignificand += bSignificand; - - // If the addition carried up, we need to right-shift the result and - // adjust the exponent: - if (aSignificand & implicitBit << 4) { - const bool sticky = aSignificand & 1; - aSignificand = aSignificand >> 1 | sticky; - aExponent += 1; - } - } - - // If we have overflowed the type, return +/- infinity: - if (aExponent >= maxExponent) return infRep | resultSign; - - if (aExponent <= 0) { - // Result is denormal before rounding; the exponent is zero and we - // need to shift the significand. - const int shift = 1 - aExponent; - const bool sticky = aSignificand << (typeWidth - shift); - aSignificand = aSignificand >> shift | sticky; - aExponent = 0; - } - - // Low three bits are round, guard, and sticky. - const int roundGuardSticky = aSignificand & 0x7; - - // Shift the significand into place, and mask off the implicit bit. - rep_t result = aSignificand >> 3 & significandMask; - - // Insert the exponent and sign. - result |= (rep_t)aExponent << significandBits; - result |= resultSign; - - return result; + const rep_t aAbs = a & absMask; + const rep_t bAbs = b & absMask; + + // Detect if a or b is zero, infinity, or NaN. + if(aAbs - 1U >= infRep - 1U || bAbs - 1U >= infRep - 1U) + { + + // NaN + anything = qNaN + if(aAbs > infRep) return (a | quietBit); + // anything + NaN = qNaN + if(bAbs > infRep) return (b | quietBit); + + if(aAbs == infRep) + { + // +/-infinity + -/+infinity = qNaN + if((a ^ b) == signBit) return qnanRep; + // +/-infinity + anything remaining = +/- infinity + else + return a; + } + + // anything remaining + +/-infinity = +/-infinity + if(bAbs == infRep) return b; + + // zero + anything = anything + if(!aAbs) + { + // but we need to get the sign right for zero + zero + if(!bAbs) + return (a & b); + else + return b; + } + + // anything + zero = anything + if(!bAbs) return a; + } + + // Swap a and b if necessary so that a has the larger absolute value. + if(bAbs > aAbs) + { + const uint32 temp = a; + a = b; + b = temp; + } + + // Extract the exponent and significand from the (possibly swapped) a and b. + int aExponent = a >> significandBits & maxExponent; + int bExponent = b >> significandBits & maxExponent; + rep_t aSignificand = a & significandMask; + rep_t bSignificand = b & significandMask; + + // Normalize any denormals, and adjust the exponent accordingly. + //if (aExponent == 0) aExponent = normalize(&aSignificand); + //if (bExponent == 0) bExponent = normalize(&bSignificand); + + // The sign of the result is the sign of the larger operand, a. If they + // have opposite signs, we are performing a subtraction; otherwise addition. + const rep_t resultSign = a & signBit; + const bool subtraction = (a ^ b) & signBit; + + // Shift the significands to give us round, guard and sticky, and or in the + // implicit significand bit. (If we fell through from the denormal path it + // was already set by normalize( ), but setting it twice won't hurt + // anything.) + aSignificand = (aSignificand | implicitBit) << 3; + bSignificand = (bSignificand | implicitBit) << 3; + + // Shift the significand of b by the difference in exponents, with a sticky + // bottom bit to get rounding correct. + const unsigned int align = aExponent - bExponent; + if(align) + { + if(align < typeWidth) + { + //const bool sticky = bSignificand << (typeWidth - align); + bSignificand = bSignificand >> align; + } + else + { + bSignificand = 0; // sticky; b is known to be non-zero. + } + } + + if(subtraction) + { + aSignificand -= bSignificand; + + // If a == -b, return +zero. + if(aSignificand == 0) return 0; + + // If partial cancellation occured, we need to left-shift the result + // and adjust the exponent: + if(aSignificand < implicitBit << 3) + { + const int shift = rep_clz(aSignificand) - rep_clz(implicitBit << 3); + aSignificand <<= shift; + aExponent -= shift; + } + } + + else /* addition */ + { + aSignificand += bSignificand; + + // If the addition carried up, we need to right-shift the result and + // adjust the exponent: + if(aSignificand & implicitBit << 4) + { + const bool sticky = aSignificand & 1; + aSignificand = aSignificand >> 1 | sticky; + aExponent += 1; + } + } + + // If we have overflowed the type, return +/- infinity: + if(aExponent >= maxExponent) return infRep | resultSign; + + if(aExponent <= 0) + { + // Result is denormal before rounding; the exponent is zero and we + // need to shift the significand. + const int shift = 1 - aExponent; + const bool sticky = aSignificand << (typeWidth - shift); + aSignificand = aSignificand >> shift | sticky; + aExponent = 0; + } + + // Low three bits are round, guard, and sticky. + const int roundGuardSticky = aSignificand & 0x7; + + // Shift the significand into place, and mask off the implicit bit. + rep_t result = aSignificand >> 3 & significandMask; + + // Insert the exponent and sign. + result |= (rep_t)aExponent << significandBits; + result |= resultSign; + + return result; } diff --git a/Source/ee/FpMulTruncate.cpp b/Source/ee/FpMulTruncate.cpp index 6251870b3..260e743de 100644 --- a/Source/ee/FpMulTruncate.cpp +++ b/Source/ee/FpMulTruncate.cpp @@ -11,153 +11,174 @@ typedef float fp_t; #define REP_C UINT32_C #define significandBits 23 -#define typeWidth (sizeof(rep_t)*CHAR_BIT) -#define exponentBits (typeWidth - significandBits - 1) -#define maxExponent ((1 << exponentBits) - 1) -#define exponentBias (maxExponent >> 1) +#define typeWidth (sizeof(rep_t) * CHAR_BIT) +#define exponentBits (typeWidth - significandBits - 1) +#define maxExponent ((1 << exponentBits) - 1) +#define exponentBias (maxExponent >> 1) -#define implicitBit (REP_C(1) << significandBits) +#define implicitBit (REP_C(1) << significandBits) #define significandMask (implicitBit - 1U) -#define signBit (REP_C(1) << (significandBits + exponentBits)) -#define absMask (signBit - 1U) -#define exponentMask (absMask ^ significandMask) -#define oneRep ((rep_t)exponentBias << significandBits) -#define infRep exponentMask -#define quietBit (implicitBit >> 1) -#define qnanRep (exponentMask | quietBit) +#define signBit (REP_C(1) << (significandBits + exponentBits)) +#define absMask (signBit - 1U) +#define exponentMask (absMask ^ significandMask) +#define oneRep ((rep_t)exponentBias << significandBits) +#define infRep exponentMask +#define quietBit (implicitBit >> 1) +#define qnanRep (exponentMask | quietBit) -static rep_t toRep(fp_t x) { - union { fp_t f; rep_t i; } rep; +static rep_t toRep(fp_t x) +{ + union { + fp_t f; + rep_t i; + } rep; rep.f = x; - return rep.i; + return rep.i; } -static fp_t fromRep(rep_t x) { - union { fp_t f; rep_t i; } rep; +static fp_t fromRep(rep_t x) +{ + union { + fp_t f; + rep_t i; + } rep; rep.i = x; - return rep.f; + return rep.f; } // 32x32 --> 64 bit multiply -static void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) { - const uint64 product = (uint64)a*b; - *hi = product >> 32; - *lo = product; +static void wideMultiply(rep_t a, rep_t b, rep_t* hi, rep_t* lo) +{ + const uint64 product = (uint64)a * b; + *hi = product >> 32; + *lo = product; } -static void wideLeftShift(rep_t *hi, rep_t *lo, int count) { - *hi = *hi << count | *lo >> (typeWidth - count); - *lo = *lo << count; +static void wideLeftShift(rep_t* hi, rep_t* lo, int count) +{ + *hi = *hi << count | *lo >> (typeWidth - count); + *lo = *lo << count; } -static void wideRightShiftWithSticky(rep_t *hi, rep_t *lo, int count) { - if (count < typeWidth) { - const bool sticky = *lo << (typeWidth - count); - *lo = *hi << (typeWidth - count) | *lo >> count | sticky; - *hi = *hi >> count; - } - else if (count < 2*typeWidth) { - const bool sticky = *hi << (2*typeWidth - count) | *lo; - *lo = *hi >> (count - typeWidth) | sticky; - *hi = 0; - } else { - const bool sticky = *hi | *lo; - *lo = sticky; - *hi = 0; - } +static void wideRightShiftWithSticky(rep_t* hi, rep_t* lo, int count) +{ + if(count < typeWidth) + { + const bool sticky = *lo << (typeWidth - count); + *lo = *hi << (typeWidth - count) | *lo >> count | sticky; + *hi = *hi >> count; + } + else if(count < 2 * typeWidth) + { + const bool sticky = *hi << (2 * typeWidth - count) | *lo; + *lo = *hi >> (count - typeWidth) | sticky; + *hi = 0; + } + else + { + const bool sticky = *hi | *lo; + *lo = sticky; + *hi = 0; + } } -uint32 FpMulTruncate(uint32 a, uint32 b) +uint32 FpMulTruncate(uint32 a, uint32 b) { const unsigned int aExponent = a >> significandBits & maxExponent; const unsigned int bExponent = b >> significandBits & maxExponent; const rep_t productSign = (a ^ b) & signBit; - - rep_t aSignificand = a & significandMask; - rep_t bSignificand = b & significandMask; - int scale = 0; - - // Detect if a or b is zero, denormal, infinity, or NaN. - if (aExponent-1U >= maxExponent-1U || bExponent-1U >= maxExponent-1U) { - - const rep_t aAbs = a & absMask; - const rep_t bAbs = b & absMask; - - // NaN * anything = qNaN - if (aAbs > infRep) return (a | quietBit); - // anything * NaN = qNaN - if (bAbs > infRep) return (b | quietBit); - - if (aAbs == infRep) { - // infinity * non-zero = +/- infinity - if (bAbs) return (aAbs | productSign); - // infinity * zero = NaN - else return qnanRep; - } - - if (bAbs == infRep) { - // non-zero * infinity = +/- infinity - if (aAbs) return (bAbs | productSign); - // zero * infinity = NaN - else return qnanRep; - } - - // zero * anything = +/- zero - if (!aAbs) return productSign; - // anything * zero = +/- zero - if (!bAbs) return productSign; - - // one or both of a or b is denormal, the other (if applicable) is a - // normal number. Renormalize one or both of a and b, and set scale to - // include the necessary exponent adjustment. - if (aAbs < implicitBit) aSignificand = 0; - if (bAbs < implicitBit) bSignificand = 0; - } - - // Or in the implicit significand bit. (If we fell through from the - // denormal path it was already set by normalize( ), but setting it twice - // won't hurt anything.) - aSignificand |= implicitBit; - bSignificand |= implicitBit; - - // Get the significand of a*b. Before multiplying the significands, shift - // one of them left to left-align it in the field. Thus, the product will - // have (exponentBits + 2) integral digits, all but two of which must be - // zero. Normalizing this result is just a conditional left-shift by one - // and bumping the exponent accordingly. - rep_t productHi, productLo; - wideMultiply(aSignificand, bSignificand << exponentBits, - &productHi, &productLo); - - int productExponent = aExponent + bExponent - exponentBias + scale; - - // Normalize the significand, adjust exponent if needed. - if (productHi & implicitBit) + + rep_t aSignificand = a & significandMask; + rep_t bSignificand = b & significandMask; + int scale = 0; + + // Detect if a or b is zero, denormal, infinity, or NaN. + if(aExponent - 1U >= maxExponent - 1U || bExponent - 1U >= maxExponent - 1U) + { + + const rep_t aAbs = a & absMask; + const rep_t bAbs = b & absMask; + + // NaN * anything = qNaN + if(aAbs > infRep) return (a | quietBit); + // anything * NaN = qNaN + if(bAbs > infRep) return (b | quietBit); + + if(aAbs == infRep) + { + // infinity * non-zero = +/- infinity + if(bAbs) return (aAbs | productSign); + // infinity * zero = NaN + else + return qnanRep; + } + + if(bAbs == infRep) + { + // non-zero * infinity = +/- infinity + if(aAbs) return (bAbs | productSign); + // zero * infinity = NaN + else + return qnanRep; + } + + // zero * anything = +/- zero + if(!aAbs) return productSign; + // anything * zero = +/- zero + if(!bAbs) return productSign; + + // one or both of a or b is denormal, the other (if applicable) is a + // normal number. Renormalize one or both of a and b, and set scale to + // include the necessary exponent adjustment. + if(aAbs < implicitBit) aSignificand = 0; + if(bAbs < implicitBit) bSignificand = 0; + } + + // Or in the implicit significand bit. (If we fell through from the + // denormal path it was already set by normalize( ), but setting it twice + // won't hurt anything.) + aSignificand |= implicitBit; + bSignificand |= implicitBit; + + // Get the significand of a*b. Before multiplying the significands, shift + // one of them left to left-align it in the field. Thus, the product will + // have (exponentBits + 2) integral digits, all but two of which must be + // zero. Normalizing this result is just a conditional left-shift by one + // and bumping the exponent accordingly. + rep_t productHi, productLo; + wideMultiply(aSignificand, bSignificand << exponentBits, + &productHi, &productLo); + + int productExponent = aExponent + bExponent - exponentBias + scale; + + // Normalize the significand, adjust exponent if needed. + if(productHi & implicitBit) { productExponent++; } - else + else { wideLeftShift(&productHi, &productLo, 1); } - - // If we have overflowed the type, return +/- infinity. - if (productExponent >= maxExponent) return infRep | productSign; - - if (productExponent <= 0) { - // Result is denormal before rounding, the exponent is zero and we - // need to shift the significand. - wideRightShiftWithSticky(&productHi, &productLo, 1 - productExponent); - } - else + + // If we have overflowed the type, return +/- infinity. + if(productExponent >= maxExponent) return infRep | productSign; + + if(productExponent <= 0) { - // Result is normal before rounding; insert the exponent. - productHi &= significandMask; - productHi |= (rep_t)productExponent << significandBits; - } - - // Insert the sign of the result: - productHi |= productSign; - - return productHi; + // Result is denormal before rounding, the exponent is zero and we + // need to shift the significand. + wideRightShiftWithSticky(&productHi, &productLo, 1 - productExponent); + } + else + { + // Result is normal before rounding; insert the exponent. + productHi &= significandMask; + productHi |= (rep_t)productExponent << significandBits; + } + + // Insert the sign of the result: + productHi |= productSign; + + return productHi; } diff --git a/Source/ee/GIF.cpp b/Source/ee/GIF.cpp index 737e3bf45..bdd74cef2 100644 --- a/Source/ee/GIF.cpp +++ b/Source/ee/GIF.cpp @@ -9,31 +9,30 @@ #define LOG_NAME ("gif") -#define STATE_REGS_XML ("gif/regs.xml") -#define STATE_REGS_M3P ("M3P") +#define STATE_REGS_XML ("gif/regs.xml") +#define STATE_REGS_M3P ("M3P") #define STATE_REGS_ACTIVEPATH ("ActivePath") -#define STATE_REGS_LOOPS ("LOOPS") -#define STATE_REGS_CMD ("CMD") -#define STATE_REGS_REGS ("REGS") -#define STATE_REGS_REGSTEMP ("REGSTEMP") -#define STATE_REGS_REGLIST ("REGLIST") -#define STATE_REGS_EOP ("EOP") -#define STATE_REGS_QTEMP ("QTEMP") +#define STATE_REGS_LOOPS ("LOOPS") +#define STATE_REGS_CMD ("CMD") +#define STATE_REGS_REGS ("REGS") +#define STATE_REGS_REGSTEMP ("REGSTEMP") +#define STATE_REGS_REGLIST ("REGLIST") +#define STATE_REGS_EOP ("EOP") +#define STATE_REGS_QTEMP ("QTEMP") CGIF::CGIF(CGSHandler*& gs, uint8* ram, uint8* spr) -: m_gs(gs) -, m_ram(ram) -, m_spr(spr) -, m_loops(0) -, m_cmd(0) -, m_regs(0) -, m_regsTemp(0) -, m_regList(0) -, m_eop(false) -, m_qtemp(0) -, m_gifProfilerZone(CProfiler::GetInstance().RegisterZone("GIF")) + : m_gs(gs) + , m_ram(ram) + , m_spr(spr) + , m_loops(0) + , m_cmd(0) + , m_regs(0) + , m_regsTemp(0) + , m_regList(0) + , m_eop(false) + , m_qtemp(0) + , m_gifProfilerZone(CProfiler::GetInstance().RegisterZone("GIF")) { - } void CGIF::Reset() @@ -54,28 +53,28 @@ void CGIF::LoadState(Framework::CZipArchiveReader& archive) { CRegisterStateFile registerFile(*archive.BeginReadFile(STATE_REGS_XML)); m_path3Masked = registerFile.GetRegister32(STATE_REGS_M3P) != 0; - m_activePath = registerFile.GetRegister32(STATE_REGS_ACTIVEPATH); - m_loops = static_cast(registerFile.GetRegister32(STATE_REGS_LOOPS)); - m_cmd = static_cast(registerFile.GetRegister32(STATE_REGS_CMD)); - m_regs = static_cast(registerFile.GetRegister32(STATE_REGS_REGS)); - m_regsTemp = static_cast(registerFile.GetRegister32(STATE_REGS_REGSTEMP)); - m_regList = registerFile.GetRegister64(STATE_REGS_REGLIST); - m_eop = registerFile.GetRegister32(STATE_REGS_EOP) != 0; - m_qtemp = registerFile.GetRegister32(STATE_REGS_QTEMP); + m_activePath = registerFile.GetRegister32(STATE_REGS_ACTIVEPATH); + m_loops = static_cast(registerFile.GetRegister32(STATE_REGS_LOOPS)); + m_cmd = static_cast(registerFile.GetRegister32(STATE_REGS_CMD)); + m_regs = static_cast(registerFile.GetRegister32(STATE_REGS_REGS)); + m_regsTemp = static_cast(registerFile.GetRegister32(STATE_REGS_REGSTEMP)); + m_regList = registerFile.GetRegister64(STATE_REGS_REGLIST); + m_eop = registerFile.GetRegister32(STATE_REGS_EOP) != 0; + m_qtemp = registerFile.GetRegister32(STATE_REGS_QTEMP); } void CGIF::SaveState(Framework::CZipArchiveWriter& archive) { CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_REGS_XML); - registerFile->SetRegister32(STATE_REGS_M3P, m_path3Masked ? 1 : 0); + registerFile->SetRegister32(STATE_REGS_M3P, m_path3Masked ? 1 : 0); registerFile->SetRegister32(STATE_REGS_ACTIVEPATH, m_activePath); - registerFile->SetRegister32(STATE_REGS_LOOPS, m_loops); - registerFile->SetRegister32(STATE_REGS_CMD, m_cmd); - registerFile->SetRegister32(STATE_REGS_REGS, m_regs); - registerFile->SetRegister32(STATE_REGS_REGSTEMP, m_regsTemp); - registerFile->SetRegister64(STATE_REGS_REGLIST, m_regList); - registerFile->SetRegister32(STATE_REGS_EOP, m_eop ? 1 : 0); - registerFile->SetRegister32(STATE_REGS_QTEMP, m_qtemp); + registerFile->SetRegister32(STATE_REGS_LOOPS, m_loops); + registerFile->SetRegister32(STATE_REGS_CMD, m_cmd); + registerFile->SetRegister32(STATE_REGS_REGS, m_regs); + registerFile->SetRegister32(STATE_REGS_REGSTEMP, m_regsTemp); + registerFile->SetRegister64(STATE_REGS_REGLIST, m_regList); + registerFile->SetRegister32(STATE_REGS_EOP, m_eop ? 1 : 0); + registerFile->SetRegister32(STATE_REGS_QTEMP, m_qtemp); archive.InsertFile(registerFile); } @@ -100,7 +99,7 @@ uint32 CGIF::ProcessPacked(CGSHandler::RegisterWriteList& writeList, const uint8 break; case 0x01: //RGBA - temp = (packet.nV[0] & 0xFF); + temp = (packet.nV[0] & 0xFF); temp |= (packet.nV[1] & 0xFF) << 8; temp |= (packet.nV[2] & 0xFF) << 16; temp |= (packet.nV[3] & 0xFF) << 24; @@ -114,13 +113,13 @@ uint32 CGIF::ProcessPacked(CGSHandler::RegisterWriteList& writeList, const uint8 break; case 0x03: //UV - temp = (packet.nV[0] & 0x7FFF); + temp = (packet.nV[0] & 0x7FFF); temp |= (packet.nV[1] & 0x7FFF) << 16; writeList.push_back(CGSHandler::RegisterWrite(GS_REG_UV, temp)); break; case 0x04: //XYZF2 - temp = (packet.nV[0] & 0xFFFF); + temp = (packet.nV[0] & 0xFFFF); temp |= (packet.nV[1] & 0xFFFF) << 16; temp |= (uint64)(packet.nV[2] & 0x0FFFFFF0) << 28; temp |= (uint64)(packet.nV[3] & 0x00000FF0) << 52; @@ -135,7 +134,7 @@ uint32 CGIF::ProcessPacked(CGSHandler::RegisterWriteList& writeList, const uint8 break; case 0x05: //XYZ2 - temp = (packet.nV[0] & 0xFFFF); + temp = (packet.nV[0] & 0xFFFF); temp |= (packet.nV[1] & 0xFFFF) << 16; temp |= (uint64)(packet.nV[2] & 0xFFFFFFFF) << 32; if(packet.nV[3] & 0x8000) @@ -261,23 +260,22 @@ uint32 CGIF::ProcessSinglePacket(const uint8* memory, uint32 address, uint32 end { static CGSHandler::RegisterWriteList writeList; static const auto flushWriteList = - [] (CGSHandler* gs, const CGsPacketMetadata& packetMetadata) - { - if(!writeList.empty()) - { - auto currentCapacity = writeList.capacity(); - gs->WriteRegisterMassively(std::move(writeList), &packetMetadata); - writeList.reserve(currentCapacity); - } - }; + [](CGSHandler* gs, const CGsPacketMetadata& packetMetadata) { + if(!writeList.empty()) + { + auto currentCapacity = writeList.capacity(); + gs->WriteRegisterMassively(std::move(writeList), &packetMetadata); + writeList.reserve(currentCapacity); + } + }; #ifdef PROFILE CProfilerZone profilerZone(m_gifProfilerZone); #endif #if defined(_DEBUG) && defined(DEBUGGER_INCLUDED) - CLog::GetInstance().Print(LOG_NAME, "Received GIF packet on path %d at 0x%08X of 0x%08X bytes.\r\n", - packetMetadata.pathIndex, address, end - address); + CLog::GetInstance().Print(LOG_NAME, "Received GIF packet on path %d at 0x%08X of 0x%08X bytes.\r\n", + packetMetadata.pathIndex, address, end - address); #endif assert((m_activePath == 0) || (m_activePath == packetMetadata.pathIndex)); @@ -301,14 +299,14 @@ uint32 CGIF::ProcessSinglePacket(const uint8* memory, uint32 address, uint32 end address += 0x10; #ifdef _DEBUG CLog::GetInstance().Print(LOG_NAME, "TAG(loops = %d, eop = %d, pre = %d, prim = 0x%04X, cmd = %d, nreg = %d);\r\n", - tag.loops, tag.eop, tag.pre, tag.prim, tag.cmd, tag.nreg); + tag.loops, tag.eop, tag.pre, tag.prim, tag.cmd, tag.nreg); #endif - m_loops = tag.loops; - m_cmd = tag.cmd; - m_regs = tag.nreg; - m_regList = tag.regs; - m_eop = (tag.eop != 0); + m_loops = tag.loops; + m_cmd = tag.cmd; + m_regs = tag.nreg; + m_regList = tag.regs; + m_eop = (tag.eop != 0); if(m_cmd != 1) { @@ -413,7 +411,7 @@ uint32 CGIF::ReceiveDMA(uint32 address, uint32 qwc, uint32 unused, bool tagInclu assert(qwc >= 0); address += 0x10; } - + address += ProcessMultiplePackets(memory, address, end, CGsPacketMetadata(3)); assert(address <= end); diff --git a/Source/ee/GIF.h b/Source/ee/GIF.h index 1ac8b83f5..b9cf3b6f5 100644 --- a/Source/ee/GIF.h +++ b/Source/ee/GIF.h @@ -11,53 +11,53 @@ class CGIF public: enum REGISTER { - GIF_STAT = 0x10003020 + GIF_STAT = 0x10003020 }; enum { - GIF_STAT_M3P = 0x002, - GIF_STAT_APATH3 = 0xC00, + GIF_STAT_M3P = 0x002, + GIF_STAT_APATH3 = 0xC00, }; enum { - REGS_START = 0x10003000, - REGS_END = 0x100030B0, + REGS_START = 0x10003000, + REGS_END = 0x100030B0, }; struct TAG { - unsigned int loops : 15; - unsigned int eop : 1; - unsigned int reserved0 : 16; - unsigned int reserved1 : 14; - unsigned int pre : 1; - unsigned int prim : 11; - unsigned int cmd : 2; - unsigned int nreg : 4; - uint64 regs; + unsigned int loops : 15; + unsigned int eop : 1; + unsigned int reserved0 : 16; + unsigned int reserved1 : 14; + unsigned int pre : 1; + unsigned int prim : 11; + unsigned int cmd : 2; + unsigned int nreg : 4; + uint64 regs; }; static_assert(sizeof(TAG) == 0x10, "Size of TAG must be 16 bytes."); - CGIF(CGSHandler*&, uint8*, uint8*); - virtual ~CGIF() = default; + CGIF(CGSHandler*&, uint8*, uint8*); + virtual ~CGIF() = default; - void Reset(); - uint32 ReceiveDMA(uint32, uint32, uint32, bool); + void Reset(); + uint32 ReceiveDMA(uint32, uint32, uint32, bool); - uint32 ProcessSinglePacket(const uint8*, uint32, uint32, const CGsPacketMetadata&); - uint32 ProcessMultiplePackets(const uint8*, uint32, uint32, const CGsPacketMetadata&); + uint32 ProcessSinglePacket(const uint8*, uint32, uint32, const CGsPacketMetadata&); + uint32 ProcessMultiplePackets(const uint8*, uint32, uint32, const CGsPacketMetadata&); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); - CGSHandler* GetGsHandler(); + CGSHandler* GetGsHandler(); - void SetPath3Masked(bool); + void SetPath3Masked(bool); - void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); private: enum SIGNAL_STATE @@ -67,27 +67,27 @@ private: SIGNAL_STATE_PENDING, }; - uint32 ProcessPacked(CGSHandler::RegisterWriteList&, const uint8*, uint32, uint32); - uint32 ProcessRegList(CGSHandler::RegisterWriteList&, const uint8*, uint32, uint32); - uint32 ProcessImage(const uint8*, uint32, uint32); + uint32 ProcessPacked(CGSHandler::RegisterWriteList&, const uint8*, uint32, uint32); + uint32 ProcessRegList(CGSHandler::RegisterWriteList&, const uint8*, uint32, uint32); + uint32 ProcessImage(const uint8*, uint32, uint32); - void DisassembleGet(uint32); - void DisassembleSet(uint32, uint32); + void DisassembleGet(uint32); + void DisassembleSet(uint32, uint32); - bool m_path3Masked = false; - uint32 m_activePath = 0; + bool m_path3Masked = false; + uint32 m_activePath = 0; - uint16 m_loops; - uint8 m_cmd; - uint8 m_regs; - uint8 m_regsTemp; - uint64 m_regList; - bool m_eop; - uint32 m_qtemp; - SIGNAL_STATE m_signalState = SIGNAL_STATE_NONE; - uint8* m_ram; - uint8* m_spr; - CGSHandler*& m_gs; + uint16 m_loops; + uint8 m_cmd; + uint8 m_regs; + uint8 m_regsTemp; + uint64 m_regList; + bool m_eop; + uint32 m_qtemp; + SIGNAL_STATE m_signalState = SIGNAL_STATE_NONE; + uint8* m_ram; + uint8* m_spr; + CGSHandler*& m_gs; CProfiler::ZoneHandle m_gifProfilerZone = 0; }; diff --git a/Source/ee/INTC.cpp b/Source/ee/INTC.cpp index 8faf60b01..69fa5cc6e 100644 --- a/Source/ee/INTC.cpp +++ b/Source/ee/INTC.cpp @@ -2,22 +2,20 @@ #include "../Log.h" #include "../RegisterStateFile.h" -#define LOG_NAME ("intc") +#define LOG_NAME ("intc") -#define STATE_REGS_XML ("intc/regs.xml") +#define STATE_REGS_XML ("intc/regs.xml") CINTC::CINTC(CDMAC& dmac, CGSHandler*& gs) -: m_INTC_STAT(0) -, m_INTC_MASK(0) -, m_dmac(dmac) -, m_gs(gs) + : m_INTC_STAT(0) + , m_INTC_MASK(0) + , m_dmac(dmac) + , m_gs(gs) { - } CINTC::~CINTC() { - } void CINTC::Reset() diff --git a/Source/ee/INTC.h b/Source/ee/INTC.h index 63bc8df03..586abd081 100644 --- a/Source/ee/INTC.h +++ b/Source/ee/INTC.h @@ -17,38 +17,38 @@ public: enum LINES { - INTC_LINE_GS = 0, - INTC_LINE_DMAC = 1, - INTC_LINE_VBLANK_START = 2, - INTC_LINE_VBLANK_END = 3, - INTC_LINE_VIF0 = 4, - INTC_LINE_VIF1 = 5, - INTC_LINE_IPU = 8, - INTC_LINE_TIMER0 = 9, - INTC_LINE_TIMER1 = 10, - INTC_LINE_TIMER2 = 11, - INTC_LINE_TIMER3 = 12, + INTC_LINE_GS = 0, + INTC_LINE_DMAC = 1, + INTC_LINE_VBLANK_START = 2, + INTC_LINE_VBLANK_END = 3, + INTC_LINE_VIF0 = 4, + INTC_LINE_VIF1 = 5, + INTC_LINE_IPU = 8, + INTC_LINE_TIMER0 = 9, + INTC_LINE_TIMER1 = 10, + INTC_LINE_TIMER2 = 11, + INTC_LINE_TIMER3 = 12, }; - CINTC(CDMAC&, CGSHandler*&); - virtual ~CINTC(); + CINTC(CDMAC&, CGSHandler*&); + virtual ~CINTC(); - void Reset(); - bool IsInterruptPending() const; + void Reset(); + bool IsInterruptPending() const; - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); - void AssertLine(uint32); + void AssertLine(uint32); - void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); private: - uint32 GetStat() const; + uint32 GetStat() const; - uint32 m_INTC_STAT; - uint32 m_INTC_MASK; - CDMAC& m_dmac; - CGSHandler*& m_gs; + uint32 m_INTC_STAT; + uint32 m_INTC_MASK; + CDMAC& m_dmac; + CGSHandler*& m_gs; }; diff --git a/Source/ee/IPU.cpp b/Source/ee/IPU.cpp index c8a0dba4f..304c1ef3d 100644 --- a/Source/ee/IPU.cpp +++ b/Source/ee/IPU.cpp @@ -43,29 +43,27 @@ static CVLCTable::DECODE_STATUS FilterSymbolError(CVLCTable::DECODE_STATUS resul } CIPU::CIPU(CINTC& intc) -: m_intc(intc) -, m_IPU_CTRL(0) -, m_isBusy(false) -, m_currentCmd(nullptr) + : m_intc(intc) + , m_IPU_CTRL(0) + , m_isBusy(false) + , m_currentCmd(nullptr) { - } CIPU::~CIPU() { - } void CIPU::Reset() { - m_IPU_CTRL = 0; - m_IPU_CMD[0] = 0; - m_IPU_CMD[1] = 0; - m_nTH0 = 0; - m_nTH1 = 0; + m_IPU_CTRL = 0; + m_IPU_CMD[0] = 0; + m_IPU_CMD[1] = 0; + m_nTH0 = 0; + m_nTH1 = 0; - m_isBusy = false; - m_currentCmd = nullptr; + m_isBusy = false; + m_currentCmd = nullptr; m_IN_FIFO.Reset(); m_OUT_FIFO.Reset(); @@ -90,22 +88,22 @@ uint32 CIPU::GetRegister(uint32 nAddress) break; case IPU_CTRL + 0x0: - { - auto fifoState = GetFifoState(); - return m_IPU_CTRL | GetBusyBit(m_isBusy) | fifoState.ifc; - } - break; + { + auto fifoState = GetFifoState(); + return m_IPU_CTRL | GetBusyBit(m_isBusy) | fifoState.ifc; + } + break; case IPU_CTRL + 0x4: case IPU_CTRL + 0x8: case IPU_CTRL + 0xC: break; case IPU_BP + 0x0: - { - auto fifoState = GetFifoState(); - return (fifoState.fp << 16) | (fifoState.ifc << 8) | fifoState.bp; - } - break; + { + auto fifoState = GetFifoState(); + return (fifoState.fp << 16) | (fifoState.ifc << 8) | fifoState.bp; + } + break; case IPU_BP + 0x4: case IPU_BP + 0x8: @@ -129,13 +127,13 @@ uint32 CIPU::GetRegister(uint32 nAddress) break; case IPU_TOP + 0x4: - { - //Not quite sure about this... are we really busy if there's no data in the FIFO? - //This was needed to fix Timesplitters - unsigned int availableSize = std::min(32, m_IN_FIFO.GetAvailableBits()); - return GetBusyBit(m_isBusy) | GetBusyBit(availableSize != 32); - } - break; + { + //Not quite sure about this... are we really busy if there's no data in the FIFO? + //This was needed to fix Timesplitters + unsigned int availableSize = std::min(32, m_IN_FIFO.GetAvailableBits()); + return GetBusyBit(m_isBusy) | GetBusyBit(availableSize != 32); + } + break; case IPU_TOP + 0x8: case IPU_TOP + 0xC: @@ -245,7 +243,6 @@ void CIPU::ExecuteCommand() } catch(const Framework::CBitStream::CBitStreamException&) { - } catch(const CStartCodeException&) { @@ -280,60 +277,60 @@ void CIPU::InitializeCommand(uint32 value) switch(nCmd) { case IPU_CMD_BCLR: - { - m_BCLRCommand.Initialize(&m_IN_FIFO, value); - m_currentCmd = &m_BCLRCommand; - } - break; + { + m_BCLRCommand.Initialize(&m_IN_FIFO, value); + m_currentCmd = &m_BCLRCommand; + } + break; case IPU_CMD_IDEC: - { - m_IDECCommand.Initialize(&m_BDECCommand, &m_CSCCommand, &m_IN_FIFO, &m_OUT_FIFO, value, GetDecoderContext(), m_nTH0, m_nTH1); - m_currentCmd = &m_IDECCommand; - } - break; + { + m_IDECCommand.Initialize(&m_BDECCommand, &m_CSCCommand, &m_IN_FIFO, &m_OUT_FIFO, value, GetDecoderContext(), m_nTH0, m_nTH1); + m_currentCmd = &m_IDECCommand; + } + break; case IPU_CMD_BDEC: - { - m_BDECCommand.Initialize(&m_IN_FIFO, &m_OUT_FIFO, value, true, GetDecoderContext()); - m_currentCmd = &m_BDECCommand; - } - break; + { + m_BDECCommand.Initialize(&m_IN_FIFO, &m_OUT_FIFO, value, true, GetDecoderContext()); + m_currentCmd = &m_BDECCommand; + } + break; case IPU_CMD_VDEC: - { - m_VDECCommand.Initialize(&m_IN_FIFO, value, GetPictureType(), &m_IPU_CMD[0]); - m_currentCmd = &m_VDECCommand; - } - break; + { + m_VDECCommand.Initialize(&m_IN_FIFO, value, GetPictureType(), &m_IPU_CMD[0]); + m_currentCmd = &m_VDECCommand; + } + break; case IPU_CMD_FDEC: - { - m_FDECCommand.Initialize(&m_IN_FIFO, value, &m_IPU_CMD[0]); - m_currentCmd = &m_FDECCommand; - } - break; + { + m_FDECCommand.Initialize(&m_IN_FIFO, value, &m_IPU_CMD[0]); + m_currentCmd = &m_FDECCommand; + } + break; case IPU_CMD_SETIQ: - { - uint8* matrix = (value & 0x08000000) ? m_nNonIntraIQ : m_nIntraIQ; - m_SETIQCommand.Initialize(&m_IN_FIFO, matrix); - m_currentCmd = &m_SETIQCommand; - } - break; + { + uint8* matrix = (value & 0x08000000) ? m_nNonIntraIQ : m_nIntraIQ; + m_SETIQCommand.Initialize(&m_IN_FIFO, matrix); + m_currentCmd = &m_SETIQCommand; + } + break; case IPU_CMD_SETVQ: - { - m_SETVQCommand.Initialize(&m_IN_FIFO, m_nVQCLUT); - m_currentCmd = &m_SETVQCommand; - } - break; + { + m_SETVQCommand.Initialize(&m_IN_FIFO, m_nVQCLUT); + m_currentCmd = &m_SETVQCommand; + } + break; case IPU_CMD_CSC: - { - m_CSCCommand.Initialize(&m_IN_FIFO, &m_OUT_FIFO, value, m_nTH0, m_nTH1); - m_currentCmd = &m_CSCCommand; - } - break; + { + m_CSCCommand.Initialize(&m_IN_FIFO, &m_OUT_FIFO, value, m_nTH0, m_nTH1); + m_currentCmd = &m_CSCCommand; + } + break; case IPU_CMD_SETTH: - { - m_SETTHCommand.Initialize(value, &m_nTH0, &m_nTH1); - m_currentCmd = &m_SETTHCommand; - } - break; + { + m_SETTHCommand.Initialize(value, &m_nTH0, &m_nTH1); + m_currentCmd = &m_SETTHCommand; + } + break; default: assert(0); CLog::GetInstance().Print(LOG_NAME, "Unhandled command execution requested (%d).\r\n", value >> 28); @@ -366,14 +363,14 @@ uint32 CIPU::ReceiveDMA4(uint32 nAddress, uint32 nQWC, bool nTagIncluded, uint8* CIPU::DECODER_CONTEXT CIPU::GetDecoderContext() { DECODER_CONTEXT context; - context.isMpeg1CoeffVLCTable = GetIsMPEG1CoeffVLCTable(); - context.isMpeg2 = GetIsMPEG2(); - context.isZigZag = GetIsZigZagScan(); - context.isLinearQScale = GetIsLinearQScale(); - context.dcPrecision = GetDcPrecision(); - context.intraIq = m_nIntraIQ; - context.nonIntraIq = m_nNonIntraIQ; - context.dcPredictor = m_nDcPredictor; + context.isMpeg1CoeffVLCTable = GetIsMPEG1CoeffVLCTable(); + context.isMpeg2 = GetIsMPEG2(); + context.isZigZag = GetIsZigZagScan(); + context.isLinearQScale = GetIsLinearQScale(); + context.dcPrecision = GetDcPrecision(); + context.intraIq = m_nIntraIQ; + context.nonIntraIq = m_nNonIntraIQ; + context.dcPredictor = m_nDcPredictor; return context; } @@ -438,7 +435,7 @@ void CIPU::DequantiseBlock(int16* pBlock, uint8 nMBI, uint8 nQSC, bool isLinearQ } pBlock[0] = nIntraDcMult * pBlock[0]; - + for(unsigned int i = 1; i < 64; i++) { int16 nSign = 0; @@ -508,7 +505,6 @@ void CIPU::DequantiseBlock(int16* pBlock, uint8 nMBI, uint8 nQSC, bool isLinearQ if(nSum & 1) { - } } @@ -595,7 +591,6 @@ void CIPU::DisassembleSet(uint32 nAddress, uint32 nValue) CLog::GetInstance().Print(LOG_NAME, "IPU_IN_FIFO = 0x%08X\r\n", nValue); break; } - } void CIPU::DisassembleCommand(uint32 nValue) @@ -606,55 +601,55 @@ void CIPU::DisassembleCommand(uint32 nValue) CLog::GetInstance().Print(LOG_NAME, "BCLR(bp = %i);\r\n", nValue & 0x7F); break; case 2: - CLog::GetInstance().Print(LOG_NAME, "BDEC(mbi = %i, dcr = %i, dt = %i, qsc = %i, fb = %i);\r\n", \ - (nValue >> 27) & 1, \ - (nValue >> 26) & 1, \ - (nValue >> 25) & 1, \ - (nValue >> 16) & 0x1F, \ - nValue & 0x3F); + CLog::GetInstance().Print(LOG_NAME, "BDEC(mbi = %i, dcr = %i, dt = %i, qsc = %i, fb = %i);\r\n", + (nValue >> 27) & 1, + (nValue >> 26) & 1, + (nValue >> 25) & 1, + (nValue >> 16) & 0x1F, + nValue & 0x3F); break; case 3: + { + uint32 tbl = (nValue >> 26) & 0x3; + const char* tblName = NULL; + switch(tbl) { - uint32 tbl = (nValue >> 26) & 0x3; - const char* tblName = NULL; - switch(tbl) + case 0: + //Macroblock Address Increment + tblName = "MBI"; + break; + case 1: + //Macroblock Type + switch(GetPictureType()) { - case 0: - //Macroblock Address Increment - tblName = "MBI"; - break; case 1: - //Macroblock Type - switch(GetPictureType()) - { - case 1: - //I Picture - tblName = "MB Type (I)"; - break; - case 2: - //P Picture - tblName = "MB Type (P)"; - break; - case 3: - //B Picture - tblName = "MB Type (B)"; - break; - default: - assert(0); - return; - break; - } + //I Picture + tblName = "MB Type (I)"; break; case 2: - tblName = "Motion Type"; + //P Picture + tblName = "MB Type (P)"; break; case 3: - tblName = "DM Vector"; + //B Picture + tblName = "MB Type (B)"; + break; + default: + assert(0); + return; break; } - CLog::GetInstance().Print(LOG_NAME, "VDEC(tbl = %i (%s), bp = %i);\r\n", tbl, tblName, nValue & 0x3F); + break; + case 2: + tblName = "Motion Type"; + break; + case 3: + tblName = "DM Vector"; + break; } - break; + CLog::GetInstance().Print(LOG_NAME, "VDEC(tbl = %i (%s), bp = %i);\r\n", tbl, tblName, nValue & 0x3F); + } + break; case 4: CLog::GetInstance().Print(LOG_NAME, "FDEC(bp = %i);\r\n", nValue & 0x3F); break; @@ -665,10 +660,10 @@ void CIPU::DisassembleCommand(uint32 nValue) CLog::GetInstance().Print(LOG_NAME, "SETVQ();\r\n"); break; case 7: - CLog::GetInstance().Print(LOG_NAME, "CSC(ofm = %i, dte = %i, mbc = %i);\r\n", \ - (nValue >> 27) & 1, \ - (nValue >> 26) & 1, \ - (nValue >> 0) & 0x7FF); + CLog::GetInstance().Print(LOG_NAME, "CSC(ofm = %i, dte = %i, mbc = %i);\r\n", + (nValue >> 27) & 1, + (nValue >> 26) & 1, + (nValue >> 0) & 0x7FF); break; case 9: CLog::GetInstance().Print(LOG_NAME, "SETTH(th0 = 0x%04X, th1 = 0x%04X);\r\n", nValue & 0x1FF, (nValue >> 16) & 0x1FF); @@ -681,11 +676,10 @@ void CIPU::DisassembleCommand(uint32 nValue) ///////////////////////////////////////////// CIPU::COUTFIFO::COUTFIFO() -: m_buffer(nullptr) -, m_alloc(0) -, m_size(0) + : m_buffer(nullptr) + , m_alloc(0) + , m_size(0) { - } CIPU::COUTFIFO::~COUTFIFO() @@ -743,20 +737,18 @@ void CIPU::COUTFIFO::RequestGrow(unsigned int size) ///////////////////////////////////////////// CIPU::CINFIFO::CINFIFO() -: m_size(0) -, m_bitPosition(0) + : m_size(0) + , m_bitPosition(0) { - } CIPU::CINFIFO::~CINFIFO() { - } void CIPU::CINFIFO::Write(void* data, unsigned int size) { - if((size + m_size) > BUFFERSIZE) + if((size + m_size) > BUFFERSIZE) { assert(0); return; @@ -880,10 +872,9 @@ void CIPU::CINFIFO::SyncLookupBits() ///////////////////////////////////////////// CIPU::CBCLRCommand::CBCLRCommand() -: m_IN_FIFO(NULL) -, m_commandCode(0) + : m_IN_FIFO(NULL) + , m_commandCode(0) { - } void CIPU::CBCLRCommand::Initialize(CINFIFO* fifo, uint32 commandCode) @@ -906,33 +897,31 @@ bool CIPU::CBCLRCommand::Execute() CIPU::CIDECCommand::CIDECCommand() { m_temp_OUT_FIFO.SetReceiveHandler( - [&] (const void* data, uint32 size) - { - m_blockStream.Write(data, size * 0x10); - return size; - } - ); + [&](const void* data, uint32 size) { + m_blockStream.Write(data, size * 0x10); + return size; + }); } -void CIPU::CIDECCommand::Initialize(CBDECCommand* BDECCommand, CCSCCommand* CSCCommand, CINFIFO* inFifo, COUTFIFO* outFifo, - uint32 commandCode, const DECODER_CONTEXT& context, uint16 TH0, uint16 TH1) +void CIPU::CIDECCommand::Initialize(CBDECCommand* BDECCommand, CCSCCommand* CSCCommand, CINFIFO* inFifo, COUTFIFO* outFifo, + uint32 commandCode, const DECODER_CONTEXT& context, uint16 TH0, uint16 TH1) { m_command <<= commandCode; assert(m_command.cmdId == IPU_CMD_IDEC); - m_IN_FIFO = inFifo; - m_OUT_FIFO = outFifo; - m_BDECCommand = BDECCommand; - m_CSCCommand = CSCCommand; + m_IN_FIFO = inFifo; + m_OUT_FIFO = outFifo; + m_BDECCommand = BDECCommand; + m_CSCCommand = CSCCommand; - m_state = STATE_DELAY; - m_mbType = 0; - m_qsc = m_command.qsc; - m_context = context; - m_TH0 = TH0; - m_TH1 = TH1; - m_mbCount = 0; - m_delayTicks = 1000; + m_state = STATE_DELAY; + m_mbType = 0; + m_qsc = m_command.qsc; + m_context = context; + m_TH0 = TH0; + m_TH1 = TH1; + m_mbCount = 0; + m_delayTicks = 1000; } bool CIPU::CIDECCommand::Execute() @@ -942,38 +931,38 @@ bool CIPU::CIDECCommand::Execute() switch(m_state) { case STATE_DELAY: + { + //We need to induce a delay here because some games (Gust games) will issue a command + //and restart an already active DMA3 transfer + if(m_delayTicks > 0) { - //We need to induce a delay here because some games (Gust games) will issue a command - //and restart an already active DMA3 transfer - if(m_delayTicks > 0) - { - return false; - } - m_state = STATE_ADVANCE; + return false; } - break; + m_state = STATE_ADVANCE; + } + break; case STATE_ADVANCE: - { - m_IN_FIFO->Advance(m_command.fb); - m_state = STATE_READMBTYPE; - } - break; + { + m_IN_FIFO->Advance(m_command.fb); + m_state = STATE_READMBTYPE; + } + break; case STATE_READMBTYPE: + { + if(FilterSymbolError(CMacroblockTypeITable::GetInstance()->TryGetSymbol(m_IN_FIFO, m_mbType)) != CVLCTable::DECODE_STATUS_SUCCESS) { - if(FilterSymbolError(CMacroblockTypeITable::GetInstance()->TryGetSymbol(m_IN_FIFO, m_mbType)) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } - assert(m_mbType & 0x1); //Must always be intra block - m_state = STATE_READDCTTYPE; + return false; } - break; + assert(m_mbType & 0x1); //Must always be intra block + m_state = STATE_READDCTTYPE; + } + break; case STATE_READDCTTYPE: assert(m_command.dtd == 0); m_state = STATE_READQSC; break; case STATE_READQSC: - if(m_mbType & 0x10) //QSC flag + if(m_mbType & 0x10) //QSC flag { if(!m_IN_FIFO->TryGetBits_MSBF(5, m_qsc)) { @@ -983,46 +972,46 @@ bool CIPU::CIDECCommand::Execute() m_state = STATE_INITREADBLOCK; break; case STATE_INITREADBLOCK: - { - auto bdecCommand = make_convertible(0); - bdecCommand.cmdId = IPU_CMD_BDEC; - bdecCommand.fb = 0; - bdecCommand.mbi = 1; - bdecCommand.dt = 0; - bdecCommand.dcr = (m_mbCount == 0) ? 1 : 0; - bdecCommand.qsc = m_qsc; - m_BDECCommand->Initialize(m_IN_FIFO, &m_temp_OUT_FIFO, bdecCommand, false, m_context); - m_state = STATE_READBLOCK; - m_blockStream.ResetBuffer(); - } - break; + { + auto bdecCommand = make_convertible(0); + bdecCommand.cmdId = IPU_CMD_BDEC; + bdecCommand.fb = 0; + bdecCommand.mbi = 1; + bdecCommand.dt = 0; + bdecCommand.dcr = (m_mbCount == 0) ? 1 : 0; + bdecCommand.qsc = m_qsc; + m_BDECCommand->Initialize(m_IN_FIFO, &m_temp_OUT_FIFO, bdecCommand, false, m_context); + m_state = STATE_READBLOCK; + m_blockStream.ResetBuffer(); + } + break; case STATE_READBLOCK: + { + if(!m_BDECCommand->Execute()) { - if(!m_BDECCommand->Execute()) - { - return false; - } - //BDEC will yield 384 elements in RAW16 format - assert(m_blockStream.GetSize() == (CCSCCommand::BLOCK_SIZE * sizeof(int16))); - ConvertRawBlock(); - m_state = STATE_CSCINIT; - m_mbCount++; + return false; } - break; + //BDEC will yield 384 elements in RAW16 format + assert(m_blockStream.GetSize() == (CCSCCommand::BLOCK_SIZE * sizeof(int16))); + ConvertRawBlock(); + m_state = STATE_CSCINIT; + m_mbCount++; + } + break; case STATE_CSCINIT: - { - auto cscCommand = make_convertible(0); - cscCommand.cmdId = IPU_CMD_CSC; - cscCommand.mbc = 1; - cscCommand.dte = m_command.dte; - cscCommand.ofm = m_command.ofm; - m_CSCCommand->Initialize(&m_temp_IN_FIFO, m_OUT_FIFO, cscCommand, m_TH0, m_TH1); - m_state = STATE_CSC; - //CSC requires 384 elements in RAW8 format to proceed - assert(m_blockStream.GetSize() == (CCSCCommand::BLOCK_SIZE * sizeof(uint8))); - m_blockStream.Seek(0, Framework::STREAM_SEEK_SET); - } - break; + { + auto cscCommand = make_convertible(0); + cscCommand.cmdId = IPU_CMD_CSC; + cscCommand.mbc = 1; + cscCommand.dte = m_command.dte; + cscCommand.ofm = m_command.ofm; + m_CSCCommand->Initialize(&m_temp_IN_FIFO, m_OUT_FIFO, cscCommand, m_TH0, m_TH1); + m_state = STATE_CSC; + //CSC requires 384 elements in RAW8 format to proceed + assert(m_blockStream.GetSize() == (CCSCCommand::BLOCK_SIZE * sizeof(uint8))); + m_blockStream.Seek(0, Framework::STREAM_SEEK_SET); + } + break; case STATE_CSC: while(1) { @@ -1050,33 +1039,33 @@ bool CIPU::CIDECCommand::Execute() } break; case STATE_CHECKSTARTCODE: + { + uint32 startCode = 0; + if(!m_IN_FIFO->TryPeekBits_MSBF(23, startCode)) { - uint32 startCode = 0; - if(!m_IN_FIFO->TryPeekBits_MSBF(23, startCode)) - { - return false; - } - if(startCode == 0) - { - m_state = STATE_DONE; - } - else - { - m_state = STATE_READMBINCREMENT; - } + return false; } - break; + if(startCode == 0) + { + m_state = STATE_DONE; + } + else + { + m_state = STATE_READMBINCREMENT; + } + } + break; case STATE_READMBINCREMENT: + { + uint32 mbIncrement = 0; + if(CMacroblockAddressIncrementTable::GetInstance()->TryGetSymbol(m_IN_FIFO, mbIncrement) != CVLCTable::DECODE_STATUS_SUCCESS) { - uint32 mbIncrement = 0; - if(CMacroblockAddressIncrementTable::GetInstance()->TryGetSymbol(m_IN_FIFO, mbIncrement) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } - assert((mbIncrement & 0xFFFF) == 1); - m_state = STATE_READMBTYPE; + return false; } - break; + assert((mbIncrement & 0xFFFF) == 1); + m_state = STATE_READMBTYPE; + } + break; case STATE_DONE: return true; break; @@ -1120,12 +1109,18 @@ void CIPU::CIDECCommand::ConvertRawBlock() CIPU::CBDECCommand::CBDECCommand() { - m_blocks[0].block = m_yBlock[0]; m_blocks[0].channel = 0; - m_blocks[1].block = m_yBlock[1]; m_blocks[1].channel = 0; - m_blocks[2].block = m_yBlock[2]; m_blocks[2].channel = 0; - m_blocks[3].block = m_yBlock[3]; m_blocks[3].channel = 0; - m_blocks[4].block = m_cbBlock; m_blocks[4].channel = 1; - m_blocks[5].block = m_crBlock; m_blocks[5].channel = 2; + m_blocks[0].block = m_yBlock[0]; + m_blocks[0].channel = 0; + m_blocks[1].block = m_yBlock[1]; + m_blocks[1].channel = 0; + m_blocks[2].block = m_yBlock[2]; + m_blocks[2].channel = 0; + m_blocks[3].block = m_yBlock[3]; + m_blocks[3].channel = 0; + m_blocks[4].block = m_cbBlock; + m_blocks[4].channel = 1; + m_blocks[5].block = m_crBlock; + m_blocks[5].channel = 2; } void CIPU::CBDECCommand::Initialize(CINFIFO* inFifo, COUTFIFO* outFifo, uint32 commandCode, bool checkStartCode, const DECODER_CONTEXT& context) @@ -1137,9 +1132,9 @@ void CIPU::CBDECCommand::Initialize(CINFIFO* inFifo, COUTFIFO* outFifo, uint32 c m_context = context; - m_IN_FIFO = inFifo; - m_OUT_FIFO = outFifo; - m_state = STATE_ADVANCE; + m_IN_FIFO = inFifo; + m_OUT_FIFO = outFifo; + m_state = STATE_ADVANCE; m_codedBlockPattern = 0; m_currentBlockIndex = 0; @@ -1152,147 +1147,147 @@ bool CIPU::CBDECCommand::Execute() switch(m_state) { case STATE_ADVANCE: - { - m_IN_FIFO->Advance(m_command.fb); - m_state = STATE_READCBP; - } - break; + { + m_IN_FIFO->Advance(m_command.fb); + m_state = STATE_READCBP; + } + break; case STATE_READCBP: + { + if(!m_command.mbi) { - if(!m_command.mbi) - { - //Not an Intra Macroblock, so we need to fetch the pattern code - m_codedBlockPattern = static_cast(CCodedBlockPatternTable::GetInstance()->GetSymbol(m_IN_FIFO)); - } - else - { - m_codedBlockPattern = 0x3F; - } - m_state = STATE_RESETDC; + //Not an Intra Macroblock, so we need to fetch the pattern code + m_codedBlockPattern = static_cast(CCodedBlockPatternTable::GetInstance()->GetSymbol(m_IN_FIFO)); } - break; + else + { + m_codedBlockPattern = 0x3F; + } + m_state = STATE_RESETDC; + } + break; case STATE_RESETDC: - { + { #ifdef _DECODE_LOGGING - static int currentMbIndex = 0; - CLog::GetInstance().Print(DECODE_LOG_NAME, "Macroblock(%d, CBP: 0x%02X)\r\n", - currentMbIndex++, m_codedBlockPattern); + static int currentMbIndex = 0; + CLog::GetInstance().Print(DECODE_LOG_NAME, "Macroblock(%d, CBP: 0x%02X)\r\n", + currentMbIndex++, m_codedBlockPattern); #endif - if(m_command.dcr) + if(m_command.dcr) + { + int16 resetValue = 0; + + //Reset the DC prediction values + switch(m_context.dcPrecision) { - int16 resetValue = 0; - - //Reset the DC prediction values - switch(m_context.dcPrecision) - { - case 0: - resetValue = 128; - break; - case 1: - resetValue = 256; - break; - case 2: - resetValue = 512; - break; - default: - resetValue = 0; - assert(0); - break; - } - - m_context.dcPredictor[0] = resetValue; - m_context.dcPredictor[1] = resetValue; - m_context.dcPredictor[2] = resetValue; + case 0: + resetValue = 128; + break; + case 1: + resetValue = 256; + break; + case 2: + resetValue = 512; + break; + default: + resetValue = 0; + assert(0); + break; } - m_state = STATE_DECODEBLOCK_BEGIN; + + m_context.dcPredictor[0] = resetValue; + m_context.dcPredictor[1] = resetValue; + m_context.dcPredictor[2] = resetValue; } - break; + m_state = STATE_DECODEBLOCK_BEGIN; + } + break; case STATE_DECODEBLOCK_BEGIN: + { + BLOCKENTRY& blockInfo(m_blocks[m_currentBlockIndex]); + memset(blockInfo.block, 0, sizeof(int16) * 64); + + if((m_codedBlockPattern & (1 << (5 - m_currentBlockIndex)))) { - BLOCKENTRY& blockInfo(m_blocks[m_currentBlockIndex]); - memset(blockInfo.block, 0, sizeof(int16) * 64); + m_readDctCoeffsCommand.Initialize(m_IN_FIFO, + blockInfo.block, blockInfo.channel, + m_context.dcPredictor, (m_command.mbi != 0), m_context.isMpeg1CoeffVLCTable, m_context.isMpeg2); - if((m_codedBlockPattern & (1 << (5 - m_currentBlockIndex)))) - { - m_readDctCoeffsCommand.Initialize(m_IN_FIFO, - blockInfo.block, blockInfo.channel, - m_context.dcPredictor, (m_command.mbi != 0), m_context.isMpeg1CoeffVLCTable, m_context.isMpeg2); - - m_state = STATE_DECODEBLOCK_READCOEFFS; - } - else - { - m_state = STATE_DECODEBLOCK_GOTONEXT; - } + m_state = STATE_DECODEBLOCK_READCOEFFS; } - break; - case STATE_DECODEBLOCK_READCOEFFS: + else { - if(!m_readDctCoeffsCommand.Execute()) - { - return false; - } - - BLOCKENTRY& blockInfo(m_blocks[m_currentBlockIndex]); - int16 blockTemp[0x40]; - - InverseScan(blockInfo.block, m_context.isZigZag); - DequantiseBlock(blockInfo.block, (m_command.mbi != 0), m_command.qsc, - m_context.isLinearQScale, m_context.dcPrecision, m_context.intraIq, m_context.nonIntraIq); - - memcpy(blockTemp, blockInfo.block, sizeof(int16) * 0x40); - - IDCT::CIEEE1180::GetInstance()->Transform(blockTemp, blockInfo.block); - m_state = STATE_DECODEBLOCK_GOTONEXT; } - break; - case STATE_DECODEBLOCK_GOTONEXT: + } + break; + case STATE_DECODEBLOCK_READCOEFFS: + { + if(!m_readDctCoeffsCommand.Execute()) { - m_currentBlockIndex++; - if(m_currentBlockIndex == 6) - { - m_state = STATE_DONE; - } - else - { - m_state = STATE_DECODEBLOCK_BEGIN; - } + return false; } - break; - case STATE_DONE: + + BLOCKENTRY& blockInfo(m_blocks[m_currentBlockIndex]); + int16 blockTemp[0x40]; + + InverseScan(blockInfo.block, m_context.isZigZag); + DequantiseBlock(blockInfo.block, (m_command.mbi != 0), m_command.qsc, + m_context.isLinearQScale, m_context.dcPrecision, m_context.intraIq, m_context.nonIntraIq); + + memcpy(blockTemp, blockInfo.block, sizeof(int16) * 0x40); + + IDCT::CIEEE1180::GetInstance()->Transform(blockTemp, blockInfo.block); + + m_state = STATE_DECODEBLOCK_GOTONEXT; + } + break; + case STATE_DECODEBLOCK_GOTONEXT: + { + m_currentBlockIndex++; + if(m_currentBlockIndex == 6) { - //Write blocks into out FIFO - for(unsigned int i = 0; i < 8; i++) + m_state = STATE_DONE; + } + else + { + m_state = STATE_DECODEBLOCK_BEGIN; + } + } + break; + case STATE_DONE: + { + //Write blocks into out FIFO + for(unsigned int i = 0; i < 8; i++) + { + m_OUT_FIFO->Write(m_blocks[0].block + (i * 8), sizeof(int16) * 0x8); + m_OUT_FIFO->Write(m_blocks[1].block + (i * 8), sizeof(int16) * 0x8); + } + + for(unsigned int i = 0; i < 8; i++) + { + m_OUT_FIFO->Write(m_blocks[2].block + (i * 8), sizeof(int16) * 0x8); + m_OUT_FIFO->Write(m_blocks[3].block + (i * 8), sizeof(int16) * 0x8); + } + + m_OUT_FIFO->Write(m_blocks[4].block, sizeof(int16) * 0x40); + m_OUT_FIFO->Write(m_blocks[5].block, sizeof(int16) * 0x40); + + m_OUT_FIFO->Flush(); + + //Check if there's more than 7 zero bits after this and set "start code detected" + if(m_checkStartCode) + { + uint32 nextBits = 0; + if(m_IN_FIFO->TryPeekBits_MSBF(8, nextBits)) { - m_OUT_FIFO->Write(m_blocks[0].block + (i * 8), sizeof(int16) * 0x8); - m_OUT_FIFO->Write(m_blocks[1].block + (i * 8), sizeof(int16) * 0x8); - } - - for(unsigned int i = 0; i < 8; i++) - { - m_OUT_FIFO->Write(m_blocks[2].block + (i * 8), sizeof(int16) * 0x8); - m_OUT_FIFO->Write(m_blocks[3].block + (i * 8), sizeof(int16) * 0x8); - } - - m_OUT_FIFO->Write(m_blocks[4].block, sizeof(int16) * 0x40); - m_OUT_FIFO->Write(m_blocks[5].block, sizeof(int16) * 0x40); - - m_OUT_FIFO->Flush(); - - //Check if there's more than 7 zero bits after this and set "start code detected" - if(m_checkStartCode) - { - uint32 nextBits = 0; - if(m_IN_FIFO->TryPeekBits_MSBF(8, nextBits)) + if(nextBits == 0) { - if(nextBits == 0) - { - throw CStartCodeException(); - } + throw CStartCodeException(); } } } + } return true; break; } @@ -1304,34 +1299,33 @@ bool CIPU::CBDECCommand::Execute() ///////////////////////////////////////////// CIPU::CBDECCommand_ReadDct::CBDECCommand_ReadDct() -: m_state(STATE_INIT) -, m_IN_FIFO(NULL) -, m_coeffTable(NULL) -, m_block(NULL) -, m_dcPredictor(NULL) -, m_dcDiff(0) -, m_channelId(0) -, m_mbi(false) -, m_isMpeg1CoeffVLCTable(false) -, m_isMpeg2(true) -, m_blockIndex(0) + : m_state(STATE_INIT) + , m_IN_FIFO(NULL) + , m_coeffTable(NULL) + , m_block(NULL) + , m_dcPredictor(NULL) + , m_dcDiff(0) + , m_channelId(0) + , m_mbi(false) + , m_isMpeg1CoeffVLCTable(false) + , m_isMpeg2(true) + , m_blockIndex(0) { - } void CIPU::CBDECCommand_ReadDct::Initialize(CINFIFO* fifo, int16* block, unsigned int channelId, int16* dcPredictor, bool mbi, bool isMpeg1CoeffVLCTable, bool isMpeg2) { - m_state = STATE_INIT; - m_IN_FIFO = fifo; - m_block = block; - m_dcPredictor = dcPredictor; - m_channelId = channelId; - m_mbi = mbi; - m_isMpeg1CoeffVLCTable = isMpeg1CoeffVLCTable; - m_isMpeg2 = isMpeg2; - m_coeffTable = NULL; - m_blockIndex = 0; - m_dcDiff = 0; + m_state = STATE_INIT; + m_IN_FIFO = fifo; + m_block = block; + m_dcPredictor = dcPredictor; + m_channelId = channelId; + m_mbi = mbi; + m_isMpeg1CoeffVLCTable = isMpeg1CoeffVLCTable; + m_isMpeg2 = isMpeg2; + m_coeffTable = NULL; + m_blockIndex = 0; + m_dcDiff = 0; if(m_mbi && !m_isMpeg1CoeffVLCTable) { @@ -1350,90 +1344,90 @@ bool CIPU::CBDECCommand_ReadDct::Execute() switch(m_state) { case STATE_INIT: - { + { #ifdef _DECODE_LOGGING - static int currentBlockIndex = 0; - CLog::GetInstance().Print(DECODE_LOG_NAME, "Block(%d) = ", currentBlockIndex++); + static int currentBlockIndex = 0; + CLog::GetInstance().Print(DECODE_LOG_NAME, "Block(%d) = ", currentBlockIndex++); #endif - if(m_mbi) - { - m_readDcDiffCommand.Initialize(m_IN_FIFO, m_channelId, &m_dcDiff); - m_state = STATE_READDCDIFF; - } - else - { - m_state = STATE_CHECKEOB; - } + if(m_mbi) + { + m_readDcDiffCommand.Initialize(m_IN_FIFO, m_channelId, &m_dcDiff); + m_state = STATE_READDCDIFF; } - break; + else + { + m_state = STATE_CHECKEOB; + } + } + break; case STATE_READDCDIFF: + { + if(!m_readDcDiffCommand.Execute()) { - if(!m_readDcDiffCommand.Execute()) - { - return false; - } - m_block[0] = static_cast(m_dcPredictor[m_channelId] + m_dcDiff); - m_dcPredictor[m_channelId] = m_block[0]; -#ifdef _DECODE_LOGGING - CLog::GetInstance().Print(DECODE_LOG_NAME, "[%d]: %d ", 0, m_block[0]); -#endif - m_blockIndex = 1; - m_state = STATE_CHECKEOB; + return false; } + m_block[0] = static_cast(m_dcPredictor[m_channelId] + m_dcDiff); + m_dcPredictor[m_channelId] = m_block[0]; +#ifdef _DECODE_LOGGING + CLog::GetInstance().Print(DECODE_LOG_NAME, "[%d]: %d ", 0, m_block[0]); +#endif + m_blockIndex = 1; + m_state = STATE_CHECKEOB; + } - break; + break; case STATE_CHECKEOB: + { + bool isEob = false; + if(m_coeffTable->TryIsEndOfBlock(m_IN_FIFO, isEob) != CVLCTable::DECODE_STATUS_SUCCESS) { - bool isEob = false; - if(m_coeffTable->TryIsEndOfBlock(m_IN_FIFO, isEob) != CVLCTable::DECODE_STATUS_SUCCESS) + return false; + } + if((m_blockIndex != 0) && isEob) + { + m_state = STATE_SKIPEOB; + } + else + { + m_state = STATE_READCOEFF; + } + } + break; + case STATE_READCOEFF: + { + MPEG2::RUNLEVELPAIR runLevelPair; + if(m_blockIndex == 0) + { + if(FilterSymbolError(m_coeffTable->TryGetRunLevelPairDc(m_IN_FIFO, &runLevelPair, m_isMpeg2)) != CVLCTable::DECODE_STATUS_SUCCESS) { return false; } - if((m_blockIndex != 0) && isEob) - { - m_state = STATE_SKIPEOB; - } - else - { - m_state = STATE_READCOEFF; - } } - break; - case STATE_READCOEFF: + else { - MPEG2::RUNLEVELPAIR runLevelPair; - if(m_blockIndex == 0) + if(FilterSymbolError(m_coeffTable->TryGetRunLevelPair(m_IN_FIFO, &runLevelPair, m_isMpeg2)) != CVLCTable::DECODE_STATUS_SUCCESS) { - if(FilterSymbolError(m_coeffTable->TryGetRunLevelPairDc(m_IN_FIFO, &runLevelPair, m_isMpeg2)) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } + return false; } - else - { - if(FilterSymbolError(m_coeffTable->TryGetRunLevelPair(m_IN_FIFO, &runLevelPair, m_isMpeg2)) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } - } - m_blockIndex += runLevelPair.run; - - if(m_blockIndex < 0x40) - { - m_block[m_blockIndex] = static_cast(runLevelPair.level); -#ifdef _DECODE_LOGGING - CLog::GetInstance().Print(DECODE_LOG_NAME, "[%d]: %d ", m_blockIndex, runLevelPair.level); -#endif - } - else - { - throw CVLCTable::CVLCTableException(); - } - - m_blockIndex++; - m_state = STATE_CHECKEOB; } - break; + m_blockIndex += runLevelPair.run; + + if(m_blockIndex < 0x40) + { + m_block[m_blockIndex] = static_cast(runLevelPair.level); +#ifdef _DECODE_LOGGING + CLog::GetInstance().Print(DECODE_LOG_NAME, "[%d]: %d ", m_blockIndex, runLevelPair.level); +#endif + } + else + { + throw CVLCTable::CVLCTableException(); + } + + m_blockIndex++; + m_state = STATE_CHECKEOB; + } + break; case STATE_SKIPEOB: if(m_coeffTable->TrySkipEndOfBlock(m_IN_FIFO) != CVLCTable::DECODE_STATUS_SUCCESS) { @@ -1452,13 +1446,12 @@ bool CIPU::CBDECCommand_ReadDct::Execute() //BDEC ReadDcDiff subcommand implementation ///////////////////////////////////////////// CIPU::CBDECCommand_ReadDcDiff::CBDECCommand_ReadDcDiff() -: m_state(STATE_READSIZE) -, m_result(NULL) -, m_IN_FIFO(NULL) -, m_channelId(0) -, m_dcSize(0) + : m_state(STATE_READSIZE) + , m_result(NULL) + , m_IN_FIFO(NULL) + , m_channelId(0) + , m_dcSize(0) { - } void CIPU::CBDECCommand_ReadDcDiff::Initialize(CINFIFO* fifo, unsigned int channelId, int16* result) @@ -1477,55 +1470,55 @@ bool CIPU::CBDECCommand_ReadDcDiff::Execute() switch(m_state) { case STATE_READSIZE: + { + uint32 dcSize = 0; + switch(m_channelId) { - uint32 dcSize = 0; - switch(m_channelId) + case 0: + if(CDcSizeLuminanceTable::GetInstance()->TryGetSymbol(m_IN_FIFO, dcSize) != CVLCTable::DECODE_STATUS_SUCCESS) { - case 0: - if(CDcSizeLuminanceTable::GetInstance()->TryGetSymbol(m_IN_FIFO, dcSize) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } - break; - case 1: - case 2: - if(CDcSizeChrominanceTable::GetInstance()->TryGetSymbol(m_IN_FIFO, dcSize) != CVLCTable::DECODE_STATUS_SUCCESS) - { - return false; - } - break; + return false; } - m_dcSize = dcSize; - m_state = STATE_READDIFF; + break; + case 1: + case 2: + if(CDcSizeChrominanceTable::GetInstance()->TryGetSymbol(m_IN_FIFO, dcSize) != CVLCTable::DECODE_STATUS_SUCCESS) + { + return false; + } + break; } - break; + m_dcSize = dcSize; + m_state = STATE_READDIFF; + } + break; case STATE_READDIFF: + { + int16 result = 0; + if(m_dcSize == 0) { - int16 result = 0; - if(m_dcSize == 0) - { - result = 0; - } - else - { - uint32 diffValue = 0; - if(!m_IN_FIFO->TryGetBits_MSBF(m_dcSize, diffValue)) - { - return false; - } - - int16 halfRange = (1 << (m_dcSize - 1)); - result = static_cast(diffValue); - - if(result < halfRange) - { - result = (result + 1) - (2 * halfRange); - } - } - (*m_result) = result; - m_state = STATE_DONE; + result = 0; } - break; + else + { + uint32 diffValue = 0; + if(!m_IN_FIFO->TryGetBits_MSBF(m_dcSize, diffValue)) + { + return false; + } + + int16 halfRange = (1 << (m_dcSize - 1)); + result = static_cast(diffValue); + + if(result < halfRange) + { + result = (result + 1) - (2 * halfRange); + } + } + (*m_result) = result; + m_state = STATE_DONE; + } + break; case STATE_DONE: return true; break; @@ -1538,21 +1531,20 @@ bool CIPU::CBDECCommand_ReadDcDiff::Execute() ///////////////////////////////////////////// CIPU::CVDECCommand::CVDECCommand() -: m_IN_FIFO(NULL) -, m_state(STATE_ADVANCE) -, m_commandCode(0) -, m_result(NULL) -, m_table(NULL) + : m_IN_FIFO(NULL) + , m_state(STATE_ADVANCE) + , m_commandCode(0) + , m_result(NULL) + , m_table(NULL) { - } void CIPU::CVDECCommand::Initialize(CINFIFO* fifo, uint32 commandCode, uint32 pictureType, uint32* result) { - m_IN_FIFO = fifo; - m_commandCode = commandCode; - m_state = STATE_ADVANCE; - m_result = result; + m_IN_FIFO = fifo; + m_commandCode = commandCode; + m_state = STATE_ADVANCE; + m_result = result; uint32 tbl = (commandCode >> 26) & 0x03; switch(tbl) @@ -1603,17 +1595,17 @@ bool CIPU::CVDECCommand::Execute() switch(m_state) { case STATE_ADVANCE: - { - m_IN_FIFO->Advance(static_cast(m_commandCode & 0x3F)); - m_state = STATE_DECODE; - } - break; + { + m_IN_FIFO->Advance(static_cast(m_commandCode & 0x3F)); + m_state = STATE_DECODE; + } + break; case STATE_DECODE: - { - (*m_result) = m_table->GetSymbol(m_IN_FIFO); - m_state = STATE_DONE; - } - break; + { + (*m_result) = m_table->GetSymbol(m_IN_FIFO); + m_state = STATE_DONE; + } + break; case STATE_DONE: #ifdef _DECODE_LOGGING const char* tableName = "unknown"; @@ -1622,10 +1614,9 @@ bool CIPU::CVDECCommand::Execute() tableName = "mb increment"; } else if( - (m_table == CMacroblockTypeITable::GetInstance()) || - (m_table == CMacroblockTypePTable::GetInstance()) || - (m_table == CMacroblockTypeBTable::GetInstance()) - ) + (m_table == CMacroblockTypeITable::GetInstance()) || + (m_table == CMacroblockTypePTable::GetInstance()) || + (m_table == CMacroblockTypeBTable::GetInstance())) { tableName = "mb type"; } @@ -1638,8 +1629,8 @@ bool CIPU::CVDECCommand::Execute() tableName = "dm vector"; } static unsigned int currentVdec = 0; - CLog::GetInstance().Print(DECODE_LOG_NAME, "Symbol(%d, '%s') = %d\r\n", - currentVdec++, tableName, static_cast((*m_result) & 0xFFFF)); + CLog::GetInstance().Print(DECODE_LOG_NAME, "Symbol(%d, '%s') = %d\r\n", + currentVdec++, tableName, static_cast((*m_result) & 0xFFFF)); #endif return true; break; @@ -1652,20 +1643,19 @@ bool CIPU::CVDECCommand::Execute() ///////////////////////////////////////////// CIPU::CFDECCommand::CFDECCommand() -: m_IN_FIFO(NULL) -, m_state(STATE_ADVANCE) -, m_commandCode(0) -, m_result(NULL) + : m_IN_FIFO(NULL) + , m_state(STATE_ADVANCE) + , m_commandCode(0) + , m_result(NULL) { - } void CIPU::CFDECCommand::Initialize(CINFIFO* fifo, uint32 commandCode, uint32* result) { - m_IN_FIFO = fifo; - m_commandCode = commandCode; - m_state = STATE_ADVANCE; - m_result = result; + m_IN_FIFO = fifo; + m_commandCode = commandCode; + m_state = STATE_ADVANCE; + m_result = result; } bool CIPU::CFDECCommand::Execute() @@ -1675,20 +1665,20 @@ bool CIPU::CFDECCommand::Execute() switch(m_state) { case STATE_ADVANCE: - { - m_IN_FIFO->Advance(static_cast(m_commandCode & 0x3F)); - m_state = STATE_DECODE; - } - break; + { + m_IN_FIFO->Advance(static_cast(m_commandCode & 0x3F)); + m_state = STATE_DECODE; + } + break; case STATE_DECODE: + { + if(!m_IN_FIFO->TryPeekBits_MSBF(32, *m_result)) { - if(!m_IN_FIFO->TryPeekBits_MSBF(32, *m_result)) - { - return false; - } - m_state = STATE_DONE; + return false; } - break; + m_state = STATE_DONE; + } + break; case STATE_DONE: return true; break; @@ -1701,18 +1691,17 @@ bool CIPU::CFDECCommand::Execute() ///////////////////////////////////////////// CIPU::CSETIQCommand::CSETIQCommand() -: m_IN_FIFO(NULL) -, m_matrix(NULL) -, m_currentIndex(0) + : m_IN_FIFO(NULL) + , m_matrix(NULL) + , m_currentIndex(0) { - } void CIPU::CSETIQCommand::Initialize(CINFIFO* fifo, uint8* matrix) { - m_IN_FIFO = fifo; - m_matrix = matrix; - m_currentIndex = 0; + m_IN_FIFO = fifo; + m_matrix = matrix; + m_currentIndex = 0; } bool CIPU::CSETIQCommand::Execute() @@ -1730,18 +1719,17 @@ bool CIPU::CSETIQCommand::Execute() ///////////////////////////////////////////// CIPU::CSETVQCommand::CSETVQCommand() -: m_IN_FIFO(NULL) -, m_clut(NULL) -, m_currentIndex(0) + : m_IN_FIFO(NULL) + , m_clut(NULL) + , m_currentIndex(0) { - } void CIPU::CSETVQCommand::Initialize(CINFIFO* fifo, uint16* clut) { - m_IN_FIFO = fifo; - m_clut = clut; - m_currentIndex = 0; + m_IN_FIFO = fifo; + m_clut = clut; + m_currentIndex = 0; } bool CIPU::CSETVQCommand::Execute() @@ -1786,105 +1774,126 @@ bool CIPU::CCSCCommand::Execute() switch(m_state) { case STATE_READBLOCKSTART: + { + if(m_mbCount == 0) { - if(m_mbCount == 0) - { - m_state = STATE_DONE; - } - else - { - m_state = STATE_READBLOCK; - m_currentIndex = 0; - } + m_state = STATE_DONE; } - break; + else + { + m_state = STATE_READBLOCK; + m_currentIndex = 0; + } + } + break; case STATE_READBLOCK: + { + if(m_currentIndex == BLOCK_SIZE) { - if(m_currentIndex == BLOCK_SIZE) - { - m_state = STATE_CONVERTBLOCK; - } - else - { - uint32 blockValue = 0; - if(!m_IN_FIFO->TryGetBits_MSBF(8, blockValue)) - { - return false; - } - m_block[m_currentIndex] = static_cast(blockValue); - m_currentIndex++; - } + m_state = STATE_CONVERTBLOCK; } - break; - case STATE_CONVERTBLOCK: + else { - uint32 nPixel[0x100]; - - uint8* pY = m_block; - uint8* nBlockCb = m_block + 0x100; - uint8* nBlockCr = m_block + 0x140; - - uint32* pPixel = nPixel; - unsigned int* pCbCrMap = m_nCbCrMap; - - uint32 alphaTh0 = (m_TH0 & 0xFF) | ((m_TH0 & 0xFF) << 8) | ((m_TH0 & 0xFF) << 16); - uint32 alphaTh1 = (m_TH1 & 0xFF) | ((m_TH1 & 0xFF) << 8) | ((m_TH1 & 0xFF) << 16); - - for(unsigned int i = 0; i < 16; i++) - { - for(unsigned int j = 0; j < 16; j++) - { - float nY = pY[j]; - float nCb = nBlockCb[pCbCrMap[j]]; - float nCr = nBlockCr[pCbCrMap[j]]; - - float nR = nY + 1.402f * (nCr - 128); - float nG = nY - 0.34414f * (nCb - 128) - 0.71414f * (nCr - 128); - float nB = nY + 1.772f * (nCb - 128); - - if(nR < 0) { nR = 0; } if(nR > 255) { nR = 255; } - if(nG < 0) { nG = 0; } if(nG > 255) { nG = 255; } - if(nB < 0) { nB = 0; } if(nB > 255) { nB = 255; } - - uint8 a = 0; - uint32 rgb = (static_cast(nB) << 16) | (static_cast(nG) << 8) | (static_cast(nR) << 0); - if(rgb < alphaTh0) - { - a = 0; - } - else if(rgb < alphaTh1) - { - a = 0x40; - } - else - { - a = 0x80; - } - - pPixel[j] = (a << 24) | rgb; - } - - pY += 0x10; - pCbCrMap += 0x10; - pPixel += 0x10; - } - - m_OUT_FIFO->Write(nPixel, sizeof(uint32) * 0x100); - - m_mbCount--; - m_state = STATE_FLUSHBLOCK; - } - break; - case STATE_FLUSHBLOCK: - { - m_OUT_FIFO->Flush(); - if(m_OUT_FIFO->GetSize() != 0) + uint32 blockValue = 0; + if(!m_IN_FIFO->TryGetBits_MSBF(8, blockValue)) { return false; } - m_state = STATE_READBLOCKSTART; + m_block[m_currentIndex] = static_cast(blockValue); + m_currentIndex++; } - break; + } + break; + case STATE_CONVERTBLOCK: + { + uint32 nPixel[0x100]; + + uint8* pY = m_block; + uint8* nBlockCb = m_block + 0x100; + uint8* nBlockCr = m_block + 0x140; + + uint32* pPixel = nPixel; + unsigned int* pCbCrMap = m_nCbCrMap; + + uint32 alphaTh0 = (m_TH0 & 0xFF) | ((m_TH0 & 0xFF) << 8) | ((m_TH0 & 0xFF) << 16); + uint32 alphaTh1 = (m_TH1 & 0xFF) | ((m_TH1 & 0xFF) << 8) | ((m_TH1 & 0xFF) << 16); + + for(unsigned int i = 0; i < 16; i++) + { + for(unsigned int j = 0; j < 16; j++) + { + float nY = pY[j]; + float nCb = nBlockCb[pCbCrMap[j]]; + float nCr = nBlockCr[pCbCrMap[j]]; + + float nR = nY + 1.402f * (nCr - 128); + float nG = nY - 0.34414f * (nCb - 128) - 0.71414f * (nCr - 128); + float nB = nY + 1.772f * (nCb - 128); + + if(nR < 0) + { + nR = 0; + } + if(nR > 255) + { + nR = 255; + } + if(nG < 0) + { + nG = 0; + } + if(nG > 255) + { + nG = 255; + } + if(nB < 0) + { + nB = 0; + } + if(nB > 255) + { + nB = 255; + } + + uint8 a = 0; + uint32 rgb = (static_cast(nB) << 16) | (static_cast(nG) << 8) | (static_cast(nR) << 0); + if(rgb < alphaTh0) + { + a = 0; + } + else if(rgb < alphaTh1) + { + a = 0x40; + } + else + { + a = 0x80; + } + + pPixel[j] = (a << 24) | rgb; + } + + pY += 0x10; + pCbCrMap += 0x10; + pPixel += 0x10; + } + + m_OUT_FIFO->Write(nPixel, sizeof(uint32) * 0x100); + + m_mbCount--; + m_state = STATE_FLUSHBLOCK; + } + break; + case STATE_FLUSHBLOCK: + { + m_OUT_FIFO->Flush(); + if(m_OUT_FIFO->GetSize() != 0) + { + return false; + } + m_state = STATE_READBLOCKSTART; + } + break; case STATE_DONE: return true; break; @@ -1915,11 +1924,10 @@ void CIPU::CCSCCommand::GenerateCbCrMap() ///////////////////////////////////////////// CIPU::CSETTHCommand::CSETTHCommand() -: m_commandCode(0) -, m_TH0(NULL) -, m_TH1(NULL) + : m_commandCode(0) + , m_TH0(NULL) + , m_TH1(NULL) { - } void CIPU::CSETTHCommand::Initialize(uint32 commandCode, uint16* TH0, uint16* TH1) @@ -1931,7 +1939,7 @@ void CIPU::CSETTHCommand::Initialize(uint32 commandCode, uint16* TH0, uint16* TH bool CIPU::CSETTHCommand::Execute() { - (*m_TH0) = static_cast((m_commandCode >> 0) & 0x1FF); + (*m_TH0) = static_cast((m_commandCode >> 0) & 0x1FF); (*m_TH1) = static_cast((m_commandCode >> 16) & 0x1FF); return true; } diff --git a/Source/ee/IPU.h b/Source/ee/IPU.h index 81e8b6b6e..9405c4c07 100644 --- a/Source/ee/IPU.h +++ b/Source/ee/IPU.h @@ -14,32 +14,32 @@ class CINTC; class CIPU { public: - typedef std::function Dma3ReceiveHandler; + typedef std::function Dma3ReceiveHandler; - CIPU(CINTC&); - virtual ~CIPU(); + CIPU(CINTC&); + virtual ~CIPU(); enum REGISTER { - IPU_CMD = 0x10002000, - IPU_CTRL = 0x10002010, - IPU_BP = 0x10002020, - IPU_TOP = 0x10002030, - IPU_OUT_FIFO = 0x10007000, - IPU_IN_FIFO = 0x10007010, + IPU_CMD = 0x10002000, + IPU_CTRL = 0x10002010, + IPU_BP = 0x10002020, + IPU_TOP = 0x10002030, + IPU_OUT_FIFO = 0x10007000, + IPU_IN_FIFO = 0x10007010, }; - void Reset(); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); - void SetDMA3ReceiveHandler(const Dma3ReceiveHandler&); - uint32 ReceiveDMA4(uint32, uint32, bool, uint8*); + void Reset(); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); + void SetDMA3ReceiveHandler(const Dma3ReceiveHandler&); + uint32 ReceiveDMA4(uint32, uint32, bool, uint8*); - void CountTicks(uint32); - void ExecuteCommand(); - bool WillExecuteCommand() const; - bool IsCommandDelayed() const; - bool HasPendingOUTFIFOData() const; + void CountTicks(uint32); + void ExecuteCommand(); + bool WillExecuteCommand() const; + bool IsCommandDelayed() const; + bool HasPendingOUTFIFOData() const; private: enum IPU_CTRL_BITS @@ -72,98 +72,98 @@ private: struct CMD_IDEC : public convertible { - unsigned int fb : 6; - unsigned int unused0 : 10; - unsigned int qsc : 5; - unsigned int unused1 : 3; - unsigned int dtd : 1; - unsigned int sgn : 1; - unsigned int dte : 1; - unsigned int ofm : 1; - unsigned int cmdId : 4; + unsigned int fb : 6; + unsigned int unused0 : 10; + unsigned int qsc : 5; + unsigned int unused1 : 3; + unsigned int dtd : 1; + unsigned int sgn : 1; + unsigned int dte : 1; + unsigned int ofm : 1; + unsigned int cmdId : 4; }; static_assert(sizeof(CMD_IDEC) == 4, "Size of CMD_IDEC must be 4."); struct CMD_BDEC : public convertible { - unsigned int fb : 6; - unsigned int unused0 : 10; - unsigned int qsc : 5; - unsigned int unused1 : 4; - unsigned int dt : 1; - unsigned int dcr : 1; - unsigned int mbi : 1; - unsigned int cmdId : 4; + unsigned int fb : 6; + unsigned int unused0 : 10; + unsigned int qsc : 5; + unsigned int unused1 : 4; + unsigned int dt : 1; + unsigned int dcr : 1; + unsigned int mbi : 1; + unsigned int cmdId : 4; }; static_assert(sizeof(CMD_BDEC) == 4, "Size of CMD_BDEC must be 4."); struct CMD_CSC : public convertible { - unsigned int mbc : 11; - unsigned int unused0 : 15; - unsigned int dte : 1; - unsigned int ofm : 1; - unsigned int cmdId : 4; + unsigned int mbc : 11; + unsigned int unused0 : 15; + unsigned int dte : 1; + unsigned int ofm : 1; + unsigned int cmdId : 4; }; static_assert(sizeof(CMD_CSC) == 4, "Size of CMD_CSC must be 4."); struct DECODER_CONTEXT { - bool isMpeg1CoeffVLCTable = false; - bool isMpeg2 = false; - bool isLinearQScale = false; - bool isZigZag = false; - uint8* intraIq = nullptr; - uint8* nonIntraIq = nullptr; - int16* dcPredictor = nullptr; - uint32 dcPrecision = 0; + bool isMpeg1CoeffVLCTable = false; + bool isMpeg2 = false; + bool isLinearQScale = false; + bool isZigZag = false; + uint8* intraIq = nullptr; + uint8* nonIntraIq = nullptr; + int16* dcPredictor = nullptr; + uint32 dcPrecision = 0; }; class COUTFIFO { public: - COUTFIFO(); - virtual ~COUTFIFO(); + COUTFIFO(); + virtual ~COUTFIFO(); - uint32 GetSize() const; - void Write(const void*, unsigned int); - void Flush(); - void SetReceiveHandler(const Dma3ReceiveHandler&); + uint32 GetSize() const; + void Write(const void*, unsigned int); + void Flush(); + void SetReceiveHandler(const Dma3ReceiveHandler&); - void Reset(); + void Reset(); private: - void RequestGrow(unsigned int); + void RequestGrow(unsigned int); enum GROWSIZE { GROWSIZE = 0x200, }; - unsigned int m_size; - unsigned int m_alloc; - uint8* m_buffer; - Dma3ReceiveHandler m_receiveHandler; + unsigned int m_size; + unsigned int m_alloc; + uint8* m_buffer; + Dma3ReceiveHandler m_receiveHandler; }; class CINFIFO : public Framework::CBitStream { public: - CINFIFO(); - virtual ~CINFIFO(); + CINFIFO(); + virtual ~CINFIFO(); - void Write(void*, unsigned int); + void Write(void*, unsigned int); - void Advance(uint8) override; - uint8 GetBitIndex() const override; + void Advance(uint8) override; + uint8 GetBitIndex() const override; - bool TryPeekBits_LSBF(uint8, uint32&) override; - bool TryPeekBits_MSBF(uint8, uint32&) override; + bool TryPeekBits_LSBF(uint8, uint32&) override; + bool TryPeekBits_MSBF(uint8, uint32&) override; - void SetBitPosition(unsigned int); - unsigned int GetSize() const; - unsigned int GetAvailableBits() const; - void Reset(); + void SetBitPosition(unsigned int); + unsigned int GetSize() const; + unsigned int GetAvailableBits() const; + void Reset(); enum BUFFERSIZE { @@ -171,43 +171,48 @@ private: }; private: - void SyncLookupBits(); + void SyncLookupBits(); - uint8 m_buffer[BUFFERSIZE]; - uint64 m_lookupBits; - bool m_lookupBitsDirty; - unsigned int m_size; - unsigned int m_bitPosition; + uint8 m_buffer[BUFFERSIZE]; + uint64 m_lookupBits; + bool m_lookupBitsDirty; + unsigned int m_size; + unsigned int m_bitPosition; }; class CStartCodeException : public std::exception { - }; class CCommand { public: - virtual ~CCommand() {} - virtual bool Execute() = 0; - virtual void CountTicks(uint32) {} - virtual bool IsDelayed() const { return false; } + virtual ~CCommand() + { + } + virtual bool Execute() = 0; + virtual void CountTicks(uint32) + { + } + virtual bool IsDelayed() const + { + return false; + } private: - }; //0x00 ------------------------------------------------------------ class CBCLRCommand : public CCommand { public: - CBCLRCommand(); - void Initialize(CINFIFO*, uint32); - bool Execute() override; + CBCLRCommand(); + void Initialize(CINFIFO*, uint32); + bool Execute() override; private: - CINFIFO* m_IN_FIFO; - uint32 m_commandCode; + CINFIFO* m_IN_FIFO; + uint32 m_commandCode; }; //0x01 ------------------------------------------------------------ @@ -217,12 +222,12 @@ private: class CIDECCommand : public CCommand { public: - CIDECCommand(); + CIDECCommand(); - void Initialize(CBDECCommand*, CCSCCommand*, CINFIFO*, COUTFIFO*, uint32, const DECODER_CONTEXT&, uint16, uint16); - bool Execute() override; - void CountTicks(uint32) override; - bool IsDelayed() const override; + void Initialize(CBDECCommand*, CCSCCommand*, CINFIFO*, COUTFIFO*, uint32, const DECODER_CONTEXT&, uint16, uint16); + bool Execute() override; + void CountTicks(uint32) override; + bool IsDelayed() const override; private: enum STATE @@ -241,38 +246,38 @@ private: STATE_DONE }; - void ConvertRawBlock(); + void ConvertRawBlock(); - CMD_IDEC m_command = make_convertible(0); - STATE m_state = STATE_DONE; + CMD_IDEC m_command = make_convertible(0); + STATE m_state = STATE_DONE; - CBDECCommand* m_BDECCommand = nullptr; - CCSCCommand* m_CSCCommand = nullptr; - CINFIFO* m_IN_FIFO = nullptr; - COUTFIFO* m_OUT_FIFO = nullptr; + CBDECCommand* m_BDECCommand = nullptr; + CCSCCommand* m_CSCCommand = nullptr; + CINFIFO* m_IN_FIFO = nullptr; + COUTFIFO* m_OUT_FIFO = nullptr; - CINFIFO m_temp_IN_FIFO; - COUTFIFO m_temp_OUT_FIFO; + CINFIFO m_temp_IN_FIFO; + COUTFIFO m_temp_OUT_FIFO; - Framework::CMemStream m_blockStream; + Framework::CMemStream m_blockStream; - DECODER_CONTEXT m_context; - uint16 m_TH0 = 0; - uint16 m_TH1 = 0; - uint32 m_mbType = 0; - uint32 m_qsc = 0; - uint32 m_mbCount = 0; - int32 m_delayTicks = 0; + DECODER_CONTEXT m_context; + uint16 m_TH0 = 0; + uint16 m_TH1 = 0; + uint32 m_mbType = 0; + uint32 m_qsc = 0; + uint32 m_mbCount = 0; + int32 m_delayTicks = 0; }; //0x02 ------------------------------------------------------------ class CBDECCommand_ReadDcDiff : public CCommand { public: - CBDECCommand_ReadDcDiff(); + CBDECCommand_ReadDcDiff(); - void Initialize(CINFIFO*, unsigned int, int16*); - bool Execute() override; + void Initialize(CINFIFO*, unsigned int, int16*); + bool Execute() override; private: enum STATE @@ -282,20 +287,20 @@ private: STATE_DONE }; - STATE m_state; - CINFIFO* m_IN_FIFO; - unsigned int m_channelId; - uint8 m_dcSize; - int16* m_result; + STATE m_state; + CINFIFO* m_IN_FIFO; + unsigned int m_channelId; + uint8 m_dcSize; + int16* m_result; }; class CBDECCommand_ReadDct : public CCommand { public: - CBDECCommand_ReadDct(); + CBDECCommand_ReadDct(); - void Initialize(CINFIFO*, int16* block, unsigned int channelId, int16* dcPredictor, bool mbi, bool isMpeg1CoeffVLCTable, bool isMpeg2); - bool Execute() override; + void Initialize(CINFIFO*, int16* block, unsigned int channelId, int16* dcPredictor, bool mbi, bool isMpeg1CoeffVLCTable, bool isMpeg2); + bool Execute() override; private: enum STATE @@ -307,27 +312,27 @@ private: STATE_SKIPEOB }; - CINFIFO* m_IN_FIFO; - STATE m_state; - int16* m_block; - unsigned int m_channelId; - bool m_mbi; - bool m_isMpeg1CoeffVLCTable; - bool m_isMpeg2; - unsigned int m_blockIndex; - MPEG2::CDctCoefficientTable* m_coeffTable; - int16* m_dcPredictor; - int16 m_dcDiff; - CBDECCommand_ReadDcDiff m_readDcDiffCommand; + CINFIFO* m_IN_FIFO; + STATE m_state; + int16* m_block; + unsigned int m_channelId; + bool m_mbi; + bool m_isMpeg1CoeffVLCTable; + bool m_isMpeg2; + unsigned int m_blockIndex; + MPEG2::CDctCoefficientTable* m_coeffTable; + int16* m_dcPredictor; + int16 m_dcDiff; + CBDECCommand_ReadDcDiff m_readDcDiffCommand; }; class CBDECCommand : public CCommand { public: - CBDECCommand(); + CBDECCommand(); - void Initialize(CINFIFO*, COUTFIFO*, uint32, bool, const DECODER_CONTEXT&); - bool Execute() override; + void Initialize(CINFIFO*, COUTFIFO*, uint32, bool, const DECODER_CONTEXT&); + bool Execute() override; private: enum STATE @@ -343,39 +348,39 @@ private: struct BLOCKENTRY { - int16* block; - unsigned int channel; + int16* block; + unsigned int channel; }; - CMD_BDEC m_command = make_convertible(0); - STATE m_state = STATE_DONE; + CMD_BDEC m_command = make_convertible(0); + STATE m_state = STATE_DONE; - CINFIFO* m_IN_FIFO = nullptr; - COUTFIFO* m_OUT_FIFO = nullptr; - bool m_checkStartCode = false; + CINFIFO* m_IN_FIFO = nullptr; + COUTFIFO* m_OUT_FIFO = nullptr; + bool m_checkStartCode = false; - uint8 m_codedBlockPattern = 0; + uint8 m_codedBlockPattern = 0; - BLOCKENTRY m_blocks[6]; + BLOCKENTRY m_blocks[6]; - int16 m_yBlock[4][64]; - int16 m_cbBlock[64]; - int16 m_crBlock[64]; + int16 m_yBlock[4][64]; + int16 m_cbBlock[64]; + int16 m_crBlock[64]; - unsigned int m_currentBlockIndex = 0; + unsigned int m_currentBlockIndex = 0; - DECODER_CONTEXT m_context; - CBDECCommand_ReadDct m_readDctCoeffsCommand; + DECODER_CONTEXT m_context; + CBDECCommand_ReadDct m_readDctCoeffsCommand; }; //0x03 ------------------------------------------------------------ class CVDECCommand : public CCommand { public: - CVDECCommand(); + CVDECCommand(); - void Initialize(CINFIFO*, uint32, uint32, uint32*); - bool Execute() override; + void Initialize(CINFIFO*, uint32, uint32, uint32*); + bool Execute() override; private: enum STATE @@ -385,21 +390,21 @@ private: STATE_DONE }; - uint32 m_commandCode; - uint32* m_result; - CINFIFO* m_IN_FIFO; - STATE m_state; - MPEG2::CVLCTable* m_table; + uint32 m_commandCode; + uint32* m_result; + CINFIFO* m_IN_FIFO; + STATE m_state; + MPEG2::CVLCTable* m_table; }; //0x04 ------------------------------------------------------------ class CFDECCommand : public CCommand { public: - CFDECCommand(); + CFDECCommand(); - void Initialize(CINFIFO*, uint32, uint32*); - bool Execute() override; + void Initialize(CINFIFO*, uint32, uint32*); + bool Execute() override; private: enum STATE @@ -409,40 +414,40 @@ private: STATE_DONE }; - uint32 m_commandCode; - uint32* m_result; - CINFIFO* m_IN_FIFO; - STATE m_state; + uint32 m_commandCode; + uint32* m_result; + CINFIFO* m_IN_FIFO; + STATE m_state; }; //0x05 ------------------------------------------------------------ class CSETIQCommand : public CCommand { public: - CSETIQCommand(); + CSETIQCommand(); - void Initialize(CINFIFO*, uint8*); - bool Execute() override; + void Initialize(CINFIFO*, uint8*); + bool Execute() override; private: - CINFIFO* m_IN_FIFO; - uint8* m_matrix; - unsigned int m_currentIndex; + CINFIFO* m_IN_FIFO; + uint8* m_matrix; + unsigned int m_currentIndex; }; //0x06 ------------------------------------------------------------ class CSETVQCommand : public CCommand { public: - CSETVQCommand(); + CSETVQCommand(); - void Initialize(CINFIFO*, uint16*); - bool Execute() override; + void Initialize(CINFIFO*, uint16*); + bool Execute() override; private: - CINFIFO* m_IN_FIFO; - uint16* m_clut; - unsigned int m_currentIndex; + CINFIFO* m_IN_FIFO; + uint16* m_clut; + unsigned int m_currentIndex; }; //0x07 ------------------------------------------------------------ @@ -454,10 +459,10 @@ private: BLOCK_SIZE = 0x180, }; - CCSCCommand(); + CCSCCommand(); - void Initialize(CINFIFO*, COUTFIFO*, uint32, uint16, uint16); - bool Execute() override; + void Initialize(CINFIFO*, COUTFIFO*, uint32, uint16, uint16); + bool Execute() override; private: enum STATE @@ -469,83 +474,83 @@ private: STATE_DONE, }; - void GenerateCbCrMap(); + void GenerateCbCrMap(); - STATE m_state = STATE_DONE; - CMD_CSC m_command = make_convertible(0); + STATE m_state = STATE_DONE; + CMD_CSC m_command = make_convertible(0); - CINFIFO* m_IN_FIFO = nullptr; - COUTFIFO* m_OUT_FIFO = nullptr; + CINFIFO* m_IN_FIFO = nullptr; + COUTFIFO* m_OUT_FIFO = nullptr; - uint16 m_TH0 = 0; - uint16 m_TH1 = 0; - unsigned int m_currentIndex = 0; - unsigned int m_mbCount = 0; + uint16 m_TH0 = 0; + uint16 m_TH1 = 0; + unsigned int m_currentIndex = 0; + unsigned int m_mbCount = 0; - unsigned int m_nCbCrMap[0x100]; + unsigned int m_nCbCrMap[0x100]; - uint8 m_block[BLOCK_SIZE]; + uint8 m_block[BLOCK_SIZE]; }; //0x09 ------------------------------------------------------------ class CSETTHCommand : public CCommand { public: - CSETTHCommand(); + CSETTHCommand(); - void Initialize(uint32, uint16*, uint16*); - bool Execute() override; + void Initialize(uint32, uint16*, uint16*); + bool Execute() override; private: - uint32 m_commandCode; - uint16* m_TH0; - uint16* m_TH1; + uint32 m_commandCode; + uint16* m_TH0; + uint16* m_TH1; }; - void InitializeCommand(uint32); + void InitializeCommand(uint32); - DECODER_CONTEXT GetDecoderContext(); - uint32 GetPictureType(); - uint32 GetDcPrecision(); - bool GetIsMPEG2(); - bool GetIsLinearQScale(); - bool GetIsZigZagScan(); - bool GetIsMPEG1CoeffVLCTable(); + DECODER_CONTEXT GetDecoderContext(); + uint32 GetPictureType(); + uint32 GetDcPrecision(); + bool GetIsMPEG2(); + bool GetIsLinearQScale(); + bool GetIsZigZagScan(); + bool GetIsMPEG1CoeffVLCTable(); - static void DequantiseBlock(int16*, uint8, uint8, bool isLinearQScale, uint32 dcPrecision, uint8* intraIq, uint8* nonIntraIq); - static void InverseScan(int16*, bool isZigZag); + static void DequantiseBlock(int16*, uint8, uint8, bool isLinearQScale, uint32 dcPrecision, uint8* intraIq, uint8* nonIntraIq); + static void InverseScan(int16*, bool isZigZag); - uint32 GetBusyBit(bool) const; - FIFO_STATE GetFifoState() const; + uint32 GetBusyBit(bool) const; + FIFO_STATE GetFifoState() const; - void DisassembleGet(uint32); - void DisassembleSet(uint32, uint32); - void DisassembleCommand(uint32); + void DisassembleGet(uint32); + void DisassembleSet(uint32, uint32); + void DisassembleCommand(uint32); - CINTC& m_intc; + CINTC& m_intc; - uint8 m_nIntraIQ[0x40]; - uint8 m_nNonIntraIQ[0x40]; - uint16 m_nVQCLUT[0x10]; - uint16 m_nTH0; - uint16 m_nTH1; + uint8 m_nIntraIQ[0x40]; + uint8 m_nNonIntraIQ[0x40]; + uint16 m_nVQCLUT[0x10]; + uint16 m_nTH0; + uint16 m_nTH1; - int16 m_nDcPredictor[3]; + int16 m_nDcPredictor[3]; - uint32 m_IPU_CMD[2]; - uint32 m_IPU_CTRL; - COUTFIFO m_OUT_FIFO; - CINFIFO m_IN_FIFO; - bool m_isBusy; + uint32 m_IPU_CMD[2]; + uint32 m_IPU_CTRL; + COUTFIFO m_OUT_FIFO; + CINFIFO m_IN_FIFO; + bool m_isBusy; - CCommand* m_currentCmd; - CBCLRCommand m_BCLRCommand; - CIDECCommand m_IDECCommand; - CBDECCommand m_BDECCommand; - CVDECCommand m_VDECCommand; - CFDECCommand m_FDECCommand; - CSETIQCommand m_SETIQCommand; - CSETVQCommand m_SETVQCommand; - CCSCCommand m_CSCCommand; - CSETTHCommand m_SETTHCommand; + CCommand* m_currentCmd; + CBCLRCommand m_BCLRCommand; + CIDECCommand m_IDECCommand; + CBDECCommand m_BDECCommand; + CVDECCommand m_VDECCommand; + CFDECCommand m_FDECCommand; + CSETIQCommand m_SETIQCommand; + CSETVQCommand m_SETVQCommand; + CCSCCommand m_CSCCommand; + CSETTHCommand m_SETTHCommand; }; diff --git a/Source/ee/IPU_DmVectorTable.cpp b/Source/ee/IPU_DmVectorTable.cpp index fc3c34e53..5128f1081 100644 --- a/Source/ee/IPU_DmVectorTable.cpp +++ b/Source/ee/IPU_DmVectorTable.cpp @@ -5,24 +5,23 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CDmVectorTable::m_pTable[ENTRYCOUNT] = -{ - { 0x0000, 1, 0x00010000 }, - { 0x0002, 2, 0x00020001 }, - { 0x0003, 2, 0x0002FFFF }, + { + {0x0000, 1, 0x00010000}, + {0x0002, 2, 0x00020001}, + {0x0003, 2, 0x0002FFFF}, }; unsigned int CDmVectorTable::m_pIndexTable[MAXBITS] = -{ - 0, - 1, + { + 0, + 1, }; CVLCTable* CDmVectorTable::m_pInstance = NULL; -CDmVectorTable::CDmVectorTable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CDmVectorTable::CDmVectorTable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CDmVectorTable::GetInstance() diff --git a/Source/ee/IPU_DmVectorTable.h b/Source/ee/IPU_DmVectorTable.h index c2ceb1bba..aa8ecacbe 100644 --- a/Source/ee/IPU_DmVectorTable.h +++ b/Source/ee/IPU_DmVectorTable.h @@ -9,8 +9,8 @@ namespace IPU class CDmVectorTable : public MPEG2::CVLCTable { public: - CDmVectorTable(); - static MPEG2::CVLCTable* GetInstance(); + CDmVectorTable(); + static MPEG2::CVLCTable* GetInstance(); enum MAXBITS { @@ -23,11 +23,10 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; - } #endif diff --git a/Source/ee/IPU_MacroblockAddressIncrementTable.cpp b/Source/ee/IPU_MacroblockAddressIncrementTable.cpp index 44d22590a..44ff179b1 100644 --- a/Source/ee/IPU_MacroblockAddressIncrementTable.cpp +++ b/Source/ee/IPU_MacroblockAddressIncrementTable.cpp @@ -5,65 +5,64 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CMacroblockAddressIncrementTable::m_pTable[ENTRYCOUNT] = -{ - { 0x0001, 1, 0x00010001 }, - { 0x0003, 3, 0x00030002 }, - { 0x0002, 3, 0x00030003 }, - { 0x0003, 4, 0x00040004 }, - { 0x0002, 4, 0x00040005 }, - { 0x0003, 5, 0x00050006 }, - { 0x0002, 5, 0x00050007 }, - { 0x0007, 7, 0x00070008 }, - { 0x0006, 7, 0x00070009 }, - { 0x000B, 8, 0x0008000A }, - { 0x000A, 8, 0x0008000B }, - { 0x0009, 8, 0x0008000C }, - { 0x0008, 8, 0x0008000D }, - { 0x0007, 8, 0x0008000E }, - { 0x0006, 8, 0x0008000F }, - { 0x0017, 10, 0x000A0010 }, - { 0x0016, 10, 0x000A0011 }, - { 0x0015, 10, 0x000A0012 }, - { 0x0014, 10, 0x000A0013 }, - { 0x0013, 10, 0x000A0014 }, - { 0x0012, 10, 0x000A0015 }, - { 0x0023, 11, 0x000B0016 }, - { 0x0022, 11, 0x000B0017 }, - { 0x0021, 11, 0x000B0018 }, - { 0x0020, 11, 0x000B0019 }, - { 0x001F, 11, 0x000B001A }, - { 0x001E, 11, 0x000B001B }, - { 0x001D, 11, 0x000B001C }, - { 0x001C, 11, 0x000B001D }, - { 0x001B, 11, 0x000B001E }, - { 0x001A, 11, 0x000B001F }, - { 0x0019, 11, 0x000B0020 }, - { 0x0018, 11, 0x000B0021 }, - { 0x000F, 11, 0x000B0022 }, - { 0x0008, 11, 0x000B0023 }, + { + {0x0001, 1, 0x00010001}, + {0x0003, 3, 0x00030002}, + {0x0002, 3, 0x00030003}, + {0x0003, 4, 0x00040004}, + {0x0002, 4, 0x00040005}, + {0x0003, 5, 0x00050006}, + {0x0002, 5, 0x00050007}, + {0x0007, 7, 0x00070008}, + {0x0006, 7, 0x00070009}, + {0x000B, 8, 0x0008000A}, + {0x000A, 8, 0x0008000B}, + {0x0009, 8, 0x0008000C}, + {0x0008, 8, 0x0008000D}, + {0x0007, 8, 0x0008000E}, + {0x0006, 8, 0x0008000F}, + {0x0017, 10, 0x000A0010}, + {0x0016, 10, 0x000A0011}, + {0x0015, 10, 0x000A0012}, + {0x0014, 10, 0x000A0013}, + {0x0013, 10, 0x000A0014}, + {0x0012, 10, 0x000A0015}, + {0x0023, 11, 0x000B0016}, + {0x0022, 11, 0x000B0017}, + {0x0021, 11, 0x000B0018}, + {0x0020, 11, 0x000B0019}, + {0x001F, 11, 0x000B001A}, + {0x001E, 11, 0x000B001B}, + {0x001D, 11, 0x000B001C}, + {0x001C, 11, 0x000B001D}, + {0x001B, 11, 0x000B001E}, + {0x001A, 11, 0x000B001F}, + {0x0019, 11, 0x000B0020}, + {0x0018, 11, 0x000B0021}, + {0x000F, 11, 0x000B0022}, + {0x0008, 11, 0x000B0023}, }; unsigned int CMacroblockAddressIncrementTable::m_pIndexTable[MAXBITS] = -{ - 0, - 1, - 1, - 3, - 5, - 5, - 7, - 9, - 9, - 15, - 21, + { + 0, + 1, + 1, + 3, + 5, + 5, + 7, + 9, + 9, + 15, + 21, }; CVLCTable* CMacroblockAddressIncrementTable::m_pInstance = NULL; -CMacroblockAddressIncrementTable::CMacroblockAddressIncrementTable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CMacroblockAddressIncrementTable::CMacroblockAddressIncrementTable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CMacroblockAddressIncrementTable::GetInstance() diff --git a/Source/ee/IPU_MacroblockAddressIncrementTable.h b/Source/ee/IPU_MacroblockAddressIncrementTable.h index 7e8963088..c1ea57316 100644 --- a/Source/ee/IPU_MacroblockAddressIncrementTable.h +++ b/Source/ee/IPU_MacroblockAddressIncrementTable.h @@ -9,8 +9,8 @@ namespace IPU class CMacroblockAddressIncrementTable : public MPEG2::CVLCTable { public: - CMacroblockAddressIncrementTable(); - static MPEG2::CVLCTable* GetInstance(); + CMacroblockAddressIncrementTable(); + static MPEG2::CVLCTable* GetInstance(); enum MAXBITS { @@ -23,11 +23,10 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; - } #endif diff --git a/Source/ee/IPU_MacroblockTypeBTable.cpp b/Source/ee/IPU_MacroblockTypeBTable.cpp index 97fa367fb..f4530cb93 100644 --- a/Source/ee/IPU_MacroblockTypeBTable.cpp +++ b/Source/ee/IPU_MacroblockTypeBTable.cpp @@ -5,36 +5,35 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CMacroblockTypeBTable::m_pTable[ENTRYCOUNT] = -{ - { 0x0002, 2, 0x0002000C }, - { 0x0003, 2, 0x0002000E }, - { 0x0002, 3, 0x00030004 }, - { 0x0003, 3, 0x00030006 }, - { 0x0002, 4, 0x00040008 }, - { 0x0003, 4, 0x0004000A }, - { 0x0003, 5, 0x00050001 }, - { 0x0002, 5, 0x0005001E }, - { 0x0003, 6, 0x0006001A }, - { 0x0002, 6, 0x00060016 }, - { 0x0001, 6, 0x00060011 }, + { + {0x0002, 2, 0x0002000C}, + {0x0003, 2, 0x0002000E}, + {0x0002, 3, 0x00030004}, + {0x0003, 3, 0x00030006}, + {0x0002, 4, 0x00040008}, + {0x0003, 4, 0x0004000A}, + {0x0003, 5, 0x00050001}, + {0x0002, 5, 0x0005001E}, + {0x0003, 6, 0x0006001A}, + {0x0002, 6, 0x00060016}, + {0x0001, 6, 0x00060011}, }; unsigned int CMacroblockTypeBTable::m_pIndexTable[MAXBITS] = -{ - 0, - 0, - 2, - 4, - 6, - 8, + { + 0, + 0, + 2, + 4, + 6, + 8, }; CVLCTable* CMacroblockTypeBTable::m_pInstance = NULL; -CMacroblockTypeBTable::CMacroblockTypeBTable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CMacroblockTypeBTable::CMacroblockTypeBTable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CMacroblockTypeBTable::GetInstance() diff --git a/Source/ee/IPU_MacroblockTypeBTable.h b/Source/ee/IPU_MacroblockTypeBTable.h index e8ea9b23e..2248f9a72 100644 --- a/Source/ee/IPU_MacroblockTypeBTable.h +++ b/Source/ee/IPU_MacroblockTypeBTable.h @@ -8,8 +8,8 @@ namespace IPU class CMacroblockTypeBTable : public MPEG2::CVLCTable { public: - CMacroblockTypeBTable(); - static CVLCTable* GetInstance(); + CMacroblockTypeBTable(); + static CVLCTable* GetInstance(); enum MAXBITS { @@ -22,9 +22,9 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; } diff --git a/Source/ee/IPU_MacroblockTypeITable.cpp b/Source/ee/IPU_MacroblockTypeITable.cpp index 859d47269..70f827d08 100644 --- a/Source/ee/IPU_MacroblockTypeITable.cpp +++ b/Source/ee/IPU_MacroblockTypeITable.cpp @@ -5,23 +5,22 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CMacroblockTypeITable::m_pTable[ENTRYCOUNT] = -{ - { 0x0001, 1, 0x00010001 }, - { 0x0001, 2, 0x00020011 }, + { + {0x0001, 1, 0x00010001}, + {0x0001, 2, 0x00020011}, }; unsigned int CMacroblockTypeITable::m_pIndexTable[MAXBITS] = -{ - 0, - 1, + { + 0, + 1, }; CVLCTable* CMacroblockTypeITable::m_pInstance = NULL; -CMacroblockTypeITable::CMacroblockTypeITable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CMacroblockTypeITable::CMacroblockTypeITable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CMacroblockTypeITable::GetInstance() diff --git a/Source/ee/IPU_MacroblockTypeITable.h b/Source/ee/IPU_MacroblockTypeITable.h index 93fa8bddb..ae4b70ed5 100644 --- a/Source/ee/IPU_MacroblockTypeITable.h +++ b/Source/ee/IPU_MacroblockTypeITable.h @@ -5,12 +5,12 @@ namespace IPU { - + class CMacroblockTypeITable : public MPEG2::CVLCTable { public: - CMacroblockTypeITable(); - static MPEG2::CVLCTable* GetInstance(); + CMacroblockTypeITable(); + static MPEG2::CVLCTable* GetInstance(); enum MAXBITS { @@ -23,11 +23,10 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; - } #endif diff --git a/Source/ee/IPU_MacroblockTypePTable.cpp b/Source/ee/IPU_MacroblockTypePTable.cpp index 2404f389c..61f2b1043 100644 --- a/Source/ee/IPU_MacroblockTypePTable.cpp +++ b/Source/ee/IPU_MacroblockTypePTable.cpp @@ -5,32 +5,31 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CMacroblockTypePTable::m_pTable[ENTRYCOUNT] = -{ - { 0x0001, 1, 0x0001000A }, - { 0x0001, 2, 0x00020002 }, - { 0x0001, 3, 0x00030008 }, - { 0x0003, 5, 0x00050001 }, - { 0x0002, 5, 0x0005001A }, - { 0x0001, 5, 0x00050012 }, - { 0x0001, 6, 0x00060011 }, + { + {0x0001, 1, 0x0001000A}, + {0x0001, 2, 0x00020002}, + {0x0001, 3, 0x00030008}, + {0x0003, 5, 0x00050001}, + {0x0002, 5, 0x0005001A}, + {0x0001, 5, 0x00050012}, + {0x0001, 6, 0x00060011}, }; unsigned int CMacroblockTypePTable::m_pIndexTable[MAXBITS] = -{ - 0, - 1, - 2, - 2, - 3, - 6, + { + 0, + 1, + 2, + 2, + 3, + 6, }; CVLCTable* CMacroblockTypePTable::m_pInstance = NULL; -CMacroblockTypePTable::CMacroblockTypePTable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CMacroblockTypePTable::CMacroblockTypePTable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CMacroblockTypePTable::GetInstance() diff --git a/Source/ee/IPU_MacroblockTypePTable.h b/Source/ee/IPU_MacroblockTypePTable.h index 0307631d2..2a7d33819 100644 --- a/Source/ee/IPU_MacroblockTypePTable.h +++ b/Source/ee/IPU_MacroblockTypePTable.h @@ -9,8 +9,8 @@ namespace IPU class CMacroblockTypePTable : public MPEG2::CVLCTable { public: - CMacroblockTypePTable(); - static MPEG2::CVLCTable* GetInstance(); + CMacroblockTypePTable(); + static MPEG2::CVLCTable* GetInstance(); enum MAXBITS { @@ -23,11 +23,10 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; - } #endif diff --git a/Source/ee/IPU_MotionCodeTable.cpp b/Source/ee/IPU_MotionCodeTable.cpp index 6bbcee53b..4658195ed 100644 --- a/Source/ee/IPU_MotionCodeTable.cpp +++ b/Source/ee/IPU_MotionCodeTable.cpp @@ -5,63 +5,62 @@ using namespace IPU; using namespace MPEG2; VLCTABLEENTRY CMotionCodeTable::m_pTable[ENTRYCOUNT] = -{ - { 0x0001, 1, 0x00010000 }, - { 0x0002, 3, 0x00030001 }, - { 0x0003, 3, 0x0003FFFF }, - { 0x0002, 4, 0x00040002 }, - { 0x0003, 4, 0x0004FFFE }, - { 0x0002, 5, 0x00050003 }, - { 0x0003, 5, 0x0005FFFD }, - { 0x0006, 7, 0x00070004 }, - { 0x0007, 7, 0x0007FFFC }, - { 0x000A, 8, 0x00080005 }, - { 0x000B, 8, 0x0008FFFB }, - { 0x0008, 8, 0x00080006 }, - { 0x0009, 8, 0x0008FFFA }, - { 0x0006, 8, 0x00080007 }, - { 0x0007, 8, 0x0008FFF9 }, - { 0x0016, 10, 0x000A0008 }, - { 0x0017, 10, 0x000AFFF8 }, - { 0x0014, 10, 0x000A0009 }, - { 0x0015, 10, 0x000AFFF7 }, - { 0x0012, 10, 0x000A000A }, - { 0x0013, 10, 0x000AFFF6 }, - { 0x0022, 11, 0x000B000B }, - { 0x0023, 11, 0x000BFFF5 }, - { 0x0020, 11, 0x000B000C }, - { 0x0021, 11, 0x000BFFF4 }, - { 0x001E, 11, 0x000B000D }, - { 0x001F, 11, 0x000BFFF3 }, - { 0x001C, 11, 0x000B000E }, - { 0x001D, 11, 0x000BFFF2 }, - { 0x001A, 11, 0x000B000F }, - { 0x001B, 11, 0x000BFFF1 }, - { 0x0018, 11, 0x000B0010 }, - { 0x0019, 11, 0x000BFFF0 }, + { + {0x0001, 1, 0x00010000}, + {0x0002, 3, 0x00030001}, + {0x0003, 3, 0x0003FFFF}, + {0x0002, 4, 0x00040002}, + {0x0003, 4, 0x0004FFFE}, + {0x0002, 5, 0x00050003}, + {0x0003, 5, 0x0005FFFD}, + {0x0006, 7, 0x00070004}, + {0x0007, 7, 0x0007FFFC}, + {0x000A, 8, 0x00080005}, + {0x000B, 8, 0x0008FFFB}, + {0x0008, 8, 0x00080006}, + {0x0009, 8, 0x0008FFFA}, + {0x0006, 8, 0x00080007}, + {0x0007, 8, 0x0008FFF9}, + {0x0016, 10, 0x000A0008}, + {0x0017, 10, 0x000AFFF8}, + {0x0014, 10, 0x000A0009}, + {0x0015, 10, 0x000AFFF7}, + {0x0012, 10, 0x000A000A}, + {0x0013, 10, 0x000AFFF6}, + {0x0022, 11, 0x000B000B}, + {0x0023, 11, 0x000BFFF5}, + {0x0020, 11, 0x000B000C}, + {0x0021, 11, 0x000BFFF4}, + {0x001E, 11, 0x000B000D}, + {0x001F, 11, 0x000BFFF3}, + {0x001C, 11, 0x000B000E}, + {0x001D, 11, 0x000BFFF2}, + {0x001A, 11, 0x000B000F}, + {0x001B, 11, 0x000BFFF1}, + {0x0018, 11, 0x000B0010}, + {0x0019, 11, 0x000BFFF0}, }; unsigned int CMotionCodeTable::m_pIndexTable[MAXBITS] = -{ - 0, - 1, - 1, - 3, - 5, - 7, - 7, - 9, - 15, - 15, - 21, + { + 0, + 1, + 1, + 3, + 5, + 7, + 7, + 9, + 15, + 15, + 21, }; CVLCTable* CMotionCodeTable::m_pInstance = NULL; -CMotionCodeTable::CMotionCodeTable() : -CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) +CMotionCodeTable::CMotionCodeTable() + : CVLCTable(MAXBITS, m_pTable, ENTRYCOUNT, m_pIndexTable) { - } CVLCTable* CMotionCodeTable::GetInstance() diff --git a/Source/ee/IPU_MotionCodeTable.h b/Source/ee/IPU_MotionCodeTable.h index 8e544483f..37205f96e 100644 --- a/Source/ee/IPU_MotionCodeTable.h +++ b/Source/ee/IPU_MotionCodeTable.h @@ -8,8 +8,8 @@ namespace IPU class CMotionCodeTable : public MPEG2::CVLCTable { public: - CMotionCodeTable(); - static CVLCTable* GetInstance(); + CMotionCodeTable(); + static CVLCTable* GetInstance(); enum MAXBITS { @@ -22,9 +22,9 @@ namespace IPU }; private: - static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; - static unsigned int m_pIndexTable[MAXBITS]; - static MPEG2::CVLCTable* m_pInstance; + static MPEG2::VLCTABLEENTRY m_pTable[ENTRYCOUNT]; + static unsigned int m_pIndexTable[MAXBITS]; + static MPEG2::CVLCTable* m_pInstance; }; }; diff --git a/Source/ee/MA_EE.cpp b/Source/ee/MA_EE.cpp index 932ee4f15..8600cf81f 100644 --- a/Source/ee/MA_EE.cpp +++ b/Source/ee/MA_EE.cpp @@ -4,8 +4,8 @@ #include "MA_EE.h" #include "offsetof_def.h" -CMA_EE::CMA_EE() : -CMA_MIPSIV(MIPS_REGSIZE_64) +CMA_EE::CMA_EE() + : CMA_MIPSIV(MIPS_REGSIZE_64) { m_pOpGeneral[0x1E] = std::bind(&CMA_EE::LQ, this); m_pOpGeneral[0x1F] = std::bind(&CMA_EE::SQ, this); @@ -920,13 +920,13 @@ void CMA_EE::QFSRV() //02 void CMA_EE::PSLLVW() { - Generic_PSxxV([this] () { m_codeGen->Shl(); }); + Generic_PSxxV([this]() { m_codeGen->Shl(); }); } //03 void CMA_EE::PSRLVW() { - Generic_PSxxV([this] () { m_codeGen->Srl(); }); + Generic_PSxxV([this]() { m_codeGen->Srl(); }); } //08 @@ -976,14 +976,14 @@ void CMA_EE::PCPYLD() //A0 m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[0])); m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[1])); - + m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[3])); m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[2])); //B0 m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[0])); m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[1])); - + m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[1])); m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[0])); } @@ -992,16 +992,15 @@ void CMA_EE::PCPYLD() void CMA_EE::PMADDH() { static const size_t offsets[8] = - { - offsetof(CMIPS, m_State.nLO[0]), - offsetof(CMIPS, m_State.nLO[1]), - offsetof(CMIPS, m_State.nHI[0]), - offsetof(CMIPS, m_State.nHI[1]), - offsetof(CMIPS, m_State.nLO1[0]), - offsetof(CMIPS, m_State.nLO1[1]), - offsetof(CMIPS, m_State.nHI1[0]), - offsetof(CMIPS, m_State.nHI1[1]) - }; + { + offsetof(CMIPS, m_State.nLO[0]), + offsetof(CMIPS, m_State.nLO[1]), + offsetof(CMIPS, m_State.nHI[0]), + offsetof(CMIPS, m_State.nHI[1]), + offsetof(CMIPS, m_State.nLO1[0]), + offsetof(CMIPS, m_State.nLO1[1]), + offsetof(CMIPS, m_State.nHI1[0]), + offsetof(CMIPS, m_State.nHI1[1])}; for(unsigned int i = 0; i < 4; i++) { @@ -1059,20 +1058,20 @@ void CMA_EE::PMADDH() void CMA_EE::PHMADH() { static const size_t offsets[4] = - { - offsetof(CMIPS, m_State.nLO[0]), - offsetof(CMIPS, m_State.nHI[0]), - offsetof(CMIPS, m_State.nLO1[0]), - offsetof(CMIPS, m_State.nHI1[0]), - }; + { + offsetof(CMIPS, m_State.nLO[0]), + offsetof(CMIPS, m_State.nHI[0]), + offsetof(CMIPS, m_State.nLO1[0]), + offsetof(CMIPS, m_State.nHI1[0]), + }; static const size_t clearOffsets[4] = - { - offsetof(CMIPS, m_State.nLO[1]), - offsetof(CMIPS, m_State.nHI[1]), - offsetof(CMIPS, m_State.nLO1[1]), - offsetof(CMIPS, m_State.nHI1[1]), - }; + { + offsetof(CMIPS, m_State.nLO[1]), + offsetof(CMIPS, m_State.nHI[1]), + offsetof(CMIPS, m_State.nLO1[1]), + offsetof(CMIPS, m_State.nHI1[1]), + }; for(unsigned int i = 0; i < 4; i++) { @@ -1169,16 +1168,15 @@ void CMA_EE::PREVH() void CMA_EE::PMULTH() { static const size_t offsets[8] = - { - offsetof(CMIPS, m_State.nLO[0]), - offsetof(CMIPS, m_State.nLO[1]), - offsetof(CMIPS, m_State.nHI[0]), - offsetof(CMIPS, m_State.nHI[1]), - offsetof(CMIPS, m_State.nLO1[0]), - offsetof(CMIPS, m_State.nLO1[1]), - offsetof(CMIPS, m_State.nHI1[0]), - offsetof(CMIPS, m_State.nHI1[1]) - }; + { + offsetof(CMIPS, m_State.nLO[0]), + offsetof(CMIPS, m_State.nLO[1]), + offsetof(CMIPS, m_State.nHI[0]), + offsetof(CMIPS, m_State.nHI[1]), + offsetof(CMIPS, m_State.nLO1[0]), + offsetof(CMIPS, m_State.nLO1[1]), + offsetof(CMIPS, m_State.nHI1[0]), + offsetof(CMIPS, m_State.nHI1[1])}; for(unsigned int i = 0; i < 4; i++) { @@ -1299,7 +1297,7 @@ void CMA_EE::PROT3W() //03 void CMA_EE::PSRAVW() { - Generic_PSxxV([this] () { m_codeGen->Sra(); }); + Generic_PSxxV([this]() { m_codeGen->Sra(); }); } //08 @@ -1357,14 +1355,14 @@ void CMA_EE::PCPYUD() //A m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[2])); m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRS].nV[3])); - + m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[1])); m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[0])); //B m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[2])); m_codeGen->PushRel(offsetof(CMIPS, m_State.nGPR[m_nRT].nV[3])); - + m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[3])); m_codeGen->PullRel(offsetof(CMIPS, m_State.nGPR[m_nRD].nV[2])); } @@ -1524,23 +1522,22 @@ void CMA_EE::PMFHL_LH() if(m_nRD == 0) return; static const size_t offsets[8] = - { - offsetof(CMIPS, m_State.nLO[0]), - offsetof(CMIPS, m_State.nLO[1]), - offsetof(CMIPS, m_State.nHI[0]), - offsetof(CMIPS, m_State.nHI[1]), - offsetof(CMIPS, m_State.nLO1[0]), - offsetof(CMIPS, m_State.nLO1[1]), - offsetof(CMIPS, m_State.nHI1[0]), - offsetof(CMIPS, m_State.nHI1[1]) - }; + { + offsetof(CMIPS, m_State.nLO[0]), + offsetof(CMIPS, m_State.nLO[1]), + offsetof(CMIPS, m_State.nHI[0]), + offsetof(CMIPS, m_State.nHI[1]), + offsetof(CMIPS, m_State.nLO1[0]), + offsetof(CMIPS, m_State.nLO1[1]), + offsetof(CMIPS, m_State.nHI1[0]), + offsetof(CMIPS, m_State.nHI1[1])}; for(unsigned int i = 0; i < 4; i++) { m_codeGen->PushRel(offsets[(i * 2) + 0]); m_codeGen->PushCst(0xFFFF); m_codeGen->And(); - + m_codeGen->PushRel(offsets[(i * 2) + 1]); m_codeGen->Shl(16); @@ -1555,38 +1552,36 @@ void CMA_EE::PMFHL_SH() if(m_nRD == 0) return; static const auto emitClamp = - [] (CMipsJitter* codeGen, size_t offsetToClamp) - { - codeGen->PushRel(offsetToClamp); - codeGen->PushCst(0x7FFF); - codeGen->BeginIf(Jitter::CONDITION_GT); - { - codeGen->PushCst(0x7FFF); - codeGen->PullRel(offsetToClamp); - } - codeGen->EndIf(); + [](CMipsJitter* codeGen, size_t offsetToClamp) { + codeGen->PushRel(offsetToClamp); + codeGen->PushCst(0x7FFF); + codeGen->BeginIf(Jitter::CONDITION_GT); + { + codeGen->PushCst(0x7FFF); + codeGen->PullRel(offsetToClamp); + } + codeGen->EndIf(); - codeGen->PushRel(offsetToClamp); - codeGen->PushCst(0xFFFF8000); - codeGen->BeginIf(Jitter::CONDITION_LT); - { - codeGen->PushCst(0x8000); - codeGen->PullRel(offsetToClamp); - } - codeGen->EndIf(); - }; + codeGen->PushRel(offsetToClamp); + codeGen->PushCst(0xFFFF8000); + codeGen->BeginIf(Jitter::CONDITION_LT); + { + codeGen->PushCst(0x8000); + codeGen->PullRel(offsetToClamp); + } + codeGen->EndIf(); + }; static const size_t offsets[8] = - { - offsetof(CMIPS, m_State.nLO[0]), - offsetof(CMIPS, m_State.nLO[1]), - offsetof(CMIPS, m_State.nHI[0]), - offsetof(CMIPS, m_State.nHI[1]), - offsetof(CMIPS, m_State.nLO1[0]), - offsetof(CMIPS, m_State.nLO1[1]), - offsetof(CMIPS, m_State.nHI1[0]), - offsetof(CMIPS, m_State.nHI1[1]) - }; + { + offsetof(CMIPS, m_State.nLO[0]), + offsetof(CMIPS, m_State.nLO[1]), + offsetof(CMIPS, m_State.nHI[0]), + offsetof(CMIPS, m_State.nHI[1]), + offsetof(CMIPS, m_State.nLO1[0]), + offsetof(CMIPS, m_State.nLO1[1]), + offsetof(CMIPS, m_State.nHI1[0]), + offsetof(CMIPS, m_State.nHI1[1])}; static const size_t tempOffset = offsetof(CMIPS, m_State.nCOP2T); diff --git a/Source/ee/MA_EE.h b/Source/ee/MA_EE.h index ed313266d..395d44276 100644 --- a/Source/ee/MA_EE.h +++ b/Source/ee/MA_EE.h @@ -5,170 +5,169 @@ class CMA_EE : public CMA_MIPSIV { public: - CMA_EE(); - virtual ~CMA_EE() = default; + CMA_EE(); + virtual ~CMA_EE() = default; protected: typedef void (CMA_EE::*InstructionFuncConstant)(); - void SetupReflectionTables(); + void SetupReflectionTables(); - static InstructionFuncConstant m_pOpMmi0[0x20]; - static InstructionFuncConstant m_pOpMmi1[0x20]; - static InstructionFuncConstant m_pOpMmi2[0x20]; - static InstructionFuncConstant m_pOpMmi3[0x20]; - static InstructionFuncConstant m_pOpPmfhl[0x20]; + static InstructionFuncConstant m_pOpMmi0[0x20]; + static InstructionFuncConstant m_pOpMmi1[0x20]; + static InstructionFuncConstant m_pOpMmi2[0x20]; + static InstructionFuncConstant m_pOpMmi3[0x20]; + static InstructionFuncConstant m_pOpPmfhl[0x20]; - static void ReflOpRdRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpRsImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRdRt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpRsImm(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - MIPSReflection::INSTRUCTION m_ReflMmi[64]; - MIPSReflection::INSTRUCTION m_ReflMmi0[32]; - MIPSReflection::INSTRUCTION m_ReflMmi1[32]; - MIPSReflection::INSTRUCTION m_ReflMmi2[32]; - MIPSReflection::INSTRUCTION m_ReflMmi3[32]; - MIPSReflection::INSTRUCTION m_ReflPmfhl[32]; + MIPSReflection::INSTRUCTION m_ReflMmi[64]; + MIPSReflection::INSTRUCTION m_ReflMmi0[32]; + MIPSReflection::INSTRUCTION m_ReflMmi1[32]; + MIPSReflection::INSTRUCTION m_ReflMmi2[32]; + MIPSReflection::INSTRUCTION m_ReflMmi3[32]; + MIPSReflection::INSTRUCTION m_ReflPmfhl[32]; - MIPSReflection::SUBTABLE m_ReflMmiTable; - MIPSReflection::SUBTABLE m_ReflMmi0Table; - MIPSReflection::SUBTABLE m_ReflMmi1Table; - MIPSReflection::SUBTABLE m_ReflMmi2Table; - MIPSReflection::SUBTABLE m_ReflMmi3Table; - MIPSReflection::SUBTABLE m_ReflPmfhlTable; + MIPSReflection::SUBTABLE m_ReflMmiTable; + MIPSReflection::SUBTABLE m_ReflMmi0Table; + MIPSReflection::SUBTABLE m_ReflMmi1Table; + MIPSReflection::SUBTABLE m_ReflMmi2Table; + MIPSReflection::SUBTABLE m_ReflMmi3Table; + MIPSReflection::SUBTABLE m_ReflPmfhlTable; private: - - void PushVector(unsigned int); - void PullVector(unsigned int); - size_t GetLoOffset(unsigned int); - size_t GetHiOffset(unsigned int); + void PushVector(unsigned int); + void PullVector(unsigned int); + size_t GetLoOffset(unsigned int); + size_t GetHiOffset(unsigned int); //General - void LQ(); - void SQ(); + void LQ(); + void SQ(); //RegImm - void MTSAB(); - void MTSAH(); + void MTSAB(); + void MTSAH(); //Special - void MFSA(); - void MTSA(); + void MFSA(); + void MTSA(); //Special2 - void MADD(); - void MADDU(); - void PLZCW(); - void MMI0(); - void MMI2(); - void MFHI1(); - void MTHI1(); - void MFLO1(); - void MTLO1(); - void MULT1(); - void MULTU1(); - void DIV1(); - void DIVU1(); - void MADD1(); - void MADDU1(); - void MMI1(); - void MMI3(); - void PMFHL(); - void PSLLH(); - void PSRLH(); - void PSRAH(); - void PSLLW(); - void PSRLW(); - void PSRAW(); + void MADD(); + void MADDU(); + void PLZCW(); + void MMI0(); + void MMI2(); + void MFHI1(); + void MTHI1(); + void MFLO1(); + void MTLO1(); + void MULT1(); + void MULTU1(); + void DIV1(); + void DIVU1(); + void MADD1(); + void MADDU1(); + void MMI1(); + void MMI3(); + void PMFHL(); + void PSLLH(); + void PSRLH(); + void PSRAH(); + void PSLLW(); + void PSRLW(); + void PSRAW(); //Mmi0 - void PADDW(); - void PSUBW(); - void PCGTW(); - void PMAXW(); - void PADDH(); - void PSUBH(); - void PCGTH(); - void PMAXH(); - void PADDB(); - void PSUBB(); - void PCGTB(); - void PADDSW(); - void PSUBSW(); - void PEXTLW(); - void PPACW(); - void PADDSH(); - void PSUBSH(); - void PEXTLH(); - void PPACH(); - void PADDSB(); - void PEXTLB(); - void PPACB(); - void PEXT5(); - void PPAC5(); + void PADDW(); + void PSUBW(); + void PCGTW(); + void PMAXW(); + void PADDH(); + void PSUBH(); + void PCGTH(); + void PMAXH(); + void PADDB(); + void PSUBB(); + void PCGTB(); + void PADDSW(); + void PSUBSW(); + void PEXTLW(); + void PPACW(); + void PADDSH(); + void PSUBSH(); + void PEXTLH(); + void PPACH(); + void PADDSB(); + void PEXTLB(); + void PPACB(); + void PEXT5(); + void PPAC5(); //Mmi1 - void PABSW(); - void PCEQW(); - void PMINW(); - void PCEQH(); - void PMINH(); - void PCEQB(); - void PADDUW(); - void PEXTUW(); - void PADDUH(); - void PSUBUH(); - void PEXTUH(); - void PADDUB(); - void PSUBUB(); - void PEXTUB(); - void QFSRV(); + void PABSW(); + void PCEQW(); + void PMINW(); + void PCEQH(); + void PMINH(); + void PCEQB(); + void PADDUW(); + void PEXTUW(); + void PADDUH(); + void PSUBUH(); + void PEXTUH(); + void PADDUB(); + void PSUBUB(); + void PEXTUB(); + void QFSRV(); //Mmi2 - void PSLLVW(); - void PSRLVW(); - void PMFHI(); - void PMFLO(); - void PMULTW(); - void PDIVW(); - void PCPYLD(); - void PMADDH(); - void PHMADH(); - void PAND(); - void PXOR(); - void PREVH(); - void PMULTH(); - void PEXEW(); - void PROT3W(); + void PSLLVW(); + void PSRLVW(); + void PMFHI(); + void PMFLO(); + void PMULTW(); + void PDIVW(); + void PCPYLD(); + void PMADDH(); + void PHMADH(); + void PAND(); + void PXOR(); + void PREVH(); + void PMULTH(); + void PEXEW(); + void PROT3W(); //Mmi3 - void PSRAVW(); - void PMTHI(); - void PMTLO(); - void PINTEH(); - void PMULTUW(); - void PCPYUD(); - void POR(); - void PNOR(); - void PEXCH(); - void PCPYH(); - void PEXCW(); + void PSRAVW(); + void PMTHI(); + void PMTLO(); + void PINTEH(); + void PMULTUW(); + void PCPYUD(); + void POR(); + void PNOR(); + void PEXCH(); + void PCPYH(); + void PEXCW(); //Pmfhl - void PMFHL_LW(); - void PMFHL_UW(); - void PMFHL_LH(); - void PMFHL_SH(); + void PMFHL_LW(); + void PMFHL_UW(); + void PMFHL_LH(); + void PMFHL_SH(); - void Generic_MADD(unsigned int unit, bool isSigned); - void Generic_PMULTW(bool); - void Generic_PSxxV(const TemplateOperationFunctionType&); + void Generic_MADD(unsigned int unit, bool isSigned); + void Generic_PMULTW(bool); + void Generic_PSxxV(const TemplateOperationFunctionType&); //Reflection tables - static MIPSReflection::INSTRUCTION m_cReflMmi[64]; - static MIPSReflection::INSTRUCTION m_cReflMmi0[32]; - static MIPSReflection::INSTRUCTION m_cReflMmi1[32]; - static MIPSReflection::INSTRUCTION m_cReflMmi2[32]; - static MIPSReflection::INSTRUCTION m_cReflMmi3[32]; - static MIPSReflection::INSTRUCTION m_cReflPmfhl[32]; + static MIPSReflection::INSTRUCTION m_cReflMmi[64]; + static MIPSReflection::INSTRUCTION m_cReflMmi0[32]; + static MIPSReflection::INSTRUCTION m_cReflMmi1[32]; + static MIPSReflection::INSTRUCTION m_cReflMmi2[32]; + static MIPSReflection::INSTRUCTION m_cReflMmi3[32]; + static MIPSReflection::INSTRUCTION m_cReflPmfhl[32]; }; diff --git a/Source/ee/MA_EE_Reflection.cpp b/Source/ee/MA_EE_Reflection.cpp index 870d356c9..82a8a4c7a 100644 --- a/Source/ee/MA_EE_Reflection.cpp +++ b/Source/ee/MA_EE_Reflection.cpp @@ -14,8 +14,8 @@ void CMA_EE::ReflOpRdRt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint3 void CMA_EE::ReflOpRsImm(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nRS = static_cast ((nOpcode >> 21) & 0x001F); - uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); + uint8 nRS = static_cast((nOpcode >> 21) & 0x001F); + uint16 nImm = static_cast((nOpcode >> 0) & 0xFFFF); sprintf(sText, "%s, $%04X", CMIPS::m_sGPRName[nRS], nImm); } @@ -300,83 +300,83 @@ INSTRUCTION CMA_EE::m_cReflPmfhl[32] = void CMA_EE::SetupReflectionTables() { - static_assert(sizeof(m_ReflMmi) == sizeof(m_cReflMmi), "Array sizes don't match"); - static_assert(sizeof(m_ReflMmi0) == sizeof(m_cReflMmi0), "Array sizes don't match"); - static_assert(sizeof(m_ReflMmi1) == sizeof(m_cReflMmi1), "Array sizes don't match"); - static_assert(sizeof(m_ReflMmi2) == sizeof(m_cReflMmi2), "Array sizes don't match"); - static_assert(sizeof(m_ReflMmi3) == sizeof(m_cReflMmi3), "Array sizes don't match"); - static_assert(sizeof(m_ReflPmfhl) == sizeof(m_cReflPmfhl), "Array sizes don't match"); + static_assert(sizeof(m_ReflMmi) == sizeof(m_cReflMmi), "Array sizes don't match"); + static_assert(sizeof(m_ReflMmi0) == sizeof(m_cReflMmi0), "Array sizes don't match"); + static_assert(sizeof(m_ReflMmi1) == sizeof(m_cReflMmi1), "Array sizes don't match"); + static_assert(sizeof(m_ReflMmi2) == sizeof(m_cReflMmi2), "Array sizes don't match"); + static_assert(sizeof(m_ReflMmi3) == sizeof(m_cReflMmi3), "Array sizes don't match"); + static_assert(sizeof(m_ReflPmfhl) == sizeof(m_cReflPmfhl), "Array sizes don't match"); - memcpy(m_ReflMmi, m_cReflMmi, sizeof(m_cReflMmi)); - memcpy(m_ReflMmi0, m_cReflMmi0, sizeof(m_cReflMmi0)); - memcpy(m_ReflMmi1, m_cReflMmi1, sizeof(m_cReflMmi1)); - memcpy(m_ReflMmi2, m_cReflMmi2, sizeof(m_cReflMmi2)); - memcpy(m_ReflMmi3, m_cReflMmi3, sizeof(m_cReflMmi3)); - memcpy(m_ReflPmfhl, m_cReflPmfhl, sizeof(m_cReflPmfhl)); + memcpy(m_ReflMmi, m_cReflMmi, sizeof(m_cReflMmi)); + memcpy(m_ReflMmi0, m_cReflMmi0, sizeof(m_cReflMmi0)); + memcpy(m_ReflMmi1, m_cReflMmi1, sizeof(m_cReflMmi1)); + memcpy(m_ReflMmi2, m_cReflMmi2, sizeof(m_cReflMmi2)); + memcpy(m_ReflMmi3, m_cReflMmi3, sizeof(m_cReflMmi3)); + memcpy(m_ReflPmfhl, m_cReflPmfhl, sizeof(m_cReflPmfhl)); - m_ReflMmiTable.pTable = m_ReflMmi; - m_ReflMmiTable.nShift = 0; - m_ReflMmiTable.nMask = 0x3F; + m_ReflMmiTable.pTable = m_ReflMmi; + m_ReflMmiTable.nShift = 0; + m_ReflMmiTable.nMask = 0x3F; - m_ReflMmi0Table.pTable = m_ReflMmi0; - m_ReflMmi0Table.nShift = 6; - m_ReflMmi0Table.nMask = 0x1F; + m_ReflMmi0Table.pTable = m_ReflMmi0; + m_ReflMmi0Table.nShift = 6; + m_ReflMmi0Table.nMask = 0x1F; - m_ReflMmi1Table.pTable = m_ReflMmi1; - m_ReflMmi1Table.nShift = 6; - m_ReflMmi1Table.nMask = 0x1F; + m_ReflMmi1Table.pTable = m_ReflMmi1; + m_ReflMmi1Table.nShift = 6; + m_ReflMmi1Table.nMask = 0x1F; - m_ReflMmi2Table.pTable = m_ReflMmi2; - m_ReflMmi2Table.nShift = 6; - m_ReflMmi2Table.nMask = 0x1F; + m_ReflMmi2Table.pTable = m_ReflMmi2; + m_ReflMmi2Table.nShift = 6; + m_ReflMmi2Table.nMask = 0x1F; - m_ReflMmi3Table.pTable = m_ReflMmi3; - m_ReflMmi3Table.nShift = 6; - m_ReflMmi3Table.nMask = 0x1F; + m_ReflMmi3Table.pTable = m_ReflMmi3; + m_ReflMmi3Table.nShift = 6; + m_ReflMmi3Table.nMask = 0x1F; - m_ReflPmfhlTable.pTable = m_ReflPmfhl; - m_ReflPmfhlTable.nShift = 6; - m_ReflPmfhlTable.nMask = 0x1F; + m_ReflPmfhlTable.pTable = m_ReflPmfhl; + m_ReflPmfhlTable.nShift = 6; + m_ReflPmfhlTable.nMask = 0x1F; //Fix MIPSIV tables - m_ReflGeneral[0x1C].sMnemonic = "MMI"; - m_ReflGeneral[0x1C].pSubTable = &m_ReflMmiTable; - m_ReflGeneral[0x1C].pGetMnemonic = SubTableMnemonic; - m_ReflGeneral[0x1C].pGetOperands = SubTableOperands; - m_ReflGeneral[0x1C].pIsBranch = SubTableIsBranch; - m_ReflGeneral[0x1C].pGetEffectiveAddress = SubTableEffAddr; + m_ReflGeneral[0x1C].sMnemonic = "MMI"; + m_ReflGeneral[0x1C].pSubTable = &m_ReflMmiTable; + m_ReflGeneral[0x1C].pGetMnemonic = SubTableMnemonic; + m_ReflGeneral[0x1C].pGetOperands = SubTableOperands; + m_ReflGeneral[0x1C].pIsBranch = SubTableIsBranch; + m_ReflGeneral[0x1C].pGetEffectiveAddress = SubTableEffAddr; - m_ReflGeneral[0x1E].sMnemonic = "LQ"; - m_ReflGeneral[0x1E].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflGeneral[0x1E].pGetOperands = ReflOpRtOffRs; + m_ReflGeneral[0x1E].sMnemonic = "LQ"; + m_ReflGeneral[0x1E].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflGeneral[0x1E].pGetOperands = ReflOpRtOffRs; - m_ReflGeneral[0x1F].sMnemonic = "SQ"; - m_ReflGeneral[0x1F].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflGeneral[0x1F].pGetOperands = ReflOpRtOffRs; + m_ReflGeneral[0x1F].sMnemonic = "SQ"; + m_ReflGeneral[0x1F].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflGeneral[0x1F].pGetOperands = ReflOpRtOffRs; - m_ReflRegImm[0x18].sMnemonic = "MTSAB"; - m_ReflRegImm[0x18].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflRegImm[0x18].pGetOperands = ReflOpRsImm; + m_ReflRegImm[0x18].sMnemonic = "MTSAB"; + m_ReflRegImm[0x18].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflRegImm[0x18].pGetOperands = ReflOpRsImm; - m_ReflRegImm[0x19].sMnemonic = "MTSAH"; - m_ReflRegImm[0x19].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflRegImm[0x19].pGetOperands = ReflOpRsImm; + m_ReflRegImm[0x19].sMnemonic = "MTSAH"; + m_ReflRegImm[0x19].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflRegImm[0x19].pGetOperands = ReflOpRsImm; - m_ReflSpecial[0x28].sMnemonic = "MFSA"; - m_ReflSpecial[0x28].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflSpecial[0x28].pGetOperands = ReflOpRd; + m_ReflSpecial[0x28].sMnemonic = "MFSA"; + m_ReflSpecial[0x28].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflSpecial[0x28].pGetOperands = ReflOpRd; - m_ReflSpecial[0x29].sMnemonic = "MTSA"; - m_ReflSpecial[0x29].pGetMnemonic = MIPSReflection::CopyMnemonic; - m_ReflSpecial[0x29].pGetOperands = ReflOpRs; + m_ReflSpecial[0x29].sMnemonic = "MTSA"; + m_ReflSpecial[0x29].pGetMnemonic = MIPSReflection::CopyMnemonic; + m_ReflSpecial[0x29].pGetOperands = ReflOpRs; //Fix MULT/MULTU operands - m_ReflSpecial[0x18].pGetOperands = ReflOpRdRsRt; - m_ReflSpecial[0x19].pGetOperands = ReflOpRdRsRt; + m_ReflSpecial[0x18].pGetOperands = ReflOpRdRsRt; + m_ReflSpecial[0x19].pGetOperands = ReflOpRdRsRt; - m_ReflMmi[0x08].pSubTable = &m_ReflMmi0Table; - m_ReflMmi[0x09].pSubTable = &m_ReflMmi2Table; - m_ReflMmi[0x28].pSubTable = &m_ReflMmi1Table; - m_ReflMmi[0x29].pSubTable = &m_ReflMmi3Table; - m_ReflMmi[0x30].pSubTable = &m_ReflPmfhlTable; + m_ReflMmi[0x08].pSubTable = &m_ReflMmi0Table; + m_ReflMmi[0x09].pSubTable = &m_ReflMmi2Table; + m_ReflMmi[0x28].pSubTable = &m_ReflMmi1Table; + m_ReflMmi[0x29].pSubTable = &m_ReflMmi3Table; + m_ReflMmi[0x30].pSubTable = &m_ReflPmfhlTable; } diff --git a/Source/ee/MA_VU.cpp b/Source/ee/MA_VU.cpp index 3edc96bec..4192734b5 100644 --- a/Source/ee/MA_VU.cpp +++ b/Source/ee/MA_VU.cpp @@ -2,8 +2,8 @@ #include "../MIPS.h" CMA_VU::CMA_VU(uint32 vuMemAddressMask) -: CMIPSArchitecture(MIPS_REGSIZE_64) -, m_Lower(vuMemAddressMask) + : CMIPSArchitecture(MIPS_REGSIZE_64) + , m_Lower(vuMemAddressMask) { SetupReflectionTables(); } diff --git a/Source/ee/MA_VU.h b/Source/ee/MA_VU.h index fb69bd889..ec87be850 100644 --- a/Source/ee/MA_VU.h +++ b/Source/ee/MA_VU.h @@ -10,178 +10,178 @@ class CMA_VU : public CMIPSArchitecture { public: - CMA_VU(uint32); + CMA_VU(uint32); - void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int) override; - void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int) override; - MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32) override; - uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32) override; - VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); + void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int) override; + void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int) override; + MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32) override; + uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32) override; + VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); - void SetRelativePipeTime(uint32); + void SetRelativePipeTime(uint32); private: - void SetupReflectionTables(); + void SetupReflectionTables(); class CUpper : public CMIPSInstructionFactory { public: - CUpper(); + CUpper(); - void SetupReflectionTables(); - void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); - void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); - VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); - MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); - uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); + void SetupReflectionTables(); + void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); + void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); + VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); + MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); + uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); - void SetRelativePipeTime(uint32); + void SetRelativePipeTime(uint32); private: typedef void (CUpper::*InstructionFuncConstant)(); - static InstructionFuncConstant m_pOpVector[0x40]; - static InstructionFuncConstant m_pOpVector0[0x20]; - static InstructionFuncConstant m_pOpVector1[0x20]; - static InstructionFuncConstant m_pOpVector2[0x20]; - static InstructionFuncConstant m_pOpVector3[0x20]; + static InstructionFuncConstant m_pOpVector[0x40]; + static InstructionFuncConstant m_pOpVector0[0x20]; + static InstructionFuncConstant m_pOpVector1[0x20]; + static InstructionFuncConstant m_pOpVector2[0x20]; + static InstructionFuncConstant m_pOpVector3[0x20]; - uint8 m_nFT; - uint8 m_nFS; - uint8 m_nFD; - uint8 m_nBc; - uint8 m_nDest; - uint32 m_relativePipeTime; + uint8 m_nFT; + uint8 m_nFS; + uint8 m_nFD; + uint8 m_nBc; + uint8 m_nDest; + uint32 m_relativePipeTime; - static void ReflOpFtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void LOI(uint32); + void LOI(uint32); //Vector - void ADDbc(); - void SUBbc(); - void MADDbc(); - void MSUBbc(); - void MAXbc(); - void MINIbc(); - void MULbc(); - void MULq(); - void MAXi(); - void MULi(); - void MINIi(); - void ADDq(); - void MADDq(); - void ADDi(); - void MADDi(); - void SUBq(); - void MSUBq(); - void SUBi(); - void MSUBi(); - void ADD(); - void MADD(); - void MUL(); - void MAX(); - void SUB(); - void MSUB(); - void OPMSUB(); - void MINI(); - void VECTOR0(); - void VECTOR1(); - void VECTOR2(); - void VECTOR3(); + void ADDbc(); + void SUBbc(); + void MADDbc(); + void MSUBbc(); + void MAXbc(); + void MINIbc(); + void MULbc(); + void MULq(); + void MAXi(); + void MULi(); + void MINIi(); + void ADDq(); + void MADDq(); + void ADDi(); + void MADDi(); + void SUBq(); + void MSUBq(); + void SUBi(); + void MSUBi(); + void ADD(); + void MADD(); + void MUL(); + void MAX(); + void SUB(); + void MSUB(); + void OPMSUB(); + void MINI(); + void VECTOR0(); + void VECTOR1(); + void VECTOR2(); + void VECTOR3(); //Vector X Common - void ADDAbc(); - void SUBAbc(); - void MADDAbc(); - void MSUBAbc(); - void MULAbc(); + void ADDAbc(); + void SUBAbc(); + void MADDAbc(); + void MSUBAbc(); + void MULAbc(); //Vector 0 - void ITOF0(); - void FTOI0(); - void MULAq(); - void ADDA(); - void SUBA(); + void ITOF0(); + void FTOI0(); + void MULAq(); + void ADDA(); + void SUBA(); //Vector 1 - void ITOF4(); - void FTOI4(); - void ABS(); - void MSUBAq(); - void MADDA(); - void MSUBA(); + void ITOF4(); + void FTOI4(); + void ABS(); + void MSUBAq(); + void MADDA(); + void MSUBA(); //Vector 2 - void ITOF12(); - void FTOI12(); - void MULAi(); - void ADDAi(); - void SUBAi(); - void MULA(); - void OPMULA(); + void ITOF12(); + void FTOI12(); + void MULAi(); + void ADDAi(); + void SUBAi(); + void MULA(); + void OPMULA(); //Vector 3 - void ITOF15(); - void FTOI15(); - void CLIP(); - void MADDAi(); - void MSUBAi(); - void NOP(); + void ITOF15(); + void FTOI15(); + void CLIP(); + void MADDAi(); + void MSUBAi(); + void NOP(); - MIPSReflection::INSTRUCTION m_ReflV[64]; - MIPSReflection::INSTRUCTION m_ReflVX0[32]; - MIPSReflection::INSTRUCTION m_ReflVX1[32]; - MIPSReflection::INSTRUCTION m_ReflVX2[32]; - MIPSReflection::INSTRUCTION m_ReflVX3[32]; + MIPSReflection::INSTRUCTION m_ReflV[64]; + MIPSReflection::INSTRUCTION m_ReflVX0[32]; + MIPSReflection::INSTRUCTION m_ReflVX1[32]; + MIPSReflection::INSTRUCTION m_ReflVX2[32]; + MIPSReflection::INSTRUCTION m_ReflVX3[32]; - VUShared::VUINSTRUCTION m_VuReflV[64]; - VUShared::VUINSTRUCTION m_VuReflVX0[32]; - VUShared::VUINSTRUCTION m_VuReflVX1[32]; - VUShared::VUINSTRUCTION m_VuReflVX2[32]; - VUShared::VUINSTRUCTION m_VuReflVX3[32]; + VUShared::VUINSTRUCTION m_VuReflV[64]; + VUShared::VUINSTRUCTION m_VuReflVX0[32]; + VUShared::VUINSTRUCTION m_VuReflVX1[32]; + VUShared::VUINSTRUCTION m_VuReflVX2[32]; + VUShared::VUINSTRUCTION m_VuReflVX3[32]; - MIPSReflection::SUBTABLE m_ReflVTable; - MIPSReflection::SUBTABLE m_ReflVX0Table; - MIPSReflection::SUBTABLE m_ReflVX1Table; - MIPSReflection::SUBTABLE m_ReflVX2Table; - MIPSReflection::SUBTABLE m_ReflVX3Table; + MIPSReflection::SUBTABLE m_ReflVTable; + MIPSReflection::SUBTABLE m_ReflVX0Table; + MIPSReflection::SUBTABLE m_ReflVX1Table; + MIPSReflection::SUBTABLE m_ReflVX2Table; + MIPSReflection::SUBTABLE m_ReflVX3Table; - VUShared::VUSUBTABLE m_VuReflVTable; - VUShared::VUSUBTABLE m_VuReflVX0Table; - VUShared::VUSUBTABLE m_VuReflVX1Table; - VUShared::VUSUBTABLE m_VuReflVX2Table; - VUShared::VUSUBTABLE m_VuReflVX3Table; + VUShared::VUSUBTABLE m_VuReflVTable; + VUShared::VUSUBTABLE m_VuReflVX0Table; + VUShared::VUSUBTABLE m_VuReflVX1Table; + VUShared::VUSUBTABLE m_VuReflVX2Table; + VUShared::VUSUBTABLE m_VuReflVX3Table; - static MIPSReflection::INSTRUCTION m_cReflV[64]; - static MIPSReflection::INSTRUCTION m_cReflVX0[32]; - static MIPSReflection::INSTRUCTION m_cReflVX1[32]; - static MIPSReflection::INSTRUCTION m_cReflVX2[32]; - static MIPSReflection::INSTRUCTION m_cReflVX3[32]; + static MIPSReflection::INSTRUCTION m_cReflV[64]; + static MIPSReflection::INSTRUCTION m_cReflVX0[32]; + static MIPSReflection::INSTRUCTION m_cReflVX1[32]; + static MIPSReflection::INSTRUCTION m_cReflVX2[32]; + static MIPSReflection::INSTRUCTION m_cReflVX3[32]; - static VUShared::VUINSTRUCTION m_cVuReflV[64]; - static VUShared::VUINSTRUCTION m_cVuReflVX0[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX1[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX2[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX3[32]; + static VUShared::VUINSTRUCTION m_cVuReflV[64]; + static VUShared::VUINSTRUCTION m_cVuReflVX0[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX1[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX2[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX3[32]; }; class CLower : public CMIPSInstructionFactory { public: - CLower(uint32); + CLower(uint32); - void SetupReflectionTables(); - void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; - void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); - void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); - MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); - uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); - VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); + void SetupReflectionTables(); + void CompileInstruction(uint32, CMipsJitter*, CMIPS*) override; + void GetInstructionMnemonic(CMIPS*, uint32, uint32, char*, unsigned int); + void GetInstructionOperands(CMIPS*, uint32, uint32, char*, unsigned int); + MIPS_BRANCH_TYPE IsInstructionBranch(CMIPS*, uint32, uint32); + uint32 GetInstructionEffectiveAddress(CMIPS*, uint32, uint32); + VUShared::OPERANDSET GetAffectedOperands(CMIPS*, uint32, uint32); - void SetRelativePipeTime(uint32); + void SetRelativePipeTime(uint32); private: enum @@ -191,201 +191,201 @@ private: typedef void (CLower::*InstructionFuncConstant)(); - static InstructionFuncConstant m_pOpGeneral[0x80]; - static InstructionFuncConstant m_pOpLower[0x40]; - static InstructionFuncConstant m_pOpVector0[0x20]; - static InstructionFuncConstant m_pOpVector1[0x20]; - static InstructionFuncConstant m_pOpVector2[0x20]; - static InstructionFuncConstant m_pOpVector3[0x20]; + static InstructionFuncConstant m_pOpGeneral[0x80]; + static InstructionFuncConstant m_pOpLower[0x40]; + static InstructionFuncConstant m_pOpVector0[0x20]; + static InstructionFuncConstant m_pOpVector1[0x20]; + static InstructionFuncConstant m_pOpVector2[0x20]; + static InstructionFuncConstant m_pOpVector3[0x20]; - uint8 m_nIT = 0; - uint8 m_nIS = 0; - uint8 m_nID = 0; - uint8 m_nFSF = 0; - uint8 m_nFTF = 0; - uint8 m_nDest = 0; - uint8 m_nImm5 = 0; - uint16 m_nImm11 = 0; - uint16 m_nImm12 = 0; - uint16 m_nImm15 = 0; - uint16 m_nImm15S = 0; - uint32 m_nImm24 = 0; - uint32 m_relativePipeTime = 0; - uint32 m_vuMemAddressMask; + uint8 m_nIT = 0; + uint8 m_nIS = 0; + uint8 m_nID = 0; + uint8 m_nFSF = 0; + uint8 m_nFTF = 0; + uint8 m_nDest = 0; + uint8 m_nImm5 = 0; + uint16 m_nImm11 = 0; + uint16 m_nImm12 = 0; + uint16 m_nImm15 = 0; + uint16 m_nImm15S = 0; + uint32 m_nImm24 = 0; + uint32 m_relativePipeTime = 0; + uint32 m_vuMemAddressMask; - void SetBranchAddress(bool, int32); - static bool IsLOI(CMIPS*, uint32); + void SetBranchAddress(bool, int32); + static bool IsLOI(CMIPS*, uint32); - static void ReflOpIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpIsOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpImm12(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItImm12(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItIsOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItIsImm15(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpItOfsIsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpImm24(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpVi1Imm24(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFsDstOfsIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFtDstOfsIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFtDstFsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpPFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpPFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static void ReflOpFtP(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpIsOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpImm12(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItImm12(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItIsOfs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItIsImm15(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpItOfsIsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpImm24(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpVi1Imm24(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFsDstOfsIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtDstOfsIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtDstFsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpPFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpPFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + static void ReflOpFtP(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - static uint32 ReflEaIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaOffset(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); + static uint32 ReflEaIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32); - static void ReflOpAffRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffRdItFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffRdItIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffRdP(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrFtRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrFtRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrFtRdP(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrFtIsRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrIdRdItIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrIt(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrItBv(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrItRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrItRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrItBvRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrItRdItFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrPRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - static void ReflOpAffWrVi1Bv(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffRdItFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffRdItIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffRdP(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrFtRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrFtRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrFtRdP(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrFtIsRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrIdRdItIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrIt(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrItBv(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrItRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrItRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrItBvRdIs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrItRdItFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrPRdFs(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); + static void ReflOpAffWrVi1Bv(VUShared::VUINSTRUCTION*, CMIPS*, uint32, uint32, VUShared::OPERANDSET&); - void ApplySumSeries(size_t, const uint32*, const unsigned int*, unsigned int); - void GenerateEATAN(); + void ApplySumSeries(size_t, const uint32*, const unsigned int*, unsigned int); + void GenerateEATAN(); //General - void LQ(); - void SQ(); - void ILW(); - void ISW(); - void IADDIU(); - void ISUBIU(); - void FCEQ(); - void FCSET(); - void FCAND(); - void FCOR(); - void FSSET(); - void FSAND(); - void FSOR(); - void FMEQ(); - void FMAND(); - void FMOR(); - void FCGET(); - void B(); - void BAL(); - void JR(); - void JALR(); - void IBEQ(); - void IBNE(); - void IBLTZ(); - void IBGTZ(); - void IBLEZ(); - void IBGEZ(); - void LOWEROP(); + void LQ(); + void SQ(); + void ILW(); + void ISW(); + void IADDIU(); + void ISUBIU(); + void FCEQ(); + void FCSET(); + void FCAND(); + void FCOR(); + void FSSET(); + void FSAND(); + void FSOR(); + void FMEQ(); + void FMAND(); + void FMOR(); + void FCGET(); + void B(); + void BAL(); + void JR(); + void JALR(); + void IBEQ(); + void IBNE(); + void IBLTZ(); + void IBGTZ(); + void IBLEZ(); + void IBGEZ(); + void LOWEROP(); //LowerOp - void IADD(); - void ISUB(); - void IADDI(); - void IAND(); - void IOR(); - void VECTOR0(); - void VECTOR1(); - void VECTOR2(); - void VECTOR3(); + void IADD(); + void ISUB(); + void IADDI(); + void IAND(); + void IOR(); + void VECTOR0(); + void VECTOR1(); + void VECTOR2(); + void VECTOR3(); //Vector0 - void MOVE(); - void LQI(); - void DIV(); - void MTIR(); - void RNEXT(); - void MFP(); - void XTOP(); - void XGKICK(); - void ESADD(); - void EATANxy(); - void ESQRT(); - void ESIN(); + void MOVE(); + void LQI(); + void DIV(); + void MTIR(); + void RNEXT(); + void MFP(); + void XTOP(); + void XGKICK(); + void ESADD(); + void EATANxy(); + void ESQRT(); + void ESIN(); //Vector1 - void MR32(); - void SQI(); - void SQRT(); - void MFIR(); - void RGET(); - void XITOP(); - void EATANxz(); - void ERSQRT(); + void MR32(); + void SQI(); + void SQRT(); + void MFIR(); + void RGET(); + void XITOP(); + void EATANxz(); + void ERSQRT(); //Vector2 - void LQD(); - void RSQRT(); - void ILWR(); - void RINIT(); - void ELENG(); - void ESUM(); - void ERCPR(); - void EEXP(); + void LQD(); + void RSQRT(); + void ILWR(); + void RINIT(); + void ELENG(); + void ESUM(); + void ERCPR(); + void EEXP(); //Vector3 - void SQD(); - void WAITQ(); - void ISWR(); - void RXOR(); - void ERLENG(); - void WAITP(); + void SQD(); + void WAITQ(); + void ISWR(); + void RXOR(); + void ERLENG(); + void WAITP(); - MIPSReflection::INSTRUCTION m_ReflGeneral[128]; - MIPSReflection::INSTRUCTION m_ReflV[64]; - MIPSReflection::INSTRUCTION m_ReflVX0[32]; - MIPSReflection::INSTRUCTION m_ReflVX1[32]; - MIPSReflection::INSTRUCTION m_ReflVX2[32]; - MIPSReflection::INSTRUCTION m_ReflVX3[32]; + MIPSReflection::INSTRUCTION m_ReflGeneral[128]; + MIPSReflection::INSTRUCTION m_ReflV[64]; + MIPSReflection::INSTRUCTION m_ReflVX0[32]; + MIPSReflection::INSTRUCTION m_ReflVX1[32]; + MIPSReflection::INSTRUCTION m_ReflVX2[32]; + MIPSReflection::INSTRUCTION m_ReflVX3[32]; - VUShared::VUINSTRUCTION m_VuReflGeneral[128]; - VUShared::VUINSTRUCTION m_VuReflV[64]; - VUShared::VUINSTRUCTION m_VuReflVX0[32]; - VUShared::VUINSTRUCTION m_VuReflVX1[32]; - VUShared::VUINSTRUCTION m_VuReflVX2[32]; - VUShared::VUINSTRUCTION m_VuReflVX3[32]; + VUShared::VUINSTRUCTION m_VuReflGeneral[128]; + VUShared::VUINSTRUCTION m_VuReflV[64]; + VUShared::VUINSTRUCTION m_VuReflVX0[32]; + VUShared::VUINSTRUCTION m_VuReflVX1[32]; + VUShared::VUINSTRUCTION m_VuReflVX2[32]; + VUShared::VUINSTRUCTION m_VuReflVX3[32]; - MIPSReflection::SUBTABLE m_ReflGeneralTable; - MIPSReflection::SUBTABLE m_ReflVTable; - MIPSReflection::SUBTABLE m_ReflVX0Table; - MIPSReflection::SUBTABLE m_ReflVX1Table; - MIPSReflection::SUBTABLE m_ReflVX2Table; - MIPSReflection::SUBTABLE m_ReflVX3Table; + MIPSReflection::SUBTABLE m_ReflGeneralTable; + MIPSReflection::SUBTABLE m_ReflVTable; + MIPSReflection::SUBTABLE m_ReflVX0Table; + MIPSReflection::SUBTABLE m_ReflVX1Table; + MIPSReflection::SUBTABLE m_ReflVX2Table; + MIPSReflection::SUBTABLE m_ReflVX3Table; - VUShared::VUSUBTABLE m_VuReflGeneralTable; - VUShared::VUSUBTABLE m_VuReflVTable; - VUShared::VUSUBTABLE m_VuReflVX0Table; - VUShared::VUSUBTABLE m_VuReflVX1Table; - VUShared::VUSUBTABLE m_VuReflVX2Table; - VUShared::VUSUBTABLE m_VuReflVX3Table; + VUShared::VUSUBTABLE m_VuReflGeneralTable; + VUShared::VUSUBTABLE m_VuReflVTable; + VUShared::VUSUBTABLE m_VuReflVX0Table; + VUShared::VUSUBTABLE m_VuReflVX1Table; + VUShared::VUSUBTABLE m_VuReflVX2Table; + VUShared::VUSUBTABLE m_VuReflVX3Table; - static MIPSReflection::INSTRUCTION m_cReflGeneral[128]; - static MIPSReflection::INSTRUCTION m_cReflV[64]; - static MIPSReflection::INSTRUCTION m_cReflVX0[32]; - static MIPSReflection::INSTRUCTION m_cReflVX1[32]; - static MIPSReflection::INSTRUCTION m_cReflVX2[32]; - static MIPSReflection::INSTRUCTION m_cReflVX3[32]; + static MIPSReflection::INSTRUCTION m_cReflGeneral[128]; + static MIPSReflection::INSTRUCTION m_cReflV[64]; + static MIPSReflection::INSTRUCTION m_cReflVX0[32]; + static MIPSReflection::INSTRUCTION m_cReflVX1[32]; + static MIPSReflection::INSTRUCTION m_cReflVX2[32]; + static MIPSReflection::INSTRUCTION m_cReflVX3[32]; - static VUShared::VUINSTRUCTION m_cVuReflGeneral[128]; - static VUShared::VUINSTRUCTION m_cVuReflV[64]; - static VUShared::VUINSTRUCTION m_cVuReflVX0[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX1[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX2[32]; - static VUShared::VUINSTRUCTION m_cVuReflVX3[32]; + static VUShared::VUINSTRUCTION m_cVuReflGeneral[128]; + static VUShared::VUINSTRUCTION m_cVuReflV[64]; + static VUShared::VUINSTRUCTION m_cVuReflVX0[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX1[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX2[32]; + static VUShared::VUINSTRUCTION m_cVuReflVX3[32]; }; - CUpper m_Upper; - CLower m_Lower; + CUpper m_Upper; + CLower m_Lower; }; diff --git a/Source/ee/MA_VU_Lower.cpp b/Source/ee/MA_VU_Lower.cpp index 847ea493d..a9f32b216 100644 --- a/Source/ee/MA_VU_Lower.cpp +++ b/Source/ee/MA_VU_Lower.cpp @@ -7,10 +7,9 @@ #include "offsetof_def.h" CMA_VU::CLower::CLower(uint32 vuMemAddressMask) -: CMIPSInstructionFactory(MIPS_REGSIZE_32) -, m_vuMemAddressMask(vuMemAddressMask) + : CMIPSInstructionFactory(MIPS_REGSIZE_32) + , m_vuMemAddressMask(vuMemAddressMask) { - } void CMA_VU::CLower::CompileInstruction(uint32 address, CMipsJitter* codeGen, CMIPS* context) @@ -22,20 +21,20 @@ void CMA_VU::CLower::CompileInstruction(uint32 address, CMipsJitter* codeGen, CM return; } - m_nDest = (uint8 )((m_nOpcode >> 21) & 0x000F); + m_nDest = (uint8)((m_nOpcode >> 21) & 0x000F); - m_nFSF = ((m_nDest >> 0) & 0x03); - m_nFTF = ((m_nDest >> 2) & 0x03); + m_nFSF = ((m_nDest >> 0) & 0x03); + m_nFTF = ((m_nDest >> 2) & 0x03); - m_nIT = (uint8 )((m_nOpcode >> 16) & 0x001F); - m_nIS = (uint8 )((m_nOpcode >> 11) & 0x001F); - m_nID = (uint8 )((m_nOpcode >> 6) & 0x001F); - m_nImm5 = m_nID; - m_nImm11 = (uint16)((m_nOpcode >> 0) & 0x07FF); - m_nImm12 = (uint16)((m_nOpcode & 0x7FF) | (m_nOpcode & 0x00200000) >> 10); - m_nImm15 = (uint16)((m_nOpcode & 0x7FF) | (m_nOpcode & 0x01E00000) >> 10); - m_nImm15S = m_nImm15 | (m_nImm15 & 0x4000 ? 0x8000 : 0x0000); - m_nImm24 = m_nOpcode & 0x00FFFFFF; + m_nIT = (uint8)((m_nOpcode >> 16) & 0x001F); + m_nIS = (uint8)((m_nOpcode >> 11) & 0x001F); + m_nID = (uint8)((m_nOpcode >> 6) & 0x001F); + m_nImm5 = m_nID; + m_nImm11 = (uint16)((m_nOpcode >> 0) & 0x07FF); + m_nImm12 = (uint16)((m_nOpcode & 0x7FF) | (m_nOpcode & 0x00200000) >> 10); + m_nImm15 = (uint16)((m_nOpcode & 0x7FF) | (m_nOpcode & 0x01E00000) >> 10); + m_nImm15S = m_nImm15 | (m_nImm15 & 0x4000 ? 0x8000 : 0x0000); + m_nImm24 = m_nOpcode & 0x00FFFFFF; if(m_nOpcode != OPCODE_NOP) { @@ -102,30 +101,29 @@ void CMA_VU::CLower::GenerateEATAN() static const uint32 pi4 = 0x3F490FDB; const unsigned int seriesLength = 8; static const uint32 seriesConstants[seriesLength] = - { - 0x3F7FFFF5, - 0xBEAAA61C, - 0x3E4C40A6, - 0xBE0E6C63, - 0x3DC577DF, - 0xBD6501C4, - 0x3CB31652, - 0xBB84D7E7, - }; + { + 0x3F7FFFF5, + 0xBEAAA61C, + 0x3E4C40A6, + 0xBE0E6C63, + 0x3DC577DF, + 0xBD6501C4, + 0x3CB31652, + 0xBB84D7E7, + }; static const unsigned int seriesExponents[seriesLength] = - { - 1, - 3, - 5, - 7, - 9, - 11, - 13, - 15 - }; + { + 1, + 3, + 5, + 7, + 9, + 11, + 13, + 15}; ApplySumSeries(offsetof(CMIPS, m_State.nCOP2T), - seriesConstants, seriesExponents, seriesLength); + seriesConstants, seriesExponents, seriesLength); { float constant = *reinterpret_cast(&pi4); @@ -147,11 +145,11 @@ void CMA_VU::CLower::LQ() m_codeGen->PushRelRef(offsetof(CMIPS, m_vuMem)); VUShared::ComputeMemAccessAddr( - m_codeGen, - m_nIS, - static_cast(VUShared::GetImm11Offset(m_nImm11)), - 0, - m_vuMemAddressMask); + m_codeGen, + m_nIS, + static_cast(VUShared::GetImm11Offset(m_nImm11)), + 0, + m_vuMemAddressMask); m_codeGen->AddRef(); VUShared::LQbase(m_codeGen, m_nDest, m_nIT); @@ -164,11 +162,11 @@ void CMA_VU::CLower::SQ() //Compute address VUShared::ComputeMemAccessAddr( - m_codeGen, - m_nIT, - static_cast(VUShared::GetImm11Offset(m_nImm11)), - 0, - m_vuMemAddressMask); + m_codeGen, + m_nIT, + static_cast(VUShared::GetImm11Offset(m_nImm11)), + 0, + m_vuMemAddressMask); m_codeGen->AddRef(); @@ -182,11 +180,11 @@ void CMA_VU::CLower::ILW() //Compute address VUShared::ComputeMemAccessAddr( - m_codeGen, - m_nIS, - static_cast(VUShared::GetImm11Offset(m_nImm11)), - VUShared::GetDestOffset(m_nDest), - m_vuMemAddressMask); + m_codeGen, + m_nIS, + static_cast(VUShared::GetImm11Offset(m_nImm11)), + VUShared::GetDestOffset(m_nDest), + m_vuMemAddressMask); m_codeGen->AddRef(); @@ -203,11 +201,11 @@ void CMA_VU::CLower::ISW() //Compute address VUShared::ComputeMemAccessAddr( - m_codeGen, - m_nIS, - static_cast(VUShared::GetImm11Offset(m_nImm11)), - 0, - m_vuMemAddressMask); + m_codeGen, + m_nIS, + static_cast(VUShared::GetImm11Offset(m_nImm11)), + 0, + m_vuMemAddressMask); VUShared::ISWbase(m_codeGen, m_nDest); } @@ -713,24 +711,22 @@ void CMA_VU::CLower::ESIN() { static const unsigned int seriesLength = 5; static const uint32 seriesConstants[seriesLength] = - { - 0x3F800000, - 0xBE2AAAA4, - 0x3C08873E, - 0xB94FB21F, - 0x362E9C14 - }; + { + 0x3F800000, + 0xBE2AAAA4, + 0x3C08873E, + 0xB94FB21F, + 0x362E9C14}; static const unsigned int seriesExponents[seriesLength] = - { - 1, - 3, - 5, - 7, - 9 - }; + { + 1, + 3, + 5, + 7, + 9}; ApplySumSeries(offsetof(CMIPS, m_State.nCOP2[m_nIS].nV[m_nFSF]), - seriesConstants, seriesExponents, seriesLength); + seriesConstants, seriesExponents, seriesLength); m_codeGen->FP_PullSingle(offsetof(CMIPS, m_State.nCOP2P)); } @@ -896,26 +892,24 @@ void CMA_VU::CLower::EEXP() { const unsigned int seriesLength = 6; static const uint32 seriesConstants[seriesLength] = - { - 0x3E7FFFA8, - 0x3D0007F4, - 0x3B29D3FF, - 0x3933E553, - 0x36B63510, - 0x353961AC - }; + { + 0x3E7FFFA8, + 0x3D0007F4, + 0x3B29D3FF, + 0x3933E553, + 0x36B63510, + 0x353961AC}; static const unsigned int seriesExponents[seriesLength] = - { - 1, - 2, - 3, - 4, - 5, - 6 - }; + { + 1, + 2, + 3, + 4, + 5, + 6}; ApplySumSeries(offsetof(CMIPS, m_State.nCOP2[m_nIS].nV[m_nFSF]), - seriesConstants, seriesExponents, seriesLength); + seriesConstants, seriesExponents, seriesLength); m_codeGen->FP_PushCst(1.0f); m_codeGen->FP_Add(); diff --git a/Source/ee/MA_VU_LowerReflection.cpp b/Source/ee/MA_VU_LowerReflection.cpp index 9d0583b66..410a9c049 100644 --- a/Source/ee/MA_VU_LowerReflection.cpp +++ b/Source/ee/MA_VU_LowerReflection.cpp @@ -16,8 +16,8 @@ void CMA_VU::CLower::ReflOpIs(INSTRUCTION* instr, CMIPS* context, uint32 address void CMA_VU::CLower::ReflOpIsOfs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 is = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 is = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); address += 8; @@ -33,30 +33,30 @@ void CMA_VU::CLower::ReflOpIt(INSTRUCTION* instr, CMIPS* context, uint32 address void CMA_VU::CLower::ReflOpImm12(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x00200000) >> 10); + uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x00200000) >> 10); sprintf(text, "0x%03X", imm); } void CMA_VU::CLower::ReflOpItImm12(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 it = static_cast((opcode >> 16) & 0x001F); - uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x00200000) >> 10); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x00200000) >> 10); sprintf(text, "VI%i, 0x%03X", it, imm); } void CMA_VU::CLower::ReflOpItIs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 it = static_cast((opcode >> 16) & 0x001F); - uint8 is = static_cast((opcode >> 11) & 0x001F); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); sprintf(text, "VI%i, VI%i", it, is); } void CMA_VU::CLower::ReflOpOfs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); address += 8; @@ -65,8 +65,8 @@ void CMA_VU::CLower::ReflOpOfs(INSTRUCTION* instr, CMIPS* context, uint32 addres void CMA_VU::CLower::ReflOpItOfs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint16 imm = static_cast((opcode >> 0) & 0x07FF); - uint8 it = static_cast ((opcode >> 16) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 it = static_cast((opcode >> 16) & 0x001F); address += 8; @@ -75,9 +75,9 @@ void CMA_VU::CLower::ReflOpItOfs(INSTRUCTION* instr, CMIPS* context, uint32 addr void CMA_VU::CLower::ReflOpItIsOfs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 it = static_cast ((opcode >> 16) & 0x001F); - uint8 is = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); address += 8; @@ -86,19 +86,19 @@ void CMA_VU::CLower::ReflOpItIsOfs(INSTRUCTION* instr, CMIPS* context, uint32 ad void CMA_VU::CLower::ReflOpItIsImm15(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 it = static_cast ((opcode >> 16) & 0x001F); - uint8 is = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x01E00000) >> 10); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode & 0x7FF) | (opcode & 0x01E00000) >> 10); sprintf(text, "VI%i, VI%i, $%04X", it, is, imm); } void CMA_VU::CLower::ReflOpItOfsIsDst(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast ((opcode >> 21) & 0x000F); - uint8 it = static_cast ((opcode >> 16) & 0x001F); - uint8 is = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); if(imm & 0x400) imm |= 0xF800; sprintf(text, "VI%i, $%04X(VI%i)%s", it, imm, is, m_sDestination[dest]); @@ -120,10 +120,10 @@ void CMA_VU::CLower::ReflOpVi1Imm24(INSTRUCTION* instr, CMIPS* context, uint32 a void CMA_VU::CLower::ReflOpFsDstOfsIt(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast ((opcode >> 21) & 0x000F); - uint8 it = static_cast ((opcode >> 16) & 0x001F); - uint8 fs = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 fs = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); if(imm & 0x400) imm |= 0xF800; sprintf(text, "VF%i%s, $%04X(VI%i)", fs, m_sDestination[dest], imm, it); @@ -131,10 +131,10 @@ void CMA_VU::CLower::ReflOpFsDstOfsIt(INSTRUCTION* instr, CMIPS* context, uint32 void CMA_VU::CLower::ReflOpFtDstOfsIs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast ((opcode >> 21) & 0x000F); - uint8 ft = static_cast ((opcode >> 16) & 0x001F); - uint8 is = static_cast ((opcode >> 11) & 0x001F); - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 ft = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); if(imm & 0x400) imm |= 0xF800; sprintf(text, "VF%i%s, $%04X(VI%i)", ft, m_sDestination[dest], imm, is); @@ -142,39 +142,39 @@ void CMA_VU::CLower::ReflOpFtDstOfsIs(INSTRUCTION* instr, CMIPS* context, uint32 void CMA_VU::CLower::ReflOpFtDstFsDst(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast((opcode >> 21) & 0x000F); - uint8 ft = static_cast((opcode >> 16) & 0x001F); - uint8 fs = static_cast((opcode >> 11) & 0x001F); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 ft = static_cast((opcode >> 16) & 0x001F); + uint8 fs = static_cast((opcode >> 11) & 0x001F); sprintf(text, "VF%i%s, VF%i%s", ft, m_sDestination[dest], fs, m_sDestination[dest]); } void CMA_VU::CLower::ReflOpPFs(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 fs = static_cast((opcode >> 11) & 0x001F); + uint8 fs = static_cast((opcode >> 11) & 0x001F); sprintf(text, "P, VF%i", fs); } void CMA_VU::CLower::ReflOpPFsf(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 fs = static_cast((opcode >> 11) & 0x001F); - uint8 fsf = static_cast((opcode >> 21) & 0x0003); + uint8 fs = static_cast((opcode >> 11) & 0x001F); + uint8 fsf = static_cast((opcode >> 21) & 0x0003); sprintf(text, "P, VF%i%s", fs, m_sBroadcast[fsf]); } void CMA_VU::CLower::ReflOpFtP(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast((opcode >> 21) & 0x000F); - uint8 ft = static_cast((opcode >> 16) & 0x001F); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 ft = static_cast((opcode >> 16) & 0x001F); sprintf(text, "VF%i%s, P", ft, m_sDestination[dest]); } uint32 CMA_VU::CLower::ReflEaOffset(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode) { - uint16 imm = static_cast((opcode >> 0) & 0x07FF); + uint16 imm = static_cast((opcode >> 0) & 0x07FF); address += 8; return (address + GetBranch(imm)); @@ -261,7 +261,7 @@ void CMA_VU::CLower::ReflOpAffWrIdRdItIs(VUINSTRUCTION*, CMIPS*, uint32, uint32 { auto it = static_cast((opcode >> 16) & 0x001F); auto is = static_cast((opcode >> 11) & 0x001F); - auto id = static_cast((opcode >> 6) & 0x001F); + auto id = static_cast((opcode >> 6) & 0x001F); operandSet.readI0 = it; operandSet.readI1 = is; @@ -1107,105 +1107,105 @@ VUINSTRUCTION CMA_VU::CLower::m_cVuReflVX3[32] = void CMA_VU::CLower::SetupReflectionTables() { - static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); + static_assert(sizeof(m_ReflGeneral) == sizeof(m_cReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); - static_assert(sizeof(m_VuReflGeneral) == sizeof(m_cVuReflGeneral), "Array sizes don't match"); - static_assert(sizeof(m_VuReflV) == sizeof(m_cVuReflV), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX0) == sizeof(m_cVuReflVX0), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX1) == sizeof(m_cVuReflVX1), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX2) == sizeof(m_cVuReflVX2), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX3) == sizeof(m_cVuReflVX3), "Array sizes don't match"); + static_assert(sizeof(m_VuReflGeneral) == sizeof(m_cVuReflGeneral), "Array sizes don't match"); + static_assert(sizeof(m_VuReflV) == sizeof(m_cVuReflV), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX0) == sizeof(m_cVuReflVX0), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX1) == sizeof(m_cVuReflVX1), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX2) == sizeof(m_cVuReflVX2), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX3) == sizeof(m_cVuReflVX3), "Array sizes don't match"); - VerifyVuReflectionTable(m_cReflGeneral, m_cVuReflGeneral, sizeof(m_cReflGeneral) / sizeof(m_cReflGeneral[0])); - VerifyVuReflectionTable(m_cReflV, m_cVuReflV, sizeof(m_cReflV) / sizeof(m_cReflV[0])); - VerifyVuReflectionTable(m_cReflVX0, m_cVuReflVX0, sizeof(m_cReflVX0) / sizeof(m_cReflVX0[0])); - VerifyVuReflectionTable(m_cReflVX1, m_cVuReflVX1, sizeof(m_cReflVX1) / sizeof(m_cReflVX1[0])); - VerifyVuReflectionTable(m_cReflVX2, m_cVuReflVX2, sizeof(m_cReflVX2) / sizeof(m_cReflVX2[0])); - VerifyVuReflectionTable(m_cReflVX3, m_cVuReflVX3, sizeof(m_cReflVX3) / sizeof(m_cReflVX3[0])); + VerifyVuReflectionTable(m_cReflGeneral, m_cVuReflGeneral, sizeof(m_cReflGeneral) / sizeof(m_cReflGeneral[0])); + VerifyVuReflectionTable(m_cReflV, m_cVuReflV, sizeof(m_cReflV) / sizeof(m_cReflV[0])); + VerifyVuReflectionTable(m_cReflVX0, m_cVuReflVX0, sizeof(m_cReflVX0) / sizeof(m_cReflVX0[0])); + VerifyVuReflectionTable(m_cReflVX1, m_cVuReflVX1, sizeof(m_cReflVX1) / sizeof(m_cReflVX1[0])); + VerifyVuReflectionTable(m_cReflVX2, m_cVuReflVX2, sizeof(m_cReflVX2) / sizeof(m_cReflVX2[0])); + VerifyVuReflectionTable(m_cReflVX3, m_cVuReflVX3, sizeof(m_cReflVX3) / sizeof(m_cReflVX3[0])); - memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); - memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); - memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); - memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); - memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); - memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); + memcpy(m_ReflGeneral, m_cReflGeneral, sizeof(m_cReflGeneral)); + memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); + memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); + memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); + memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); + memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); - memcpy(m_VuReflGeneral, m_cVuReflGeneral, sizeof(m_cVuReflGeneral)); - memcpy(m_VuReflV, m_cVuReflV, sizeof(m_cVuReflV)); - memcpy(m_VuReflVX0, m_cVuReflVX0, sizeof(m_cVuReflVX0)); - memcpy(m_VuReflVX1, m_cVuReflVX1, sizeof(m_cVuReflVX1)); - memcpy(m_VuReflVX2, m_cVuReflVX2, sizeof(m_cVuReflVX2)); - memcpy(m_VuReflVX3, m_cVuReflVX3, sizeof(m_cVuReflVX3)); + memcpy(m_VuReflGeneral, m_cVuReflGeneral, sizeof(m_cVuReflGeneral)); + memcpy(m_VuReflV, m_cVuReflV, sizeof(m_cVuReflV)); + memcpy(m_VuReflVX0, m_cVuReflVX0, sizeof(m_cVuReflVX0)); + memcpy(m_VuReflVX1, m_cVuReflVX1, sizeof(m_cVuReflVX1)); + memcpy(m_VuReflVX2, m_cVuReflVX2, sizeof(m_cVuReflVX2)); + memcpy(m_VuReflVX3, m_cVuReflVX3, sizeof(m_cVuReflVX3)); { - m_ReflGeneralTable.nShift = 25; - m_ReflGeneralTable.nMask = 0x7F; - m_ReflGeneralTable.pTable = m_ReflGeneral; + m_ReflGeneralTable.nShift = 25; + m_ReflGeneralTable.nMask = 0x7F; + m_ReflGeneralTable.pTable = m_ReflGeneral; - m_ReflVTable.nShift = 0; - m_ReflVTable.nMask = 0x3F; - m_ReflVTable.pTable = m_ReflV; + m_ReflVTable.nShift = 0; + m_ReflVTable.nMask = 0x3F; + m_ReflVTable.pTable = m_ReflV; - m_ReflVX0Table.nShift = 6; - m_ReflVX0Table.nMask = 0x1F; - m_ReflVX0Table.pTable = m_ReflVX0; + m_ReflVX0Table.nShift = 6; + m_ReflVX0Table.nMask = 0x1F; + m_ReflVX0Table.pTable = m_ReflVX0; - m_ReflVX1Table.nShift = 6; - m_ReflVX1Table.nMask = 0x1F; - m_ReflVX1Table.pTable = m_ReflVX1; + m_ReflVX1Table.nShift = 6; + m_ReflVX1Table.nMask = 0x1F; + m_ReflVX1Table.pTable = m_ReflVX1; - m_ReflVX2Table.nShift = 6; - m_ReflVX2Table.nMask = 0x1F; - m_ReflVX2Table.pTable = m_ReflVX2; + m_ReflVX2Table.nShift = 6; + m_ReflVX2Table.nMask = 0x1F; + m_ReflVX2Table.pTable = m_ReflVX2; - m_ReflVX3Table.nShift = 6; - m_ReflVX3Table.nMask = 0x1F; - m_ReflVX3Table.pTable = m_ReflVX3; + m_ReflVX3Table.nShift = 6; + m_ReflVX3Table.nMask = 0x1F; + m_ReflVX3Table.pTable = m_ReflVX3; - m_ReflGeneral[0x40].pSubTable = &m_ReflVTable; + m_ReflGeneral[0x40].pSubTable = &m_ReflVTable; - m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; - m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; - m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; - m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; + m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; + m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; + m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; + m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; } { - m_VuReflGeneralTable.nShift = 25; - m_VuReflGeneralTable.nMask = 0x7F; - m_VuReflGeneralTable.pTable = m_VuReflGeneral; + m_VuReflGeneralTable.nShift = 25; + m_VuReflGeneralTable.nMask = 0x7F; + m_VuReflGeneralTable.pTable = m_VuReflGeneral; - m_VuReflVTable.nShift = 0; - m_VuReflVTable.nMask = 0x3F; - m_VuReflVTable.pTable = m_VuReflV; + m_VuReflVTable.nShift = 0; + m_VuReflVTable.nMask = 0x3F; + m_VuReflVTable.pTable = m_VuReflV; - m_VuReflVX0Table.nShift = 6; - m_VuReflVX0Table.nMask = 0x1F; - m_VuReflVX0Table.pTable = m_VuReflVX0; + m_VuReflVX0Table.nShift = 6; + m_VuReflVX0Table.nMask = 0x1F; + m_VuReflVX0Table.pTable = m_VuReflVX0; - m_VuReflVX1Table.nShift = 6; - m_VuReflVX1Table.nMask = 0x1F; - m_VuReflVX1Table.pTable = m_VuReflVX1; + m_VuReflVX1Table.nShift = 6; + m_VuReflVX1Table.nMask = 0x1F; + m_VuReflVX1Table.pTable = m_VuReflVX1; - m_VuReflVX2Table.nShift = 6; - m_VuReflVX2Table.nMask = 0x1F; - m_VuReflVX2Table.pTable = m_VuReflVX2; + m_VuReflVX2Table.nShift = 6; + m_VuReflVX2Table.nMask = 0x1F; + m_VuReflVX2Table.pTable = m_VuReflVX2; - m_VuReflVX3Table.nShift = 6; - m_VuReflVX3Table.nMask = 0x1F; - m_VuReflVX3Table.pTable = m_VuReflVX3; + m_VuReflVX3Table.nShift = 6; + m_VuReflVX3Table.nMask = 0x1F; + m_VuReflVX3Table.pTable = m_VuReflVX3; - m_VuReflGeneral[0x40].subTable = &m_VuReflVTable; + m_VuReflGeneral[0x40].subTable = &m_VuReflVTable; - m_VuReflV[0x3C].subTable = &m_VuReflVX0Table; - m_VuReflV[0x3D].subTable = &m_VuReflVX1Table; - m_VuReflV[0x3E].subTable = &m_VuReflVX2Table; - m_VuReflV[0x3F].subTable = &m_VuReflVX3Table; + m_VuReflV[0x3C].subTable = &m_VuReflVX0Table; + m_VuReflV[0x3D].subTable = &m_VuReflVX1Table; + m_VuReflV[0x3E].subTable = &m_VuReflVX2Table; + m_VuReflV[0x3F].subTable = &m_VuReflVX3Table; } } @@ -1224,8 +1224,8 @@ void CMA_VU::CLower::GetInstructionMnemonic(CMIPS* context, uint32 address, uint } INSTRUCTION instr; - instr.pGetMnemonic = SubTableMnemonic; - instr.pSubTable = &m_ReflGeneralTable; + instr.pGetMnemonic = SubTableMnemonic; + instr.pSubTable = &m_ReflGeneralTable; instr.pGetMnemonic(&instr, context, opcode, text, count); } @@ -1244,8 +1244,8 @@ void CMA_VU::CLower::GetInstructionOperands(CMIPS* context, uint32 address, uint } INSTRUCTION instr; - instr.pGetOperands = SubTableOperands; - instr.pSubTable = &m_ReflGeneralTable; + instr.pGetOperands = SubTableOperands; + instr.pSubTable = &m_ReflGeneralTable; instr.pGetOperands(&instr, context, address, opcode, text, count); } @@ -1262,8 +1262,8 @@ MIPS_BRANCH_TYPE CMA_VU::CLower::IsInstructionBranch(CMIPS* context, uint32 addr } INSTRUCTION instr; - instr.pIsBranch = SubTableIsBranch; - instr.pSubTable = &m_ReflGeneralTable; + instr.pIsBranch = SubTableIsBranch; + instr.pSubTable = &m_ReflGeneralTable; return instr.pIsBranch(&instr, context, opcode); } @@ -1280,8 +1280,8 @@ uint32 CMA_VU::CLower::GetInstructionEffectiveAddress(CMIPS* context, uint32 add } INSTRUCTION instr; - instr.pGetEffectiveAddress = SubTableEffAddr; - instr.pSubTable = &m_ReflGeneralTable; + instr.pGetEffectiveAddress = SubTableEffAddr; + instr.pSubTable = &m_ReflGeneralTable; return instr.pGetEffectiveAddress(&instr, context, address, opcode); } @@ -1301,8 +1301,8 @@ VUShared::OPERANDSET CMA_VU::CLower::GetAffectedOperands(CMIPS* context, uint32 } VUINSTRUCTION instr; - instr.pGetAffectedOperands = SubTableAffectedOperands; - instr.subTable = &m_VuReflGeneralTable; + instr.pGetAffectedOperands = SubTableAffectedOperands; + instr.subTable = &m_VuReflGeneralTable; instr.pGetAffectedOperands(&instr, context, address, opcode, result); return result; } diff --git a/Source/ee/MA_VU_Upper.cpp b/Source/ee/MA_VU_Upper.cpp index 1a1a42b54..fcfebe0d5 100644 --- a/Source/ee/MA_VU_Upper.cpp +++ b/Source/ee/MA_VU_Upper.cpp @@ -5,28 +5,27 @@ #undef MAX -CMA_VU::CUpper::CUpper() -: CMIPSInstructionFactory(MIPS_REGSIZE_32) -, m_nFT(0) -, m_nFS(0) -, m_nFD(0) -, m_nBc(0) -, m_nDest(0) -, m_relativePipeTime(0) +CMA_VU::CUpper::CUpper() + : CMIPSInstructionFactory(MIPS_REGSIZE_32) + , m_nFT(0) + , m_nFS(0) + , m_nFD(0) + , m_nBc(0) + , m_nDest(0) + , m_relativePipeTime(0) { - } void CMA_VU::CUpper::CompileInstruction(uint32 nAddress, CMipsJitter* codeGen, CMIPS* pCtx) { SetupQuickVariables(nAddress, codeGen, pCtx); - m_nDest = (uint8 )((m_nOpcode >> 21) & 0x000F); - m_nFT = (uint8 )((m_nOpcode >> 16) & 0x001F); - m_nFS = (uint8 )((m_nOpcode >> 11) & 0x001F); - m_nFD = (uint8 )((m_nOpcode >> 6) & 0x001F); + m_nDest = (uint8)((m_nOpcode >> 21) & 0x000F); + m_nFT = (uint8)((m_nOpcode >> 16) & 0x001F); + m_nFS = (uint8)((m_nOpcode >> 11) & 0x001F); + m_nFD = (uint8)((m_nOpcode >> 6) & 0x001F); - m_nBc = (uint8 )((m_nOpcode >> 0) & 0x0003); + m_nBc = (uint8)((m_nOpcode >> 0) & 0x0003); ((this)->*(m_pOpVector[m_nOpcode & 0x3F]))(); @@ -461,7 +460,6 @@ void CMA_VU::CUpper::MSUBAi() //0B void CMA_VU::CUpper::NOP() { - } ////////////////////////////////////////////////// diff --git a/Source/ee/MA_VU_UpperReflection.cpp b/Source/ee/MA_VU_UpperReflection.cpp index 31043db99..bbf4a66e0 100644 --- a/Source/ee/MA_VU_UpperReflection.cpp +++ b/Source/ee/MA_VU_UpperReflection.cpp @@ -8,9 +8,9 @@ using namespace VUShared; void CMA_VU::CUpper::ReflOpFtFs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s", nFT, m_sDestination[nDest], nFS, m_sDestination[nDest]); } @@ -491,122 +491,122 @@ VUINSTRUCTION CMA_VU::CUpper::m_cVuReflVX3[32] = void CMA_VU::CUpper::SetupReflectionTables() { - static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); - static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); + static_assert(sizeof(m_ReflV) == sizeof(m_cReflV), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX0) == sizeof(m_cReflVX0), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX1) == sizeof(m_cReflVX1), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX2) == sizeof(m_cReflVX2), "Array sizes don't match"); + static_assert(sizeof(m_ReflVX3) == sizeof(m_cReflVX3), "Array sizes don't match"); - static_assert(sizeof(m_VuReflV) == sizeof(m_cVuReflV), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX0) == sizeof(m_cVuReflVX0), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX1) == sizeof(m_cVuReflVX1), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX2) == sizeof(m_cVuReflVX2), "Array sizes don't match"); - static_assert(sizeof(m_VuReflVX3) == sizeof(m_cVuReflVX3), "Array sizes don't match"); + static_assert(sizeof(m_VuReflV) == sizeof(m_cVuReflV), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX0) == sizeof(m_cVuReflVX0), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX1) == sizeof(m_cVuReflVX1), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX2) == sizeof(m_cVuReflVX2), "Array sizes don't match"); + static_assert(sizeof(m_VuReflVX3) == sizeof(m_cVuReflVX3), "Array sizes don't match"); - VerifyVuReflectionTable(m_cReflV, m_cVuReflV, sizeof(m_cReflV) / sizeof(m_cReflV[0])); - VerifyVuReflectionTable(m_cReflVX0, m_cVuReflVX0, sizeof(m_cReflVX0) / sizeof(m_cReflVX0[0])); - VerifyVuReflectionTable(m_cReflVX1, m_cVuReflVX1, sizeof(m_cReflVX1) / sizeof(m_cReflVX1[0])); - VerifyVuReflectionTable(m_cReflVX2, m_cVuReflVX2, sizeof(m_cReflVX2) / sizeof(m_cReflVX2[0])); - VerifyVuReflectionTable(m_cReflVX3, m_cVuReflVX3, sizeof(m_cReflVX3) / sizeof(m_cReflVX3[0])); + VerifyVuReflectionTable(m_cReflV, m_cVuReflV, sizeof(m_cReflV) / sizeof(m_cReflV[0])); + VerifyVuReflectionTable(m_cReflVX0, m_cVuReflVX0, sizeof(m_cReflVX0) / sizeof(m_cReflVX0[0])); + VerifyVuReflectionTable(m_cReflVX1, m_cVuReflVX1, sizeof(m_cReflVX1) / sizeof(m_cReflVX1[0])); + VerifyVuReflectionTable(m_cReflVX2, m_cVuReflVX2, sizeof(m_cReflVX2) / sizeof(m_cReflVX2[0])); + VerifyVuReflectionTable(m_cReflVX3, m_cVuReflVX3, sizeof(m_cReflVX3) / sizeof(m_cReflVX3[0])); - memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); - memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); - memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); - memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); - memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); + memcpy(m_ReflV, m_cReflV, sizeof(m_cReflV)); + memcpy(m_ReflVX0, m_cReflVX0, sizeof(m_cReflVX0)); + memcpy(m_ReflVX1, m_cReflVX1, sizeof(m_cReflVX1)); + memcpy(m_ReflVX2, m_cReflVX2, sizeof(m_cReflVX2)); + memcpy(m_ReflVX3, m_cReflVX3, sizeof(m_cReflVX3)); - memcpy(m_VuReflV, m_cVuReflV, sizeof(m_cVuReflV)); - memcpy(m_VuReflVX0, m_cVuReflVX0, sizeof(m_cVuReflVX0)); - memcpy(m_VuReflVX1, m_cVuReflVX1, sizeof(m_cVuReflVX1)); - memcpy(m_VuReflVX2, m_cVuReflVX2, sizeof(m_cVuReflVX2)); - memcpy(m_VuReflVX3, m_cVuReflVX3, sizeof(m_cVuReflVX3)); + memcpy(m_VuReflV, m_cVuReflV, sizeof(m_cVuReflV)); + memcpy(m_VuReflVX0, m_cVuReflVX0, sizeof(m_cVuReflVX0)); + memcpy(m_VuReflVX1, m_cVuReflVX1, sizeof(m_cVuReflVX1)); + memcpy(m_VuReflVX2, m_cVuReflVX2, sizeof(m_cVuReflVX2)); + memcpy(m_VuReflVX3, m_cVuReflVX3, sizeof(m_cVuReflVX3)); //Standard Tables { - m_ReflVTable.nShift = 0; - m_ReflVTable.nMask = 0x3F; - m_ReflVTable.pTable = m_ReflV; + m_ReflVTable.nShift = 0; + m_ReflVTable.nMask = 0x3F; + m_ReflVTable.pTable = m_ReflV; - m_ReflVX0Table.nShift = 6; - m_ReflVX0Table.nMask = 0x1F; - m_ReflVX0Table.pTable = m_ReflVX0; + m_ReflVX0Table.nShift = 6; + m_ReflVX0Table.nMask = 0x1F; + m_ReflVX0Table.pTable = m_ReflVX0; - m_ReflVX1Table.nShift = 6; - m_ReflVX1Table.nMask = 0x1F; - m_ReflVX1Table.pTable = m_ReflVX1; + m_ReflVX1Table.nShift = 6; + m_ReflVX1Table.nMask = 0x1F; + m_ReflVX1Table.pTable = m_ReflVX1; - m_ReflVX2Table.nShift = 6; - m_ReflVX2Table.nMask = 0x1F; - m_ReflVX2Table.pTable = m_ReflVX2; + m_ReflVX2Table.nShift = 6; + m_ReflVX2Table.nMask = 0x1F; + m_ReflVX2Table.pTable = m_ReflVX2; - m_ReflVX3Table.nShift = 6; - m_ReflVX3Table.nMask = 0x1F; - m_ReflVX3Table.pTable = m_ReflVX3; + m_ReflVX3Table.nShift = 6; + m_ReflVX3Table.nMask = 0x1F; + m_ReflVX3Table.pTable = m_ReflVX3; - m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; - m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; - m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; - m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; + m_ReflV[0x3C].pSubTable = &m_ReflVX0Table; + m_ReflV[0x3D].pSubTable = &m_ReflVX1Table; + m_ReflV[0x3E].pSubTable = &m_ReflVX2Table; + m_ReflV[0x3F].pSubTable = &m_ReflVX3Table; } //VU extended tables { - m_VuReflVTable.nShift = 0; - m_VuReflVTable.nMask = 0x3F; - m_VuReflVTable.pTable = m_VuReflV; + m_VuReflVTable.nShift = 0; + m_VuReflVTable.nMask = 0x3F; + m_VuReflVTable.pTable = m_VuReflV; - m_VuReflVX0Table.nShift = 6; - m_VuReflVX0Table.nMask = 0x1F; - m_VuReflVX0Table.pTable = m_VuReflVX0; + m_VuReflVX0Table.nShift = 6; + m_VuReflVX0Table.nMask = 0x1F; + m_VuReflVX0Table.pTable = m_VuReflVX0; - m_VuReflVX1Table.nShift = 6; - m_VuReflVX1Table.nMask = 0x1F; - m_VuReflVX1Table.pTable = m_VuReflVX1; + m_VuReflVX1Table.nShift = 6; + m_VuReflVX1Table.nMask = 0x1F; + m_VuReflVX1Table.pTable = m_VuReflVX1; - m_VuReflVX2Table.nShift = 6; - m_VuReflVX2Table.nMask = 0x1F; - m_VuReflVX2Table.pTable = m_VuReflVX2; + m_VuReflVX2Table.nShift = 6; + m_VuReflVX2Table.nMask = 0x1F; + m_VuReflVX2Table.pTable = m_VuReflVX2; - m_VuReflVX3Table.nShift = 6; - m_VuReflVX3Table.nMask = 0x1F; - m_VuReflVX3Table.pTable = m_VuReflVX3; + m_VuReflVX3Table.nShift = 6; + m_VuReflVX3Table.nMask = 0x1F; + m_VuReflVX3Table.pTable = m_VuReflVX3; - m_VuReflV[0x3C].subTable = &m_VuReflVX0Table; - m_VuReflV[0x3D].subTable = &m_VuReflVX1Table; - m_VuReflV[0x3E].subTable = &m_VuReflVX2Table; - m_VuReflV[0x3F].subTable = &m_VuReflVX3Table; + m_VuReflV[0x3C].subTable = &m_VuReflVX0Table; + m_VuReflV[0x3D].subTable = &m_VuReflVX1Table; + m_VuReflV[0x3E].subTable = &m_VuReflVX2Table; + m_VuReflV[0x3F].subTable = &m_VuReflVX3Table; } } void CMA_VU::CUpper::GetInstructionMnemonic(CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { INSTRUCTION Instr; - Instr.pGetMnemonic = SubTableMnemonic; - Instr.pSubTable = &m_ReflVTable; + Instr.pGetMnemonic = SubTableMnemonic; + Instr.pSubTable = &m_ReflVTable; Instr.pGetMnemonic(&Instr, pCtx, nOpcode, sText, nCount); } void CMA_VU::CUpper::GetInstructionOperands(CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { INSTRUCTION Instr; - Instr.pGetOperands = SubTableOperands; - Instr.pSubTable = &m_ReflVTable; + Instr.pGetOperands = SubTableOperands; + Instr.pSubTable = &m_ReflVTable; Instr.pGetOperands(&Instr, pCtx, nAddress, nOpcode, sText, nCount); } MIPS_BRANCH_TYPE CMA_VU::CUpper::IsInstructionBranch(CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { INSTRUCTION Instr; - Instr.pIsBranch = SubTableIsBranch; - Instr.pSubTable = &m_ReflVTable; + Instr.pIsBranch = SubTableIsBranch; + Instr.pSubTable = &m_ReflVTable; return Instr.pIsBranch(&Instr, pCtx, nOpcode); } uint32 CMA_VU::CUpper::GetInstructionEffectiveAddress(CMIPS* pCtx, uint32 nAddress, uint32 nOpcode) { INSTRUCTION Instr; - Instr.pGetEffectiveAddress = SubTableEffAddr; - Instr.pSubTable = &m_ReflVTable; + Instr.pGetEffectiveAddress = SubTableEffAddr; + Instr.pSubTable = &m_ReflVTable; return Instr.pGetEffectiveAddress(&Instr, pCtx, nAddress, nOpcode); } @@ -616,8 +616,8 @@ VUShared::OPERANDSET CMA_VU::CUpper::GetAffectedOperands(CMIPS* context, uint32 memset(&result, 0, sizeof(OPERANDSET)); VUINSTRUCTION instr; - instr.pGetAffectedOperands = SubTableAffectedOperands; - instr.subTable = &m_VuReflVTable; + instr.pGetAffectedOperands = SubTableAffectedOperands; + instr.subTable = &m_VuReflVTable; instr.pGetAffectedOperands(&instr, context, address, opcode, result); return result; } diff --git a/Source/ee/PS2OS.cpp b/Source/ee/PS2OS.cpp index dd61473ba..bf52b70d0 100644 --- a/Source/ee/PS2OS.cpp +++ b/Source/ee/PS2OS.cpp @@ -48,184 +48,182 @@ // 0x1FC03100 0x1FC03200 Wait Thread Proc // 0x1FC03200 0x1FC03300 Alarm Handler -#define BIOS_ADDRESS_KERNELSTACK_TOP 0x00030000 -#define BIOS_ADDRESS_IDLE_THREAD_ID 0x00000010 -#define BIOS_ADDRESS_CURRENT_THREAD_ID 0x00000014 -#define BIOS_ADDRESS_VSYNCFLAG_VALUE1PTR 0x00000018 -#define BIOS_ADDRESS_VSYNCFLAG_VALUE2PTR 0x0000001C -#define BIOS_ADDRESS_THREADSCHEDULE_BASE 0x00000020 -#define BIOS_ADDRESS_INTCHANDLERQUEUE_BASE 0x00000024 -#define BIOS_ADDRESS_DMACHANDLERQUEUE_BASE 0x00000028 -#define BIOS_ADDRESS_LASTSIFDMA_TIME 0x0000002C -#define BIOS_ADDRESS_INTCHANDLER_BASE 0x0000A000 -#define BIOS_ADDRESS_DMACHANDLER_BASE 0x0000C000 -#define BIOS_ADDRESS_SEMAPHORE_BASE 0x0000E000 -#define BIOS_ADDRESS_ALARM_BASE 0x00010800 -#define BIOS_ADDRESS_THREAD_BASE 0x00011000 +#define BIOS_ADDRESS_KERNELSTACK_TOP 0x00030000 +#define BIOS_ADDRESS_IDLE_THREAD_ID 0x00000010 +#define BIOS_ADDRESS_CURRENT_THREAD_ID 0x00000014 +#define BIOS_ADDRESS_VSYNCFLAG_VALUE1PTR 0x00000018 +#define BIOS_ADDRESS_VSYNCFLAG_VALUE2PTR 0x0000001C +#define BIOS_ADDRESS_THREADSCHEDULE_BASE 0x00000020 +#define BIOS_ADDRESS_INTCHANDLERQUEUE_BASE 0x00000024 +#define BIOS_ADDRESS_DMACHANDLERQUEUE_BASE 0x00000028 +#define BIOS_ADDRESS_LASTSIFDMA_TIME 0x0000002C +#define BIOS_ADDRESS_INTCHANDLER_BASE 0x0000A000 +#define BIOS_ADDRESS_DMACHANDLER_BASE 0x0000C000 +#define BIOS_ADDRESS_SEMAPHORE_BASE 0x0000E000 +#define BIOS_ADDRESS_ALARM_BASE 0x00010800 +#define BIOS_ADDRESS_THREAD_BASE 0x00011000 -#define BIOS_ADDRESS_BASE 0x1FC00000 -#define BIOS_ADDRESS_INTERRUPTHANDLER 0x1FC00200 -#define BIOS_ADDRESS_DMACHANDLER 0x1FC01000 -#define BIOS_ADDRESS_INTCHANDLER 0x1FC02000 -#define BIOS_ADDRESS_THREADEPILOG 0x1FC03000 -#define BIOS_ADDRESS_IDLETHREADPROC 0x1FC03100 -#define BIOS_ADDRESS_ALARMHANDLER 0x1FC03200 +#define BIOS_ADDRESS_BASE 0x1FC00000 +#define BIOS_ADDRESS_INTERRUPTHANDLER 0x1FC00200 +#define BIOS_ADDRESS_DMACHANDLER 0x1FC01000 +#define BIOS_ADDRESS_INTCHANDLER 0x1FC02000 +#define BIOS_ADDRESS_THREADEPILOG 0x1FC03000 +#define BIOS_ADDRESS_IDLETHREADPROC 0x1FC03100 +#define BIOS_ADDRESS_ALARMHANDLER 0x1FC03200 -#define BIOS_ID_BASE 1 +#define BIOS_ID_BASE 1 -#define PATCHESFILENAME "patches.xml" -#define LOG_NAME ("ps2os") +#define PATCHESFILENAME "patches.xml" +#define LOG_NAME ("ps2os") -#define SYSCALL_NAME_EXIT "osExit" -#define SYSCALL_NAME_LOADEXECPS2 "osLoadExecPS2" -#define SYSCALL_NAME_EXECPS2 "osExecPS2" -#define SYSCALL_NAME_ADDINTCHANDLER "osAddIntcHandler" -#define SYSCALL_NAME_REMOVEINTCHANDLER "osRemoveIntcHandler" -#define SYSCALL_NAME_ADDDMACHANDLER "osAddDmacHandler" -#define SYSCALL_NAME_REMOVEDMACHANDLER "osRemoveDmacHandler" -#define SYSCALL_NAME_ENABLEINTC "osEnableIntc" -#define SYSCALL_NAME_DISABLEINTC "osDisableIntc" -#define SYSCALL_NAME_ENABLEDMAC "osEnableDmac" -#define SYSCALL_NAME_DISABLEDMAC "osDisableDmac" -#define SYSCALL_NAME_SETALARM "osSetAlarm" -#define SYSCALL_NAME_IENABLEINTC "osiEnableIntc" -#define SYSCALL_NAME_IDISABLEINTC "osiDisableIntc" -#define SYSCALL_NAME_IENABLEDMAC "osiEnableDmac" -#define SYSCALL_NAME_IDISABLEDMAC "osiDisableDmac" -#define SYSCALL_NAME_IRELEASEALARM "osiReleaseAlarm" -#define SYSCALL_NAME_CREATETHREAD "osCreateThread" -#define SYSCALL_NAME_DELETETHREAD "osDeleteThread" -#define SYSCALL_NAME_STARTTHREAD "osStartThread" -#define SYSCALL_NAME_EXITTHREAD "osExitThread" -#define SYSCALL_NAME_EXITDELETETHREAD "osExitDeleteThread" -#define SYSCALL_NAME_TERMINATETHREAD "osTerminateThread" -#define SYSCALL_NAME_CHANGETHREADPRIORITY "osChangeThreadPriority" -#define SYSCALL_NAME_ICHANGETHREADPRIORITY "osiChangeThreadPriority" -#define SYSCALL_NAME_ROTATETHREADREADYQUEUE "osRotateThreadReadyQueue" -#define SYSCALL_NAME_GETTHREADID "osGetThreadId" -#define SYSCALL_NAME_REFERTHREADSTATUS "osReferThreadStatus" -#define SYSCALL_NAME_IREFERTHREADSTATUS "osiReferThreadStatus" -#define SYSCALL_NAME_SLEEPTHREAD "osSleepThread" -#define SYSCALL_NAME_WAKEUPTHREAD "osWakeupThread" -#define SYSCALL_NAME_IWAKEUPTHREAD "osiWakeupThread" -#define SYSCALL_NAME_CANCELWAKEUPTHREAD "osCancelWakeupThread" -#define SYSCALL_NAME_ICANCELWAKEUPTHREAD "osiCancelWakeupThread" -#define SYSCALL_NAME_SUSPENDTHREAD "osSuspendThread" -#define SYSCALL_NAME_ISUSPENDTHREAD "osiSuspendThread" -#define SYSCALL_NAME_RESUMETHREAD "osResumeThread" -#define SYSCALL_NAME_ENDOFHEAP "osEndOfHeap" -#define SYSCALL_NAME_CREATESEMA "osCreateSema" -#define SYSCALL_NAME_DELETESEMA "osDeleteSema" -#define SYSCALL_NAME_SIGNALSEMA "osSignalSema" -#define SYSCALL_NAME_ISIGNALSEMA "osiSignalSema" -#define SYSCALL_NAME_WAITSEMA "osWaitSema" -#define SYSCALL_NAME_POLLSEMA "osPollSema" -#define SYSCALL_NAME_IPOLLSEMA "osiPollSema" -#define SYSCALL_NAME_REFERSEMASTATUS "osReferSemaStatus" -#define SYSCALL_NAME_IREFERSEMASTATUS "osiReferSemaStatus" -#define SYSCALL_NAME_FLUSHCACHE "osFlushCache" -#define SYSCALL_NAME_SIFSTOPDMA "osSifStopDma" -#define SYSCALL_NAME_GSGETIMR "osGsGetIMR" -#define SYSCALL_NAME_GSPUTIMR "osGsPutIMR" -#define SYSCALL_NAME_SETVSYNCFLAG "osSetVSyncFlag" -#define SYSCALL_NAME_SETSYSCALL "osSetSyscall" -#define SYSCALL_NAME_SIFDMASTAT "osSifDmaStat" -#define SYSCALL_NAME_SIFSETDMA "osSifSetDma" -#define SYSCALL_NAME_SIFSETDCHAIN "osSifSetDChain" -#define SYSCALL_NAME_DECI2CALL "osDeci2Call" -#define SYSCALL_NAME_MACHINETYPE "osMachineType" +#define SYSCALL_NAME_EXIT "osExit" +#define SYSCALL_NAME_LOADEXECPS2 "osLoadExecPS2" +#define SYSCALL_NAME_EXECPS2 "osExecPS2" +#define SYSCALL_NAME_ADDINTCHANDLER "osAddIntcHandler" +#define SYSCALL_NAME_REMOVEINTCHANDLER "osRemoveIntcHandler" +#define SYSCALL_NAME_ADDDMACHANDLER "osAddDmacHandler" +#define SYSCALL_NAME_REMOVEDMACHANDLER "osRemoveDmacHandler" +#define SYSCALL_NAME_ENABLEINTC "osEnableIntc" +#define SYSCALL_NAME_DISABLEINTC "osDisableIntc" +#define SYSCALL_NAME_ENABLEDMAC "osEnableDmac" +#define SYSCALL_NAME_DISABLEDMAC "osDisableDmac" +#define SYSCALL_NAME_SETALARM "osSetAlarm" +#define SYSCALL_NAME_IENABLEINTC "osiEnableIntc" +#define SYSCALL_NAME_IDISABLEINTC "osiDisableIntc" +#define SYSCALL_NAME_IENABLEDMAC "osiEnableDmac" +#define SYSCALL_NAME_IDISABLEDMAC "osiDisableDmac" +#define SYSCALL_NAME_IRELEASEALARM "osiReleaseAlarm" +#define SYSCALL_NAME_CREATETHREAD "osCreateThread" +#define SYSCALL_NAME_DELETETHREAD "osDeleteThread" +#define SYSCALL_NAME_STARTTHREAD "osStartThread" +#define SYSCALL_NAME_EXITTHREAD "osExitThread" +#define SYSCALL_NAME_EXITDELETETHREAD "osExitDeleteThread" +#define SYSCALL_NAME_TERMINATETHREAD "osTerminateThread" +#define SYSCALL_NAME_CHANGETHREADPRIORITY "osChangeThreadPriority" +#define SYSCALL_NAME_ICHANGETHREADPRIORITY "osiChangeThreadPriority" +#define SYSCALL_NAME_ROTATETHREADREADYQUEUE "osRotateThreadReadyQueue" +#define SYSCALL_NAME_GETTHREADID "osGetThreadId" +#define SYSCALL_NAME_REFERTHREADSTATUS "osReferThreadStatus" +#define SYSCALL_NAME_IREFERTHREADSTATUS "osiReferThreadStatus" +#define SYSCALL_NAME_SLEEPTHREAD "osSleepThread" +#define SYSCALL_NAME_WAKEUPTHREAD "osWakeupThread" +#define SYSCALL_NAME_IWAKEUPTHREAD "osiWakeupThread" +#define SYSCALL_NAME_CANCELWAKEUPTHREAD "osCancelWakeupThread" +#define SYSCALL_NAME_ICANCELWAKEUPTHREAD "osiCancelWakeupThread" +#define SYSCALL_NAME_SUSPENDTHREAD "osSuspendThread" +#define SYSCALL_NAME_ISUSPENDTHREAD "osiSuspendThread" +#define SYSCALL_NAME_RESUMETHREAD "osResumeThread" +#define SYSCALL_NAME_ENDOFHEAP "osEndOfHeap" +#define SYSCALL_NAME_CREATESEMA "osCreateSema" +#define SYSCALL_NAME_DELETESEMA "osDeleteSema" +#define SYSCALL_NAME_SIGNALSEMA "osSignalSema" +#define SYSCALL_NAME_ISIGNALSEMA "osiSignalSema" +#define SYSCALL_NAME_WAITSEMA "osWaitSema" +#define SYSCALL_NAME_POLLSEMA "osPollSema" +#define SYSCALL_NAME_IPOLLSEMA "osiPollSema" +#define SYSCALL_NAME_REFERSEMASTATUS "osReferSemaStatus" +#define SYSCALL_NAME_IREFERSEMASTATUS "osiReferSemaStatus" +#define SYSCALL_NAME_FLUSHCACHE "osFlushCache" +#define SYSCALL_NAME_SIFSTOPDMA "osSifStopDma" +#define SYSCALL_NAME_GSGETIMR "osGsGetIMR" +#define SYSCALL_NAME_GSPUTIMR "osGsPutIMR" +#define SYSCALL_NAME_SETVSYNCFLAG "osSetVSyncFlag" +#define SYSCALL_NAME_SETSYSCALL "osSetSyscall" +#define SYSCALL_NAME_SIFDMASTAT "osSifDmaStat" +#define SYSCALL_NAME_SIFSETDMA "osSifSetDma" +#define SYSCALL_NAME_SIFSETDCHAIN "osSifSetDChain" +#define SYSCALL_NAME_DECI2CALL "osDeci2Call" +#define SYSCALL_NAME_MACHINETYPE "osMachineType" #ifdef DEBUGGER_INCLUDED -const CPS2OS::SYSCALL_NAME CPS2OS::g_syscallNames[] = -{ - { 0x0004, SYSCALL_NAME_EXIT }, - { 0x0006, SYSCALL_NAME_LOADEXECPS2 }, - { 0x0007, SYSCALL_NAME_EXECPS2 }, - { 0x0010, SYSCALL_NAME_ADDINTCHANDLER }, - { 0x0011, SYSCALL_NAME_REMOVEINTCHANDLER }, - { 0x0012, SYSCALL_NAME_ADDDMACHANDLER }, - { 0x0013, SYSCALL_NAME_REMOVEDMACHANDLER }, - { 0x0014, SYSCALL_NAME_ENABLEINTC }, - { 0x0015, SYSCALL_NAME_DISABLEINTC }, - { 0x0016, SYSCALL_NAME_ENABLEDMAC }, - { 0x0017, SYSCALL_NAME_DISABLEDMAC }, - { 0x0018, SYSCALL_NAME_SETALARM }, - { 0x001A, SYSCALL_NAME_IENABLEINTC }, - { 0x001B, SYSCALL_NAME_IDISABLEINTC }, - { 0x001C, SYSCALL_NAME_IENABLEDMAC }, - { 0x001D, SYSCALL_NAME_IDISABLEDMAC }, - { 0x001F, SYSCALL_NAME_IRELEASEALARM }, - { 0x0020, SYSCALL_NAME_CREATETHREAD }, - { 0x0021, SYSCALL_NAME_DELETETHREAD }, - { 0x0022, SYSCALL_NAME_STARTTHREAD }, - { 0x0023, SYSCALL_NAME_EXITTHREAD }, - { 0x0024, SYSCALL_NAME_EXITDELETETHREAD }, - { 0x0025, SYSCALL_NAME_TERMINATETHREAD }, - { 0x0029, SYSCALL_NAME_CHANGETHREADPRIORITY }, - { 0x002A, SYSCALL_NAME_ICHANGETHREADPRIORITY }, - { 0x002B, SYSCALL_NAME_ROTATETHREADREADYQUEUE }, - { 0x002F, SYSCALL_NAME_GETTHREADID }, - { 0x0030, SYSCALL_NAME_REFERTHREADSTATUS }, - { 0x0031, SYSCALL_NAME_IREFERTHREADSTATUS }, - { 0x0032, SYSCALL_NAME_SLEEPTHREAD }, - { 0x0033, SYSCALL_NAME_WAKEUPTHREAD }, - { 0x0034, SYSCALL_NAME_IWAKEUPTHREAD }, - { 0x0035, SYSCALL_NAME_CANCELWAKEUPTHREAD }, - { 0x0036, SYSCALL_NAME_ICANCELWAKEUPTHREAD }, - { 0x0037, SYSCALL_NAME_SUSPENDTHREAD }, - { 0x0038, SYSCALL_NAME_ISUSPENDTHREAD }, - { 0x0039, SYSCALL_NAME_RESUMETHREAD }, - { 0x003E, SYSCALL_NAME_ENDOFHEAP }, - { 0x0040, SYSCALL_NAME_CREATESEMA }, - { 0x0041, SYSCALL_NAME_DELETESEMA }, - { 0x0042, SYSCALL_NAME_SIGNALSEMA }, - { 0x0043, SYSCALL_NAME_ISIGNALSEMA }, - { 0x0044, SYSCALL_NAME_WAITSEMA }, - { 0x0045, SYSCALL_NAME_POLLSEMA }, - { 0x0046, SYSCALL_NAME_IPOLLSEMA }, - { 0x0047, SYSCALL_NAME_REFERSEMASTATUS }, - { 0x0048, SYSCALL_NAME_IREFERSEMASTATUS }, - { 0x0064, SYSCALL_NAME_FLUSHCACHE }, - { 0x006B, SYSCALL_NAME_SIFSTOPDMA }, - { 0x0070, SYSCALL_NAME_GSGETIMR }, - { 0x0071, SYSCALL_NAME_GSPUTIMR }, - { 0x0073, SYSCALL_NAME_SETVSYNCFLAG }, - { 0x0074, SYSCALL_NAME_SETSYSCALL }, - { 0x0076, SYSCALL_NAME_SIFDMASTAT }, - { 0x0077, SYSCALL_NAME_SIFSETDMA }, - { 0x0078, SYSCALL_NAME_SIFSETDCHAIN }, - { 0x007C, SYSCALL_NAME_DECI2CALL }, - { 0x007E, SYSCALL_NAME_MACHINETYPE }, - { 0x0000, NULL } -}; +const CPS2OS::SYSCALL_NAME CPS2OS::g_syscallNames[] = + { + {0x0004, SYSCALL_NAME_EXIT}, + {0x0006, SYSCALL_NAME_LOADEXECPS2}, + {0x0007, SYSCALL_NAME_EXECPS2}, + {0x0010, SYSCALL_NAME_ADDINTCHANDLER}, + {0x0011, SYSCALL_NAME_REMOVEINTCHANDLER}, + {0x0012, SYSCALL_NAME_ADDDMACHANDLER}, + {0x0013, SYSCALL_NAME_REMOVEDMACHANDLER}, + {0x0014, SYSCALL_NAME_ENABLEINTC}, + {0x0015, SYSCALL_NAME_DISABLEINTC}, + {0x0016, SYSCALL_NAME_ENABLEDMAC}, + {0x0017, SYSCALL_NAME_DISABLEDMAC}, + {0x0018, SYSCALL_NAME_SETALARM}, + {0x001A, SYSCALL_NAME_IENABLEINTC}, + {0x001B, SYSCALL_NAME_IDISABLEINTC}, + {0x001C, SYSCALL_NAME_IENABLEDMAC}, + {0x001D, SYSCALL_NAME_IDISABLEDMAC}, + {0x001F, SYSCALL_NAME_IRELEASEALARM}, + {0x0020, SYSCALL_NAME_CREATETHREAD}, + {0x0021, SYSCALL_NAME_DELETETHREAD}, + {0x0022, SYSCALL_NAME_STARTTHREAD}, + {0x0023, SYSCALL_NAME_EXITTHREAD}, + {0x0024, SYSCALL_NAME_EXITDELETETHREAD}, + {0x0025, SYSCALL_NAME_TERMINATETHREAD}, + {0x0029, SYSCALL_NAME_CHANGETHREADPRIORITY}, + {0x002A, SYSCALL_NAME_ICHANGETHREADPRIORITY}, + {0x002B, SYSCALL_NAME_ROTATETHREADREADYQUEUE}, + {0x002F, SYSCALL_NAME_GETTHREADID}, + {0x0030, SYSCALL_NAME_REFERTHREADSTATUS}, + {0x0031, SYSCALL_NAME_IREFERTHREADSTATUS}, + {0x0032, SYSCALL_NAME_SLEEPTHREAD}, + {0x0033, SYSCALL_NAME_WAKEUPTHREAD}, + {0x0034, SYSCALL_NAME_IWAKEUPTHREAD}, + {0x0035, SYSCALL_NAME_CANCELWAKEUPTHREAD}, + {0x0036, SYSCALL_NAME_ICANCELWAKEUPTHREAD}, + {0x0037, SYSCALL_NAME_SUSPENDTHREAD}, + {0x0038, SYSCALL_NAME_ISUSPENDTHREAD}, + {0x0039, SYSCALL_NAME_RESUMETHREAD}, + {0x003E, SYSCALL_NAME_ENDOFHEAP}, + {0x0040, SYSCALL_NAME_CREATESEMA}, + {0x0041, SYSCALL_NAME_DELETESEMA}, + {0x0042, SYSCALL_NAME_SIGNALSEMA}, + {0x0043, SYSCALL_NAME_ISIGNALSEMA}, + {0x0044, SYSCALL_NAME_WAITSEMA}, + {0x0045, SYSCALL_NAME_POLLSEMA}, + {0x0046, SYSCALL_NAME_IPOLLSEMA}, + {0x0047, SYSCALL_NAME_REFERSEMASTATUS}, + {0x0048, SYSCALL_NAME_IREFERSEMASTATUS}, + {0x0064, SYSCALL_NAME_FLUSHCACHE}, + {0x006B, SYSCALL_NAME_SIFSTOPDMA}, + {0x0070, SYSCALL_NAME_GSGETIMR}, + {0x0071, SYSCALL_NAME_GSPUTIMR}, + {0x0073, SYSCALL_NAME_SETVSYNCFLAG}, + {0x0074, SYSCALL_NAME_SETSYSCALL}, + {0x0076, SYSCALL_NAME_SIFDMASTAT}, + {0x0077, SYSCALL_NAME_SIFSETDMA}, + {0x0078, SYSCALL_NAME_SIFSETDCHAIN}, + {0x007C, SYSCALL_NAME_DECI2CALL}, + {0x007E, SYSCALL_NAME_MACHINETYPE}, + {0x0000, NULL}}; #endif namespace filesystem = boost::filesystem; -CPS2OS::CPS2OS(CMIPS& ee, uint8* ram, uint8* bios, uint8* spr, CGSHandler*& gs, CSIF& sif, CIopBios& iopBios) -: m_ee(ee) -, m_gs(gs) -, m_elf(nullptr) -, m_ram(ram) -, m_bios(bios) -, m_spr(spr) -, m_sif(sif) -, m_iopBios(iopBios) -, m_threads(reinterpret_cast(m_ram + BIOS_ADDRESS_THREAD_BASE), BIOS_ID_BASE, MAX_THREAD) -, m_semaphores(reinterpret_cast(m_ram + BIOS_ADDRESS_SEMAPHORE_BASE), BIOS_ID_BASE, MAX_SEMAPHORE) -, m_intcHandlers(reinterpret_cast(m_ram + BIOS_ADDRESS_INTCHANDLER_BASE), BIOS_ID_BASE, MAX_INTCHANDLER) -, m_dmacHandlers(reinterpret_cast(m_ram + BIOS_ADDRESS_DMACHANDLER_BASE), BIOS_ID_BASE, MAX_DMACHANDLER) -, m_alarms(reinterpret_cast(m_ram + BIOS_ADDRESS_ALARM_BASE), BIOS_ID_BASE, MAX_ALARM) -, m_currentThreadId(reinterpret_cast(m_ram + BIOS_ADDRESS_CURRENT_THREAD_ID)) -, m_idleThreadId(reinterpret_cast(m_ram + BIOS_ADDRESS_IDLE_THREAD_ID)) -, m_lastSifDmaTime(reinterpret_cast(m_ram + BIOS_ADDRESS_LASTSIFDMA_TIME)) -, m_threadSchedule(m_threads, reinterpret_cast(m_ram + BIOS_ADDRESS_THREADSCHEDULE_BASE)) -, m_intcHandlerQueue(m_intcHandlers, reinterpret_cast(m_ram + BIOS_ADDRESS_INTCHANDLERQUEUE_BASE)) -, m_dmacHandlerQueue(m_dmacHandlers, reinterpret_cast(m_ram + BIOS_ADDRESS_DMACHANDLERQUEUE_BASE)) +CPS2OS::CPS2OS(CMIPS& ee, uint8* ram, uint8* bios, uint8* spr, CGSHandler*& gs, CSIF& sif, CIopBios& iopBios) + : m_ee(ee) + , m_gs(gs) + , m_elf(nullptr) + , m_ram(ram) + , m_bios(bios) + , m_spr(spr) + , m_sif(sif) + , m_iopBios(iopBios) + , m_threads(reinterpret_cast(m_ram + BIOS_ADDRESS_THREAD_BASE), BIOS_ID_BASE, MAX_THREAD) + , m_semaphores(reinterpret_cast(m_ram + BIOS_ADDRESS_SEMAPHORE_BASE), BIOS_ID_BASE, MAX_SEMAPHORE) + , m_intcHandlers(reinterpret_cast(m_ram + BIOS_ADDRESS_INTCHANDLER_BASE), BIOS_ID_BASE, MAX_INTCHANDLER) + , m_dmacHandlers(reinterpret_cast(m_ram + BIOS_ADDRESS_DMACHANDLER_BASE), BIOS_ID_BASE, MAX_DMACHANDLER) + , m_alarms(reinterpret_cast(m_ram + BIOS_ADDRESS_ALARM_BASE), BIOS_ID_BASE, MAX_ALARM) + , m_currentThreadId(reinterpret_cast(m_ram + BIOS_ADDRESS_CURRENT_THREAD_ID)) + , m_idleThreadId(reinterpret_cast(m_ram + BIOS_ADDRESS_IDLE_THREAD_ID)) + , m_lastSifDmaTime(reinterpret_cast(m_ram + BIOS_ADDRESS_LASTSIFDMA_TIME)) + , m_threadSchedule(m_threads, reinterpret_cast(m_ram + BIOS_ADDRESS_THREADSCHEDULE_BASE)) + , m_intcHandlerQueue(m_intcHandlers, reinterpret_cast(m_ram + BIOS_ADDRESS_INTCHANDLERQUEUE_BASE)) + , m_dmacHandlerQueue(m_dmacHandlers, reinterpret_cast(m_ram + BIOS_ADDRESS_DMACHANDLERQUEUE_BASE)) { - } CPS2OS::~CPS2OS() @@ -260,7 +258,7 @@ void CPS2OS::Release() bool CPS2OS::IsIdle() const { return m_ee.CanGenerateInterrupt() && - (m_currentThreadId == m_idleThreadId); + (m_currentThreadId == m_idleThreadId); } void CPS2OS::DumpIntcHandlers() @@ -273,10 +271,10 @@ void CPS2OS::DumpIntcHandlers() auto handler = m_intcHandlers[i + 1]; if(handler == nullptr) continue; - printf("ID: %02i, Line: %i, Address: 0x%08X.\r\n", \ - i + 1, - handler->cause, - handler->address); + printf("ID: %02i, Line: %i, Address: 0x%08X.\r\n", + i + 1, + handler->cause, + handler->address); } } @@ -290,10 +288,10 @@ void CPS2OS::DumpDmacHandlers() auto handler = m_dmacHandlers[i + 1]; if(handler == nullptr) continue; - printf("ID: %02i, Channel: %i, Address: 0x%08X.\r\n", \ - i + 1, - handler->channel, - handler->address); + printf("ID: %02i, Channel: %i, Address: 0x%08X.\r\n", + i + 1, + handler->channel, + handler->address); } } @@ -411,7 +409,7 @@ void CPS2OS::LoadELF(Framework::CStream& stream, const char* executablePath, con DELETEPTR(elf); throw std::runtime_error("Not an executable ELF file."); } - + UnloadExecutable(); m_elf = elf; @@ -419,15 +417,14 @@ void CPS2OS::LoadELF(Framework::CStream& stream, const char* executablePath, con m_executablePath = executablePath; m_currentArguments = arguments; - m_executableName = - [&] () - { - auto executableName = reinterpret_cast(strchr(executablePath, ':')); - if(!executableName) return executablePath; - executableName++; - if(executableName[0] == '/' || executableName[0] == '\\') executableName++; - return executableName; - }(); + m_executableName = + [&]() { + auto executableName = reinterpret_cast(strchr(executablePath, ':')); + if(!executableName) return executablePath; + executableName++; + if(executableName[0] == '/' || executableName[0] == '\\') executableName++; + return executableName; + }(); LoadExecutableInternal(); ApplyPatches(); @@ -456,7 +453,7 @@ void CPS2OS::LoadExecutableInternal() } m_ee.m_State.nPC = header.nEntryPoint; - + #ifdef DEBUGGER_INCLUDED std::pair executableRange = GetExecutableRange(); uint32 minAddr = executableRange.first; @@ -473,12 +470,11 @@ void CPS2OS::LoadExecutableInternal() if(opcode == 0x0000000C) { //Check the opcode before and after it - uint32 addiu = *reinterpret_cast(m_ram + address - 4); - uint32 jr = *reinterpret_cast(m_ram + address + 4); + uint32 addiu = *reinterpret_cast(m_ram + address - 4); + uint32 jr = *reinterpret_cast(m_ram + address + 4); if( - (jr == 0x03E00008) && - (addiu & 0xFFFF0000) == 0x24030000 - ) + (jr == 0x03E00008) && + (addiu & 0xFFFF0000) == 0x24030000) { //We have it! int16 syscallId = static_cast(addiu); @@ -537,7 +533,7 @@ uint32 CPS2OS::LoadExecutable(const char* path, const char* section) assert(strcmp(section, "all") == 0); auto fileStream(ioman->GetFileStream(handle)); - + //Load all program sections { CElfFile executable(*fileStream); @@ -603,9 +599,9 @@ void CPS2OS::ApplyPatches() for(Framework::Xml::CFilteringNodeIterator itNode(executableNode, "Patch"); !itNode.IsEnd(); itNode++) { auto patch = (*itNode); - - const char* addressString = patch->GetAttribute("Address"); - const char* valueString = patch->GetAttribute("Value"); + + const char* addressString = patch->GetAttribute("Address"); + const char* valueString = patch->GetAttribute("Value"); if(addressString == nullptr) continue; if(valueString == nullptr) continue; @@ -633,13 +629,13 @@ void CPS2OS::AssembleCustomSyscallHandler() //Epilogue assembler.ADDIU(CMIPS::SP, CMIPS::SP, 0xFFF0); assembler.SD(CMIPS::RA, 0x0000, CMIPS::SP); - + //Load the function address off the table at 0x80010000 assembler.SLL(CMIPS::T0, CMIPS::V1, 2); assembler.LUI(CMIPS::T1, 0x8001); assembler.ADDU(CMIPS::T0, CMIPS::T0, CMIPS::T1); assembler.LW(CMIPS::T0, 0x0000, CMIPS::T0); - + //And the address with 0x1FFFFFFF assembler.LUI(CMIPS::T1, 0x1FFF); assembler.ORI(CMIPS::T1, CMIPS::T1, 0xFFFF); @@ -668,7 +664,7 @@ void CPS2OS::AssembleInterruptHandler() //Epilogue (allocate stackFrameSize bytes) assembler.LI(CMIPS::K0, BIOS_ADDRESS_KERNELSTACK_TOP); assembler.ADDIU(CMIPS::K0, CMIPS::K0, 0x10000 - stackFrameSize); - + //Save EPC assembler.MFC0(CMIPS::T0, CCOP_SCU::EPC); assembler.SW(CMIPS::T0, 0x0220, CMIPS::K0); @@ -697,26 +693,25 @@ void CPS2OS::AssembleInterruptHandler() //assembler.SW(CMIPS::S0, 0x0000, CMIPS::T0); assembler.NOP(); - static const auto generateIntHandler = - [](CMIPSAssembler& assembler, uint32 line) - { - auto skipIntHandlerLabel = assembler.CreateLabel(); + static const auto generateIntHandler = + [](CMIPSAssembler& assembler, uint32 line) { + auto skipIntHandlerLabel = assembler.CreateLabel(); - //Check cause - assembler.ANDI(CMIPS::T0, CMIPS::S0, (1 << line)); - assembler.BEQ(CMIPS::R0, CMIPS::T0, skipIntHandlerLabel); - assembler.NOP(); + //Check cause + assembler.ANDI(CMIPS::T0, CMIPS::S0, (1 << line)); + assembler.BEQ(CMIPS::R0, CMIPS::T0, skipIntHandlerLabel); + assembler.NOP(); - //Process handlers - assembler.ADDIU(CMIPS::A0, CMIPS::R0, line); - assembler.JAL(BIOS_ADDRESS_INTCHANDLER); - assembler.NOP(); + //Process handlers + assembler.ADDIU(CMIPS::A0, CMIPS::R0, line); + assembler.JAL(BIOS_ADDRESS_INTCHANDLER); + assembler.NOP(); - assembler.MarkLabel(skipIntHandlerLabel); - }; + assembler.MarkLabel(skipIntHandlerLabel); + }; generateIntHandler(assembler, CINTC::INTC_LINE_GS); - + { auto skipIntHandlerLabel = assembler.CreateLabel(); @@ -838,7 +833,7 @@ void CPS2OS::AssembleDmacHandler() assembler.ADDU(CMIPS::A0, channelCounterRegister, CMIPS::R0); assembler.LW(CMIPS::A1, offsetof(DMACHANDLER, arg), CMIPS::T0); assembler.LW(CMIPS::GP, offsetof(DMACHANDLER, gp), CMIPS::T0); - + //Jump assembler.JALR(CMIPS::T1); assembler.NOP(); @@ -917,7 +912,7 @@ void CPS2OS::AssembleIntcHandler() assembler.ADDU(CMIPS::A0, causeRegister, CMIPS::R0); assembler.LW(CMIPS::A1, offsetof(INTCHANDLER, arg), CMIPS::T0); assembler.LW(CMIPS::GP, offsetof(INTCHANDLER, gp), CMIPS::T0); - + //Jump assembler.JALR(CMIPS::T1); assembler.NOP(); @@ -939,7 +934,7 @@ void CPS2OS::AssembleIntcHandler() void CPS2OS::AssembleThreadEpilog() { CMIPSAssembler assembler((uint32*)&m_bios[BIOS_ADDRESS_THREADEPILOG - BIOS_ADDRESS_BASE]); - + assembler.ADDIU(CMIPS::V1, CMIPS::R0, 0x23); assembler.SYSCALL(); } @@ -991,7 +986,7 @@ void CPS2OS::AssembleAlarmHandler() assembler.LW(CMIPS::A1, offsetof(ALARM, delay), CMIPS::T0); assembler.LW(CMIPS::A2, offsetof(ALARM, callbackParam), CMIPS::T0); assembler.LW(CMIPS::GP, offsetof(ALARM, gp), CMIPS::T0); - + //Jump assembler.JALR(CMIPS::T1); assembler.NOP(); @@ -1115,11 +1110,15 @@ void CPS2OS::ThreadSwitchContext(uint32 id) auto& sa = context->gpr[CMIPS::R0].nV0; auto& hi = context->gpr[CMIPS::K0]; auto& lo = context->gpr[CMIPS::K1]; - sa = m_ee.m_State.nSA >> 3; //Act as if MFSA was used - hi.nV[0] = m_ee.m_State.nHI[0]; hi.nV[1] = m_ee.m_State.nHI[1]; - hi.nV[2] = m_ee.m_State.nHI1[0]; hi.nV[3] = m_ee.m_State.nHI1[1]; - lo.nV[0] = m_ee.m_State.nLO[0]; lo.nV[1] = m_ee.m_State.nLO[1]; - lo.nV[2] = m_ee.m_State.nLO1[0]; lo.nV[3] = m_ee.m_State.nLO1[1]; + sa = m_ee.m_State.nSA >> 3; //Act as if MFSA was used + hi.nV[0] = m_ee.m_State.nHI[0]; + hi.nV[1] = m_ee.m_State.nHI[1]; + hi.nV[2] = m_ee.m_State.nHI1[0]; + hi.nV[3] = m_ee.m_State.nHI1[1]; + lo.nV[0] = m_ee.m_State.nLO[0]; + lo.nV[1] = m_ee.m_State.nLO[1]; + lo.nV[2] = m_ee.m_State.nLO1[0]; + lo.nV[3] = m_ee.m_State.nLO1[1]; context->cop1a = m_ee.m_State.nCOP1A; context->fcsr = m_ee.m_State.nFCSR; } @@ -1153,11 +1152,15 @@ void CPS2OS::ThreadSwitchContext(uint32 id) auto& sa = context->gpr[CMIPS::R0].nV0; auto& hi = context->gpr[CMIPS::K0]; auto& lo = context->gpr[CMIPS::K1]; - m_ee.m_State.nSA = (sa & 0x0F) << 3; //Act as if MTSA was used - m_ee.m_State.nHI[0] = hi.nV[0]; m_ee.m_State.nHI[1] = hi.nV[1]; - m_ee.m_State.nHI1[0] = hi.nV[2]; m_ee.m_State.nHI1[1] = hi.nV[3]; - m_ee.m_State.nLO[0] = lo.nV[0]; m_ee.m_State.nLO[1] = lo.nV[1]; - m_ee.m_State.nLO1[0] = lo.nV[2]; m_ee.m_State.nLO1[1] = lo.nV[3]; + m_ee.m_State.nSA = (sa & 0x0F) << 3; //Act as if MTSA was used + m_ee.m_State.nHI[0] = hi.nV[0]; + m_ee.m_State.nHI[1] = hi.nV[1]; + m_ee.m_State.nHI1[0] = hi.nV[2]; + m_ee.m_State.nHI1[1] = hi.nV[3]; + m_ee.m_State.nLO[0] = lo.nV[0]; + m_ee.m_State.nLO[1] = lo.nV[1]; + m_ee.m_State.nLO1[0] = lo.nV[2]; + m_ee.m_State.nLO1[1] = lo.nV[3]; m_ee.m_State.nCOP1A = context->cop1a; m_ee.m_State.nFCSR = context->fcsr; } @@ -1255,8 +1258,8 @@ void CPS2OS::CreateIdleThread() { m_idleThreadId = m_threads.Allocate(); auto thread = m_threads[m_idleThreadId]; - thread->epc = BIOS_ADDRESS_IDLETHREADPROC; - thread->status = THREAD_ZOMBIE; + thread->epc = BIOS_ADDRESS_IDLETHREADPROC; + thread->status = THREAD_ZOMBIE; } std::pair CPS2OS::GetVsyncFlagPtrs() const @@ -1380,9 +1383,9 @@ void CPS2OS::sc_Unhandled() //02 void CPS2OS::sc_GsSetCrt() { - bool isInterlaced = (m_ee.m_State.nGPR[SC_PARAM0].nV[0] != 0); - unsigned int mode = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - bool isFrameMode = (m_ee.m_State.nGPR[SC_PARAM2].nV[0] != 0); + bool isInterlaced = (m_ee.m_State.nGPR[SC_PARAM0].nV[0] != 0); + unsigned int mode = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + bool isFrameMode = (m_ee.m_State.nGPR[SC_PARAM2].nV[0] != 0); if(m_gs != NULL) { @@ -1390,7 +1393,6 @@ void CPS2OS::sc_GsSetCrt() } } - //04 void CPS2OS::sc_Exit() { @@ -1400,9 +1402,9 @@ void CPS2OS::sc_Exit() //06 void CPS2OS::sc_LoadExecPS2() { - uint32 filePathPtr = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 argCount = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - uint32 argValuesPtr = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; + uint32 filePathPtr = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 argCount = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 argValuesPtr = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; ArgumentList arguments; for(uint32 i = 0; i < argCount; i++) @@ -1423,10 +1425,10 @@ void CPS2OS::sc_LoadExecPS2() //07 void CPS2OS::sc_ExecPS2() { - uint32 pc = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 gp = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - uint32 argCount = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; - uint32 argValuesPtr = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; + uint32 pc = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 gp = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 argCount = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; + uint32 argValuesPtr = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; //This is used by Gran Turismo 4. The game clears the program //loaded initially, so, we need to make sure there's no stale @@ -1456,10 +1458,10 @@ void CPS2OS::sc_ExecPS2() //10 void CPS2OS::sc_AddIntcHandler() { - uint32 cause = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 address = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - uint32 next = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; - uint32 arg = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; + uint32 cause = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 address = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 next = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; + uint32 arg = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; uint32 id = m_intcHandlers.Allocate(); if(static_cast(id) == -1) @@ -1469,10 +1471,10 @@ void CPS2OS::sc_AddIntcHandler() } auto handler = m_intcHandlers[id]; - handler->address = address; - handler->cause = cause; - handler->arg = arg; - handler->gp = m_ee.m_State.nGPR[CMIPS::GP].nV[0]; + handler->address = address; + handler->cause = cause; + handler->arg = arg; + handler->gp = m_ee.m_State.nGPR[CMIPS::GP].nV[0]; if(next == 0) { @@ -1494,7 +1496,7 @@ void CPS2OS::sc_AddIntcHandler() void CPS2OS::sc_RemoveIntcHandler() { uint32 cause = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 id = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 id = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; auto handler = m_intcHandlers[id]; if(!handler) @@ -1521,10 +1523,10 @@ void CPS2OS::sc_RemoveIntcHandler() //12 void CPS2OS::sc_AddDmacHandler() { - uint32 channel = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 address = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - uint32 next = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; - uint32 arg = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; + uint32 channel = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 address = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 next = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; + uint32 arg = m_ee.m_State.nGPR[SC_PARAM3].nV[0]; uint32 id = m_dmacHandlers.Allocate(); if(static_cast(id) == -1) @@ -1534,10 +1536,10 @@ void CPS2OS::sc_AddDmacHandler() } auto handler = m_dmacHandlers[id]; - handler->address = address; - handler->channel = channel; - handler->arg = arg; - handler->gp = m_ee.m_State.nGPR[CMIPS::GP].nV[0]; + handler->address = address; + handler->channel = channel; + handler->arg = arg; + handler->gp = m_ee.m_State.nGPR[CMIPS::GP].nV[0]; if(next == 0) { @@ -1559,7 +1561,7 @@ void CPS2OS::sc_AddDmacHandler() void CPS2OS::sc_RemoveDmacHandler() { uint32 channel = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 id = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 id = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; auto handler = m_dmacHandlers[id]; if(!handler) @@ -1660,9 +1662,9 @@ void CPS2OS::sc_DisableDmac() //18 void CPS2OS::sc_SetAlarm() { - uint32 delay = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 callback = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - uint32 callbackParam = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; + uint32 delay = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 callback = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 callbackParam = m_ee.m_State.nGPR[SC_PARAM2].nV[0]; auto alarmId = m_alarms.Allocate(); assert(alarmId != -1); @@ -1673,10 +1675,10 @@ void CPS2OS::sc_SetAlarm() } auto alarm = m_alarms[alarmId]; - alarm->delay = delay; - alarm->callback = callback; - alarm->callbackParam = callbackParam; - alarm->gp = m_ee.m_State.nGPR[CMIPS::GP].nV0; + alarm->delay = delay; + alarm->callback = callback; + alarm->callbackParam = callbackParam; + alarm->gp = m_ee.m_State.nGPR[CMIPS::GP].nV0; m_ee.m_State.nGPR[SC_RETURN].nD0 = alarmId; } @@ -1715,15 +1717,15 @@ void CPS2OS::sc_CreateThread() assert(threadParam->initPriority < 128); auto thread = m_threads[id]; - thread->status = THREAD_ZOMBIE; - thread->stackBase = threadParam->stackBase; - thread->epc = threadParam->threadProc; - thread->threadProc = threadParam->threadProc; - thread->initPriority = threadParam->initPriority; - thread->heapBase = heapBase; - thread->wakeUpCount = 0; - thread->gp = threadParam->gp; - thread->stackSize = threadParam->stackSize; + thread->status = THREAD_ZOMBIE; + thread->stackBase = threadParam->stackBase; + thread->epc = threadParam->threadProc; + thread->threadProc = threadParam->threadProc; + thread->initPriority = threadParam->initPriority; + thread->heapBase = heapBase; + thread->wakeUpCount = 0; + thread->gp = threadParam->gp; + thread->stackSize = threadParam->stackSize; ThreadReset(id); @@ -1768,8 +1770,8 @@ void CPS2OS::sc_DeleteThread() //22 void CPS2OS::sc_StartThread() { - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 arg = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 arg = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; auto thread = m_threads[id]; if(!thread) @@ -1780,7 +1782,7 @@ void CPS2OS::sc_StartThread() assert(thread->status == THREAD_ZOMBIE); thread->status = THREAD_RUNNING; - thread->epc = thread->threadProc; + thread->epc = thread->threadProc; auto context = reinterpret_cast(GetStructPtr(thread->contextPtr)); context->gpr[CMIPS::A0].nV0 = arg; @@ -1857,9 +1859,9 @@ void CPS2OS::sc_TerminateThread() //2A void CPS2OS::sc_ChangeThreadPriority() { - bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x2A; - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 prio = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x2A; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 prio = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; auto thread = m_threads[id]; if(!thread) @@ -1919,8 +1921,8 @@ void CPS2OS::sc_GetThreadId() //30 void CPS2OS::sc_ReferThreadStatus() { - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 statusPtr = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 statusPtr = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; if(id >= MAX_THREAD) { @@ -1990,13 +1992,13 @@ void CPS2OS::sc_ReferThreadStatus() { auto status = reinterpret_cast(GetStructPtr(statusPtr)); - status->status = ret; - status->initPriority = thread->initPriority; - status->currPriority = thread->currPriority; - status->stackBase = thread->stackBase; - status->stackSize = thread->stackSize; - status->waitType = waitType; - status->wakeupCount = thread->wakeUpCount; + status->status = ret; + status->initPriority = thread->initPriority; + status->currPriority = thread->currPriority; + status->stackBase = thread->stackBase; + status->stackSize = thread->stackSize; + status->waitType = waitType; + status->wakeupCount = thread->wakeUpCount; } m_ee.m_State.nGPR[SC_RETURN].nD0 = ret; @@ -2024,8 +2026,8 @@ void CPS2OS::sc_SleepThread() //34 void CPS2OS::sc_WakeupThread() { - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x34; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x34; if((id == 0) || (id == m_currentThreadId)) { @@ -2050,8 +2052,8 @@ void CPS2OS::sc_WakeupThread() m_ee.m_State.nGPR[SC_RETURN].nD0 = static_cast(id); if( - (thread->status == THREAD_SLEEPING) || - (thread->status == THREAD_SUSPENDED_SLEEPING)) + (thread->status == THREAD_SLEEPING) || + (thread->status == THREAD_SUSPENDED_SLEEPING)) { switch(thread->status) { @@ -2081,8 +2083,8 @@ void CPS2OS::sc_WakeupThread() //36 void CPS2OS::sc_CancelWakeupThread() { - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x36; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x36; auto thread = m_threads[id]; if(!thread) @@ -2119,11 +2121,10 @@ void CPS2OS::sc_SuspendThread() } if( - (thread->status == THREAD_ZOMBIE) || - (thread->status == THREAD_SUSPENDED) || - (thread->status == THREAD_SUSPENDED_WAITING) || - (thread->status == THREAD_SUSPENDED_SLEEPING) - ) + (thread->status == THREAD_ZOMBIE) || + (thread->status == THREAD_SUSPENDED) || + (thread->status == THREAD_SUSPENDED_WAITING) || + (thread->status == THREAD_SUSPENDED_SLEEPING)) { m_ee.m_State.nGPR[SC_RETURN].nD0 = static_cast(-1); return; @@ -2173,11 +2174,10 @@ void CPS2OS::sc_ResumeThread() } if( - (thread->status == THREAD_ZOMBIE) || - (thread->status == THREAD_RUNNING) || - (thread->status == THREAD_WAITING) || - (thread->status == THREAD_SLEEPING) - ) + (thread->status == THREAD_ZOMBIE) || + (thread->status == THREAD_RUNNING) || + (thread->status == THREAD_WAITING) || + (thread->status == THREAD_SLEEPING)) { m_ee.m_State.nGPR[SC_RETURN].nD0 = static_cast(-1); return; @@ -2253,11 +2253,11 @@ void CPS2OS::sc_SetupThread() //Priority needs to be 0 because some games rely on this //by calling RotateThreadReadyQueue(0) (Dynasty Warriors 2) auto thread = m_threads[threadId]; - thread->status = THREAD_RUNNING; - thread->stackBase = stackAddr - stackSize; - thread->initPriority = 0; - thread->currPriority = 0; - thread->contextPtr = 0; + thread->status = THREAD_RUNNING; + thread->stackBase = stackAddr - stackSize; + thread->initPriority = 0; + thread->currPriority = 0; + thread->contextPtr = 0; LinkThread(threadId); assert(m_currentThreadId == 0); @@ -2310,9 +2310,9 @@ void CPS2OS::sc_CreateSema() } auto sema = m_semaphores[id]; - sema->count = semaParam->initCount; - sema->maxCount = semaParam->maxCount; - sema->waitCount = 0; + sema->count = semaParam->initCount; + sema->maxCount = semaParam->maxCount; + sema->waitCount = 0; assert(sema->count <= sema->maxCount); @@ -2352,8 +2352,8 @@ void CPS2OS::sc_DeleteSema() //43 void CPS2OS::sc_SignalSema() { - bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x43; - uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + bool isInt = m_ee.m_State.nGPR[3].nV[0] == 0x43; + uint32 id = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; auto sema = m_semaphores[id]; if(sema == nullptr) @@ -2361,7 +2361,7 @@ void CPS2OS::sc_SignalSema() m_ee.m_State.nGPR[SC_RETURN].nD0 = static_cast(-1); return; } - + //TODO: Check maximum value //Set return value here because we might reschedule @@ -2400,7 +2400,7 @@ void CPS2OS::sc_WaitSema() auto thread = m_threads[m_currentThreadId]; assert(thread->status == THREAD_RUNNING); - thread->status = THREAD_WAITING; + thread->status = THREAD_WAITING; thread->semaWait = id; UnlinkThread(m_currentThreadId); @@ -2437,7 +2437,7 @@ void CPS2OS::sc_PollSema() } sema->count--; - + m_ee.m_State.nGPR[SC_RETURN].nD0 = id; } @@ -2456,9 +2456,9 @@ void CPS2OS::sc_ReferSemaStatus() return; } - semaParam->count = sema->count; - semaParam->maxCount = sema->maxCount; - semaParam->waitThreads = sema->waitCount; + semaParam->count = sema->count; + semaParam->maxCount = sema->maxCount; + semaParam->waitThreads = sema->waitCount; m_ee.m_State.nGPR[SC_RETURN].nD0 = id; } @@ -2532,10 +2532,10 @@ void CPS2OS::sc_SetSyscall() } auto handler = m_intcHandlers[handlerId]; - handler->address = address & 0x1FFFFFFF; - handler->cause = line; - handler->arg = 0; - handler->gp = 0; + handler->address = address & 0x1FFFFFFF; + handler->cause = line; + handler->arg = 0; + handler->gp = 0; if(!(m_ee.m_pMemoryMap->GetWord(CINTC::INTC_MASK) & (1 << line))) { @@ -2593,7 +2593,7 @@ void CPS2OS::sc_SifSetDma() m_ee.m_pMemoryMap->SetWord(CDMAC::D6_MADR, xfer.srcAddr); m_ee.m_pMemoryMap->SetWord(CDMAC::D6_TADR, xfer.dstAddr); - m_ee.m_pMemoryMap->SetWord(CDMAC::D6_QWC, size); + m_ee.m_pMemoryMap->SetWord(CDMAC::D6_QWC, size); m_ee.m_pMemoryMap->SetWord(CDMAC::D6_CHCR, CDMAC::CHCR_BIT::CHCR_STR); } } @@ -2604,7 +2604,7 @@ void CPS2OS::sc_SifSetDChain() //Humm, set the SIF0 DMA channel in destination chain mode? //This syscall is invoked by the SIF dma interrupt handler (when a packet has been received) - //To make sure every packet generates an interrupt, the SIF will hold into any packet + //To make sure every packet generates an interrupt, the SIF will hold into any packet //that it might have in its queue while a packet is being processed. //The MarkPacketProcess function will tell the SIF that the packet has been processed //and that it can continue sending packets over. (Needed for Guilty Gear XX Accent Core Plus) @@ -2618,8 +2618,8 @@ void CPS2OS::sc_SifSetDChain() //79 void CPS2OS::sc_SifSetReg() { - uint32 registerId = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 value = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + uint32 registerId = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 value = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; m_sif.SetRegister(registerId, value); @@ -2636,9 +2636,9 @@ void CPS2OS::sc_SifGetReg() //7C void CPS2OS::sc_Deci2Call() { - uint32 function = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; - uint32 param = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; - + uint32 function = m_ee.m_State.nGPR[SC_PARAM0].nV[0]; + uint32 param = m_ee.m_State.nGPR[SC_PARAM1].nV[0]; + switch(function) { case 0x01: @@ -2647,9 +2647,9 @@ void CPS2OS::sc_Deci2Call() uint32 id = GetNextAvailableDeci2HandlerId(); DECI2HANDLER* handler = GetDeci2Handler(id); - handler->valid = 1; - handler->device = *(uint32*)&m_ram[param + 0x00]; - handler->bufferAddr = *(uint32*)&m_ram[param + 0x04]; + handler->valid = 1; + handler->device = *(uint32*)&m_ram[param + 0x00]; + handler->bufferAddr = *(uint32*)&m_ram[param + 0x04]; m_ee.m_State.nGPR[SC_RETURN].nV[0] = id; m_ee.m_State.nGPR[SC_RETURN].nV[1] = 0; @@ -2681,7 +2681,7 @@ void CPS2OS::sc_Deci2Call() //Deci2Poll { uint32 id = *reinterpret_cast(GetStructPtr(param + 0x00)); - + DECI2HANDLER* handler = GetDeci2Handler(id); if(handler->valid != 0) { @@ -2704,7 +2704,6 @@ void CPS2OS::sc_Deci2Call() CLog::GetInstance().Print(LOG_NAME, "Unknown Deci2Call function (0x%08X) called. PC: 0x%08X.\r\n", function, m_ee.m_State.nPC); break; } - } //7E @@ -2734,13 +2733,13 @@ void CPS2OS::HandleSyscall() { //This will happen if an ADDIU R0, R0, $x instruction is encountered. Not sure if there's a use for that on the EE CLog::GetInstance().Print(LOG_NAME, "System call exception occured but no SYSCALL instruction found (addr = 0x%08X, opcode = 0x%08X).\r\n", - searchAddress, callInstruction); + searchAddress, callInstruction); m_ee.m_State.nHasException = 0; return; } uint32 func = m_ee.m_State.nGPR[3].nV[0]; - + if(func == 0x666) { //Reschedule @@ -2757,9 +2756,9 @@ void CPS2OS::HandleSyscall() if(GetCustomSyscallTable()[func] == 0) { - #ifdef _DEBUG +#ifdef _DEBUG DisassembleSysCall(static_cast(func & 0xFF)); - #endif +#endif if(func < 0x80) { ((this)->*(m_sysCall[func & 0xFF]))(); @@ -2794,105 +2793,105 @@ std::string CPS2OS::GetSysCallDescription(uint8 function) switch(function) { case 0x02: - sprintf(description, "GsSetCrt(interlace = %i, mode = %i, field = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM2].nV[0]); + sprintf(description, "GsSetCrt(interlace = %i, mode = %i, field = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0]); break; case 0x04: sprintf(description, SYSCALL_NAME_EXIT "();"); break; case 0x06: sprintf(description, SYSCALL_NAME_LOADEXECPS2 "(exec = 0x%08X, argc = %d, argv = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0], - m_ee.m_State.nGPR[SC_PARAM2].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0]); break; case 0x07: sprintf(description, SYSCALL_NAME_EXECPS2 "(pc = 0x%08X, gp = 0x%08X, argc = %d, argv = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM0].nV[1], - m_ee.m_State.nGPR[SC_PARAM0].nV[2], - m_ee.m_State.nGPR[SC_PARAM0].nV[3]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM0].nV[1], + m_ee.m_State.nGPR[SC_PARAM0].nV[2], + m_ee.m_State.nGPR[SC_PARAM0].nV[3]); break; case 0x10: sprintf(description, SYSCALL_NAME_ADDINTCHANDLER "(cause = %i, address = 0x%08X, next = 0x%08X, arg = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0], - m_ee.m_State.nGPR[SC_PARAM2].nV[0], - m_ee.m_State.nGPR[SC_PARAM3].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0], + m_ee.m_State.nGPR[SC_PARAM3].nV[0]); break; case 0x11: - sprintf(description, SYSCALL_NAME_REMOVEINTCHANDLER "(cause = %i, id = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_REMOVEINTCHANDLER "(cause = %i, id = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x12: - sprintf(description, SYSCALL_NAME_ADDDMACHANDLER "(channel = %i, address = 0x%08X, next = %i, arg = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM2].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM3].nV[0]); + sprintf(description, SYSCALL_NAME_ADDDMACHANDLER "(channel = %i, address = 0x%08X, next = %i, arg = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0], + m_ee.m_State.nGPR[SC_PARAM3].nV[0]); break; case 0x13: - sprintf(description, SYSCALL_NAME_REMOVEDMACHANDLER "(channel = %i, handler = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_REMOVEDMACHANDLER "(channel = %i, handler = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x14: - sprintf(description, SYSCALL_NAME_ENABLEINTC "(cause = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_ENABLEINTC "(cause = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x15: - sprintf(description, SYSCALL_NAME_DISABLEINTC "(cause = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_DISABLEINTC "(cause = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x16: - sprintf(description, SYSCALL_NAME_ENABLEDMAC "(channel = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_ENABLEDMAC "(channel = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x17: - sprintf(description, SYSCALL_NAME_DISABLEDMAC "(channel = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_DISABLEDMAC "(channel = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x18: sprintf(description, SYSCALL_NAME_SETALARM "(time = %d, proc = 0x%08X, arg = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0], - m_ee.m_State.nGPR[SC_PARAM2].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0]); break; case 0x1A: sprintf(description, SYSCALL_NAME_IENABLEINTC "(cause = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x1B: sprintf(description, SYSCALL_NAME_IDISABLEINTC "(cause = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x1C: sprintf(description, SYSCALL_NAME_IENABLEDMAC "(channel = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x1D: sprintf(description, SYSCALL_NAME_IDISABLEDMAC "(channel = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x1F: sprintf(description, SYSCALL_NAME_IRELEASEALARM "(id = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x20: - sprintf(description, SYSCALL_NAME_CREATETHREAD "(thread = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_CREATETHREAD "(thread = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x21: - sprintf(description, SYSCALL_NAME_DELETETHREAD "(id = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_DELETETHREAD "(id = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x22: - sprintf(description, SYSCALL_NAME_STARTTHREAD "(id = 0x%08X, a0 = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_STARTTHREAD "(id = 0x%08X, a0 = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x23: sprintf(description, SYSCALL_NAME_EXITTHREAD "();"); @@ -2901,120 +2900,120 @@ std::string CPS2OS::GetSysCallDescription(uint8 function) sprintf(description, SYSCALL_NAME_EXITDELETETHREAD "();"); break; case 0x25: - sprintf(description, SYSCALL_NAME_TERMINATETHREAD "(id = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_TERMINATETHREAD "(id = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x29: - sprintf(description, SYSCALL_NAME_CHANGETHREADPRIORITY "(id = 0x%08X, priority = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_CHANGETHREADPRIORITY "(id = 0x%08X, priority = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x2A: - sprintf(description, SYSCALL_NAME_ICHANGETHREADPRIORITY "(id = 0x%08X, priority = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_ICHANGETHREADPRIORITY "(id = 0x%08X, priority = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x2B: - sprintf(description, SYSCALL_NAME_ROTATETHREADREADYQUEUE "(prio = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_ROTATETHREADREADYQUEUE "(prio = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x2F: sprintf(description, SYSCALL_NAME_GETTHREADID "();"); break; case 0x30: sprintf(description, SYSCALL_NAME_REFERTHREADSTATUS "(threadId = %d, infoPtr = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x31: sprintf(description, SYSCALL_NAME_IREFERTHREADSTATUS "(threadId = %d, infoPtr = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x32: sprintf(description, SYSCALL_NAME_SLEEPTHREAD "();"); break; case 0x33: - sprintf(description, SYSCALL_NAME_WAKEUPTHREAD "(id = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_WAKEUPTHREAD "(id = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x34: - sprintf(description, SYSCALL_NAME_IWAKEUPTHREAD "(id = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_IWAKEUPTHREAD "(id = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x35: - sprintf(description, SYSCALL_NAME_CANCELWAKEUPTHREAD "(id = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_CANCELWAKEUPTHREAD "(id = %d);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x36: - sprintf(description, SYSCALL_NAME_ICANCELWAKEUPTHREAD "(id = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_ICANCELWAKEUPTHREAD "(id = %d);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x37: - sprintf(description, SYSCALL_NAME_SUSPENDTHREAD "(id = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_SUSPENDTHREAD "(id = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x38: sprintf(description, SYSCALL_NAME_ISUSPENDTHREAD "(id = %d);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x39: - sprintf(description, SYSCALL_NAME_RESUMETHREAD "(id = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_RESUMETHREAD "(id = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x3C: - sprintf(description, "SetupThread(gp = 0x%08X, stack = 0x%08X, stack_size = 0x%08X, args = 0x%08X, root_func = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM2].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM3].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM4].nV[0]); + sprintf(description, "SetupThread(gp = 0x%08X, stack = 0x%08X, stack_size = 0x%08X, args = 0x%08X, root_func = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0], + m_ee.m_State.nGPR[SC_PARAM2].nV[0], + m_ee.m_State.nGPR[SC_PARAM3].nV[0], + m_ee.m_State.nGPR[SC_PARAM4].nV[0]); break; case 0x3D: - sprintf(description, "SetupHeap(heap_start = 0x%08X, heap_size = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, "SetupHeap(heap_start = 0x%08X, heap_size = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x3E: sprintf(description, SYSCALL_NAME_ENDOFHEAP "();"); break; case 0x40: - sprintf(description, SYSCALL_NAME_CREATESEMA "(sema = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_CREATESEMA "(sema = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x41: - sprintf(description, SYSCALL_NAME_DELETESEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_DELETESEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x42: - sprintf(description, SYSCALL_NAME_SIGNALSEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_SIGNALSEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x43: - sprintf(description, SYSCALL_NAME_ISIGNALSEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_ISIGNALSEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x44: - sprintf(description, SYSCALL_NAME_WAITSEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_WAITSEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x45: - sprintf(description, SYSCALL_NAME_POLLSEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_POLLSEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x46: - sprintf(description, SYSCALL_NAME_IPOLLSEMA "(semaid = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_IPOLLSEMA "(semaid = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x47: sprintf(description, SYSCALL_NAME_REFERSEMASTATUS "(semaid = %i, status = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x48: sprintf(description, SYSCALL_NAME_IREFERSEMASTATUS "(semaid = %i, status = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x64: case 0x68: @@ -3026,43 +3025,43 @@ std::string CPS2OS::GetSysCallDescription(uint8 function) sprintf(description, SYSCALL_NAME_GSGETIMR "();"); break; case 0x71: - sprintf(description, SYSCALL_NAME_GSPUTIMR "(GS_IMR = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, SYSCALL_NAME_GSPUTIMR "(GS_IMR = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x73: - sprintf(description, SYSCALL_NAME_SETVSYNCFLAG "(ptr1 = 0x%08X, ptr2 = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_SETVSYNCFLAG "(ptr1 = 0x%08X, ptr2 = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x74: - sprintf(description, SYSCALL_NAME_SETSYSCALL "(num = 0x%02X, address = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_SETSYSCALL "(num = 0x%02X, address = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x76: sprintf(description, SYSCALL_NAME_SIFDMASTAT "();"); break; case 0x77: - sprintf(description, SYSCALL_NAME_SIFSETDMA "(list = 0x%08X, count = %i);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, SYSCALL_NAME_SIFSETDMA "(list = 0x%08X, count = %i);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x78: sprintf(description, SYSCALL_NAME_SIFSETDCHAIN "();"); break; case 0x79: - sprintf(description, "SifSetReg(register = 0x%08X, value = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0], \ - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + sprintf(description, "SifSetReg(register = 0x%08X, value = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x7A: - sprintf(description, "SifGetReg(register = 0x%08X);", \ - m_ee.m_State.nGPR[SC_PARAM0].nV[0]); + sprintf(description, "SifGetReg(register = 0x%08X);", + m_ee.m_State.nGPR[SC_PARAM0].nV[0]); break; case 0x7C: sprintf(description, SYSCALL_NAME_DECI2CALL "(func = 0x%08X, param = 0x%08X);", - m_ee.m_State.nGPR[SC_PARAM0].nV[0], - m_ee.m_State.nGPR[SC_PARAM1].nV[0]); + m_ee.m_State.nGPR[SC_PARAM0].nV[0], + m_ee.m_State.nGPR[SC_PARAM1].nV[0]); break; case 0x7E: sprintf(description, SYSCALL_NAME_MACHINETYPE "();"); @@ -3131,10 +3130,10 @@ BiosDebugModuleInfoArray CPS2OS::GetModulesDebugInfo() const auto executableRange = GetExecutableRange(); BIOS_DEBUG_MODULE_INFO module; - module.name = m_executableName; - module.begin = executableRange.first; - module.end = executableRange.second; - module.param = m_elf; + module.name = m_executableName; + module.begin = executableRange.first; + module.end = executableRange.second; + module.param = m_elf; result.push_back(module); } @@ -3153,8 +3152,8 @@ BiosDebugThreadInfoArray CPS2OS::GetThreadsDebugInfo() const auto threadContext = reinterpret_cast(GetStructPtr(thread->contextPtr)); BIOS_DEBUG_THREAD_INFO threadInfo; - threadInfo.id = threadIterator; - threadInfo.priority = thread->currPriority; + threadInfo.id = threadIterator; + threadInfo.priority = thread->currPriority; if(m_currentThreadId == threadIterator) { threadInfo.pc = m_ee.m_State.nPC; diff --git a/Source/ee/PS2OS.h b/Source/ee/PS2OS.h index 50fc4eb89..5686ffe6d 100644 --- a/Source/ee/PS2OS.h +++ b/Source/ee/PS2OS.h @@ -21,101 +21,101 @@ class CPS2OS : public CBiosDebugInfoProvider public: typedef std::vector ArgumentList; - typedef boost::signals2::signal RequestLoadExecutableEvent; + typedef boost::signals2::signal RequestLoadExecutableEvent; - CPS2OS(CMIPS&, uint8*, uint8*, uint8*, CGSHandler*&, CSIF&, CIopBios&); - virtual ~CPS2OS(); + CPS2OS(CMIPS&, uint8*, uint8*, uint8*, CGSHandler*&, CSIF&, CIopBios&); + virtual ~CPS2OS(); - void Initialize(); - void Release(); + void Initialize(); + void Release(); - bool IsIdle() const; + bool IsIdle() const; - void DumpIntcHandlers(); - void DumpDmacHandlers(); + void DumpIntcHandlers(); + void DumpDmacHandlers(); - void BootFromFile(const boost::filesystem::path&); - void BootFromVirtualPath(const char*, const ArgumentList&); - void BootFromCDROM(); - CELF* GetELF(); - const char* GetExecutableName() const; - std::pair GetExecutableRange() const; - uint32 LoadExecutable(const char*, const char*); + void BootFromFile(const boost::filesystem::path&); + void BootFromVirtualPath(const char*, const ArgumentList&); + void BootFromCDROM(); + CELF* GetELF(); + const char* GetExecutableName() const; + std::pair GetExecutableRange() const; + uint32 LoadExecutable(const char*, const char*); - void HandleInterrupt(); - void HandleSyscall(); - void HandleReturnFromException(); - bool CheckVBlankFlag(); + void HandleInterrupt(); + void HandleSyscall(); + void HandleReturnFromException(); + bool CheckVBlankFlag(); - static uint32 TranslateAddress(CMIPS*, uint32); + static uint32 TranslateAddress(CMIPS*, uint32); #ifdef DEBUGGER_INCLUDED - BiosDebugModuleInfoArray GetModulesDebugInfo() const override; - BiosDebugThreadInfoArray GetThreadsDebugInfo() const override; + BiosDebugModuleInfoArray GetModulesDebugInfo() const override; + BiosDebugThreadInfoArray GetThreadsDebugInfo() const override; #endif - boost::signals2::signal OnExecutableChange; - boost::signals2::signal OnExecutableUnloading; - boost::signals2::signal OnRequestInstructionCacheFlush; - RequestLoadExecutableEvent OnRequestLoadExecutable; - boost::signals2::signal OnRequestExit; + boost::signals2::signal OnExecutableChange; + boost::signals2::signal OnExecutableUnloading; + boost::signals2::signal OnRequestInstructionCacheFlush; + RequestLoadExecutableEvent OnRequestLoadExecutable; + boost::signals2::signal OnRequestExit; private: struct SEMAPHOREPARAM { - uint32 count; - uint32 maxCount; - uint32 initCount; - uint32 waitThreads; - uint32 attributes; - uint32 options; + uint32 count; + uint32 maxCount; + uint32 initCount; + uint32 waitThreads; + uint32 attributes; + uint32 options; }; struct THREADPARAM { - uint32 status; - uint32 threadProc; - uint32 stackBase; - uint32 stackSize; - uint32 gp; - uint32 initPriority; - uint32 currPriority; - uint32 attr; - uint32 option; + uint32 status; + uint32 threadProc; + uint32 stackBase; + uint32 stackSize; + uint32 gp; + uint32 initPriority; + uint32 currPriority; + uint32 attr; + uint32 option; }; struct THREADSTATUS : public THREADPARAM { - uint32 waitType; - uint32 waitId; - uint32 wakeupCount; + uint32 waitType; + uint32 waitId; + uint32 wakeupCount; }; static_assert(sizeof(THREADSTATUS) == 0x30, "Thread status must be 48 bytes long."); struct SEMAPHORE { - uint32 isValid; - uint32 count; - uint32 maxCount; - uint32 waitCount; + uint32 isValid; + uint32 count; + uint32 maxCount; + uint32 waitCount; }; struct THREAD { - uint32 isValid; - uint32 nextId; - uint32 status; - uint32 contextPtr; - uint32 stackBase; - uint32 heapBase; - uint32 threadProc; - uint32 epc; - uint32 gp; - uint32 initPriority; - uint32 currPriority; - uint32 semaWait; - uint32 wakeUpCount; - uint32 stackSize; + uint32 isValid; + uint32 nextId; + uint32 status; + uint32 contextPtr; + uint32 stackBase; + uint32 heapBase; + uint32 threadProc; + uint32 epc; + uint32 gp; + uint32 initPriority; + uint32 currPriority; + uint32 semaWait; + uint32 wakeUpCount; + uint32 stackSize; }; enum STACKRES @@ -129,55 +129,55 @@ private: //values directly in the thread context struct THREADCONTEXT { - uint128 gpr[0x20]; - uint32 cop1[0x20]; - uint32 fcsr; - uint32 cop1a; - uint32 unknown[6]; + uint128 gpr[0x20]; + uint32 cop1[0x20]; + uint32 fcsr; + uint32 cop1a; + uint32 unknown[6]; }; static_assert(sizeof(THREADCONTEXT) == STACKRES, "Size of THREADCONTEXT must be STACKRES"); struct DMACHANDLER { - uint32 isValid; - uint32 nextId; - uint32 channel; - uint32 address; - uint32 arg; - uint32 gp; + uint32 isValid; + uint32 nextId; + uint32 channel; + uint32 address; + uint32 arg; + uint32 gp; }; struct INTCHANDLER { - uint32 isValid; - uint32 nextId; - uint32 cause; - uint32 address; - uint32 arg; - uint32 gp; + uint32 isValid; + uint32 nextId; + uint32 cause; + uint32 address; + uint32 arg; + uint32 gp; }; struct DECI2HANDLER { - uint32 valid; - uint32 device; - uint32 bufferAddr; + uint32 valid; + uint32 device; + uint32 bufferAddr; }; struct ALARM { - uint32 isValid; - uint32 delay; - uint32 callback; - uint32 callbackParam; - uint32 gp; + uint32 isValid; + uint32 delay; + uint32 callback; + uint32 callbackParam; + uint32 gp; }; #ifdef DEBUGGER_INCLUDED struct SYSCALL_NAME { - uint32 id; - const char* name; + uint32 id; + const char* name; }; #endif @@ -193,33 +193,33 @@ private: enum MAX { - MAX_THREAD = 256, - MAX_SEMAPHORE = 256, - MAX_DMACHANDLER = 128, - MAX_INTCHANDLER = 128, - MAX_DECI2HANDLER = 32, - MAX_ALARM = 4, + MAX_THREAD = 256, + MAX_SEMAPHORE = 256, + MAX_DMACHANDLER = 128, + MAX_INTCHANDLER = 128, + MAX_DECI2HANDLER = 32, + MAX_ALARM = 4, }; //TODO: Use "refer" status enum values enum THREAD_STATUS { - THREAD_RUNNING = 0x01, - THREAD_SLEEPING = 0x02, - THREAD_WAITING = 0x03, - THREAD_SUSPENDED = 0x04, - THREAD_SUSPENDED_WAITING = 0x05, - THREAD_SUSPENDED_SLEEPING = 0x06, - THREAD_ZOMBIE = 0x07, + THREAD_RUNNING = 0x01, + THREAD_SLEEPING = 0x02, + THREAD_WAITING = 0x03, + THREAD_SUSPENDED = 0x04, + THREAD_SUSPENDED_WAITING = 0x05, + THREAD_SUSPENDED_SLEEPING = 0x06, + THREAD_ZOMBIE = 0x07, }; enum THREAD_STATUS_REFER { - THS_RUN = 0x01, - THS_READY = 0x02, - THS_WAIT = 0x04, - THS_SUSPEND = 0x08, - THS_DORMANT = 0x10, + THS_RUN = 0x01, + THS_READY = 0x02, + THS_WAIT = 0x04, + THS_SUSPEND = 0x08, + THS_DORMANT = 0x10, }; typedef COsStructManager ThreadList; @@ -234,131 +234,131 @@ private: typedef void (CPS2OS::*SystemCallHandler)(); - void LoadELF(Framework::CStream&, const char*, const ArgumentList&); + void LoadELF(Framework::CStream&, const char*, const ArgumentList&); - void LoadExecutableInternal(); - void UnloadExecutable(); + void LoadExecutableInternal(); + void UnloadExecutable(); - void ApplyPatches(); + void ApplyPatches(); - void DisassembleSysCall(uint8); - std::string GetSysCallDescription(uint8); + void DisassembleSysCall(uint8); + std::string GetSysCallDescription(uint8); - static SystemCallHandler m_sysCall[0x80]; + static SystemCallHandler m_sysCall[0x80]; - void AssembleCustomSyscallHandler(); - void AssembleInterruptHandler(); - void AssembleDmacHandler(); - void AssembleIntcHandler(); - void AssembleAlarmHandler(); - void AssembleThreadEpilog(); - void AssembleIdleThreadProc(); + void AssembleCustomSyscallHandler(); + void AssembleInterruptHandler(); + void AssembleDmacHandler(); + void AssembleIntcHandler(); + void AssembleAlarmHandler(); + void AssembleThreadEpilog(); + void AssembleIdleThreadProc(); - uint32* GetCustomSyscallTable(); + uint32* GetCustomSyscallTable(); - void CreateIdleThread(); - void LinkThread(uint32); - void UnlinkThread(uint32); - void ThreadShakeAndBake(); - void ThreadSwitchContext(uint32); - void ThreadReset(uint32); - void CheckLivingThreads(); + void CreateIdleThread(); + void LinkThread(uint32); + void UnlinkThread(uint32); + void ThreadShakeAndBake(); + void ThreadSwitchContext(uint32); + void ThreadReset(uint32); + void CheckLivingThreads(); - bool SemaReleaseSingleThread(uint32, bool); + bool SemaReleaseSingleThread(uint32, bool); - std::pair GetVsyncFlagPtrs() const; - void SetVsyncFlagPtrs(uint32, uint32); + std::pair GetVsyncFlagPtrs() const; + void SetVsyncFlagPtrs(uint32, uint32); - uint8* GetStructPtr(uint32) const; + uint8* GetStructPtr(uint32) const; - uint32 GetNextAvailableDeci2HandlerId(); - DECI2HANDLER* GetDeci2Handler(uint32); + uint32 GetNextAvailableDeci2HandlerId(); + DECI2HANDLER* GetDeci2Handler(uint32); //Various system calls - void sc_GsSetCrt(); - void sc_Exit(); - void sc_LoadExecPS2(); - void sc_ExecPS2(); - void sc_AddIntcHandler(); - void sc_RemoveIntcHandler(); - void sc_AddDmacHandler(); - void sc_RemoveDmacHandler(); - void sc_EnableIntc(); - void sc_DisableIntc(); - void sc_EnableDmac(); - void sc_DisableDmac(); - void sc_SetAlarm(); - void sc_ReleaseAlarm(); - void sc_CreateThread(); - void sc_DeleteThread(); - void sc_StartThread(); - void sc_ExitThread(); - void sc_ExitDeleteThread(); - void sc_TerminateThread(); - void sc_ChangeThreadPriority(); - void sc_RotateThreadReadyQueue(); - void sc_GetThreadId(); - void sc_ReferThreadStatus(); - void sc_SleepThread(); - void sc_WakeupThread(); - void sc_CancelWakeupThread(); - void sc_SuspendThread(); - void sc_ResumeThread(); - void sc_SetupThread(); - void sc_SetupHeap(); - void sc_EndOfHeap(); - void sc_CreateSema(); - void sc_DeleteSema(); - void sc_SignalSema(); - void sc_WaitSema(); - void sc_PollSema(); - void sc_ReferSemaStatus(); - void sc_FlushCache(); - void sc_GsGetIMR(); - void sc_GsPutIMR(); - void sc_SetVSyncFlag(); - void sc_SetSyscall(); - void sc_SifDmaStat(); - void sc_SifSetDma(); - void sc_SifSetDChain(); - void sc_SifSetReg(); - void sc_SifGetReg(); - void sc_Deci2Call(); - void sc_MachineType(); - void sc_GetMemorySize(); - void sc_Unhandled(); + void sc_GsSetCrt(); + void sc_Exit(); + void sc_LoadExecPS2(); + void sc_ExecPS2(); + void sc_AddIntcHandler(); + void sc_RemoveIntcHandler(); + void sc_AddDmacHandler(); + void sc_RemoveDmacHandler(); + void sc_EnableIntc(); + void sc_DisableIntc(); + void sc_EnableDmac(); + void sc_DisableDmac(); + void sc_SetAlarm(); + void sc_ReleaseAlarm(); + void sc_CreateThread(); + void sc_DeleteThread(); + void sc_StartThread(); + void sc_ExitThread(); + void sc_ExitDeleteThread(); + void sc_TerminateThread(); + void sc_ChangeThreadPriority(); + void sc_RotateThreadReadyQueue(); + void sc_GetThreadId(); + void sc_ReferThreadStatus(); + void sc_SleepThread(); + void sc_WakeupThread(); + void sc_CancelWakeupThread(); + void sc_SuspendThread(); + void sc_ResumeThread(); + void sc_SetupThread(); + void sc_SetupHeap(); + void sc_EndOfHeap(); + void sc_CreateSema(); + void sc_DeleteSema(); + void sc_SignalSema(); + void sc_WaitSema(); + void sc_PollSema(); + void sc_ReferSemaStatus(); + void sc_FlushCache(); + void sc_GsGetIMR(); + void sc_GsPutIMR(); + void sc_SetVSyncFlag(); + void sc_SetSyscall(); + void sc_SifDmaStat(); + void sc_SifSetDma(); + void sc_SifSetDChain(); + void sc_SifSetReg(); + void sc_SifGetReg(); + void sc_Deci2Call(); + void sc_MachineType(); + void sc_GetMemorySize(); + void sc_Unhandled(); - uint8* m_ram = nullptr; - uint8* m_bios = nullptr; - uint8* m_spr = nullptr; + uint8* m_ram = nullptr; + uint8* m_bios = nullptr; + uint8* m_spr = nullptr; - CELF* m_elf; - CMIPS& m_ee; - ThreadList m_threads; - SemaphoreList m_semaphores; - IntcHandlerList m_intcHandlers; - DmacHandlerList m_dmacHandlers; - AlarmList m_alarms; + CELF* m_elf; + CMIPS& m_ee; + ThreadList m_threads; + SemaphoreList m_semaphores; + IntcHandlerList m_intcHandlers; + DmacHandlerList m_dmacHandlers; + AlarmList m_alarms; - OsVariableWrapper m_currentThreadId; - OsVariableWrapper m_idleThreadId; - OsVariableWrapper m_lastSifDmaTime; + OsVariableWrapper m_currentThreadId; + OsVariableWrapper m_idleThreadId; + OsVariableWrapper m_lastSifDmaTime; - ThreadQueue m_threadSchedule; - IntcHandlerQueue m_intcHandlerQueue; - DmacHandlerQueue m_dmacHandlerQueue; + ThreadQueue m_threadSchedule; + IntcHandlerQueue m_intcHandlerQueue; + DmacHandlerQueue m_dmacHandlerQueue; - std::string m_executablePath; - ArgumentList m_currentArguments; + std::string m_executablePath; + ArgumentList m_currentArguments; //For display purposes only - std::string m_executableName; + std::string m_executableName; - CGSHandler*& m_gs; - CSIF& m_sif; - CIopBios& m_iopBios; + CGSHandler*& m_gs; + CSIF& m_sif; + CIopBios& m_iopBios; #ifdef DEBUGGER_INCLUDED - static const SYSCALL_NAME g_syscallNames[]; + static const SYSCALL_NAME g_syscallNames[]; #endif }; diff --git a/Source/ee/SIF.cpp b/Source/ee/SIF.cpp index b73adcdc4..44b8102c8 100644 --- a/Source/ee/SIF.cpp +++ b/Source/ee/SIF.cpp @@ -8,72 +8,71 @@ #include "lexical_cast_ex.h" #include "string_format.h" -#define RPC_RECVADDR 0xDEADBEF0 -#define SIF_RESETADDR 0 //Only works if equals to 0 +#define RPC_RECVADDR 0xDEADBEF0 +#define SIF_RESETADDR 0 //Only works if equals to 0 -#define LOG_NAME ("sif") +#define LOG_NAME ("sif") -#define STATE_REGS_XML ("sif/regs.xml") -#define STATE_PACKETQUEUE ("sif/packet_queue") -#define STATE_CALL_REPLIES_XML ("sif/call_replies.xml") -#define STATE_BIND_REPLIES_XML ("sif/bind_replies.xml") +#define STATE_REGS_XML ("sif/regs.xml") +#define STATE_PACKETQUEUE ("sif/packet_queue") +#define STATE_CALL_REPLIES_XML ("sif/call_replies.xml") +#define STATE_BIND_REPLIES_XML ("sif/bind_replies.xml") -#define STATE_REG_MAINADDR ("MAINADDR") -#define STATE_REG_SUBADDR ("SUBADDR") -#define STATE_REG_MSFLAG ("MSFLAG") -#define STATE_REG_SMFLAG ("SMFLAG") -#define STATE_REG_EERECVADDR ("EERecvAddr") -#define STATE_REG_DATAADDR ("DataAddr") +#define STATE_REG_MAINADDR ("MAINADDR") +#define STATE_REG_SUBADDR ("SUBADDR") +#define STATE_REG_MSFLAG ("MSFLAG") +#define STATE_REG_SMFLAG ("SMFLAG") +#define STATE_REG_EERECVADDR ("EERecvAddr") +#define STATE_REG_DATAADDR ("DataAddr") #define STATE_REG_PACKETPROCESSED ("packetProcessed") -#define STATE_PACKET_HEADER_PACKETSIZE ("Packet_Header_PacketSize") -#define STATE_PACKET_HEADER_DESTSIZE ("Packet_Header_DestSize") -#define STATE_PACKET_HEADER_DEST ("Packet_Header_Dest") -#define STATE_PACKET_HEADER_CID ("Packet_Header_CId") -#define STATE_PACKET_HEADER_OPTIONAL ("Packet_Header_Optional") +#define STATE_PACKET_HEADER_PACKETSIZE ("Packet_Header_PacketSize") +#define STATE_PACKET_HEADER_DESTSIZE ("Packet_Header_DestSize") +#define STATE_PACKET_HEADER_DEST ("Packet_Header_Dest") +#define STATE_PACKET_HEADER_CID ("Packet_Header_CId") +#define STATE_PACKET_HEADER_OPTIONAL ("Packet_Header_Optional") -#define STATE_PACKET_CALL_RECORDID ("Packet_Call_RecordId") -#define STATE_PACKET_CALL_PACKETADDR ("Packet_Call_PacketAddr") -#define STATE_PACKET_CALL_RPCID ("Packet_Call_RpcId") -#define STATE_PACKET_CALL_CLIENTDATAADDR ("Packet_Call_ClientDataAddr") -#define STATE_PACKET_CALL_RPCNUMBER ("Packet_Call_RPCNumber") -#define STATE_PACKET_CALL_SENDSIZE ("Packet_Call_SendSize") -#define STATE_PACKET_CALL_RECV ("Packet_Call_Recv") -#define STATE_PACKET_CALL_RECVSIZE ("Packet_Call_RecvSize") -#define STATE_PACKET_CALL_RECVMODE ("Packet_Call_RecvMode") -#define STATE_PACKET_CALL_SERVERDATAADDR ("Packet_Call_ServerDataAddr") +#define STATE_PACKET_CALL_RECORDID ("Packet_Call_RecordId") +#define STATE_PACKET_CALL_PACKETADDR ("Packet_Call_PacketAddr") +#define STATE_PACKET_CALL_RPCID ("Packet_Call_RpcId") +#define STATE_PACKET_CALL_CLIENTDATAADDR ("Packet_Call_ClientDataAddr") +#define STATE_PACKET_CALL_RPCNUMBER ("Packet_Call_RPCNumber") +#define STATE_PACKET_CALL_SENDSIZE ("Packet_Call_SendSize") +#define STATE_PACKET_CALL_RECV ("Packet_Call_Recv") +#define STATE_PACKET_CALL_RECVSIZE ("Packet_Call_RecvSize") +#define STATE_PACKET_CALL_RECVMODE ("Packet_Call_RecvMode") +#define STATE_PACKET_CALL_SERVERDATAADDR ("Packet_Call_ServerDataAddr") -#define STATE_PACKET_REQUEST_END_RECORDID ("Packet_Request_End_RecordId") -#define STATE_PACKET_REQUEST_END_PACKETADDR ("Packet_Request_End_PacketAddr") -#define STATE_PACKET_REQUEST_END_RPCID ("Packet_Request_End_RpcId") -#define STATE_PACKET_REQUEST_END_CLIENTDATAADDR ("Packet_Request_End_ClientDataAddr") -#define STATE_PACKET_REQUEST_END_CID ("Packet_Request_End_CId") -#define STATE_PACKET_REQUEST_END_SERVERDATAADDR ("Packet_Request_End_ServerDataAddr") -#define STATE_PACKET_REQUEST_END_BUFFER ("Packet_Request_End_Buffer") -#define STATE_PACKET_REQUEST_END_CLIENTBUFFER ("Packet_Request_End_ClientBuffer") +#define STATE_PACKET_REQUEST_END_RECORDID ("Packet_Request_End_RecordId") +#define STATE_PACKET_REQUEST_END_PACKETADDR ("Packet_Request_End_PacketAddr") +#define STATE_PACKET_REQUEST_END_RPCID ("Packet_Request_End_RpcId") +#define STATE_PACKET_REQUEST_END_CLIENTDATAADDR ("Packet_Request_End_ClientDataAddr") +#define STATE_PACKET_REQUEST_END_CID ("Packet_Request_End_CId") +#define STATE_PACKET_REQUEST_END_SERVERDATAADDR ("Packet_Request_End_ServerDataAddr") +#define STATE_PACKET_REQUEST_END_BUFFER ("Packet_Request_End_Buffer") +#define STATE_PACKET_REQUEST_END_CLIENTBUFFER ("Packet_Request_End_ClientBuffer") CSIF::CSIF(CDMAC& dmac, uint8* eeRam, uint8* iopRam) -: m_dmac(dmac) -, m_eeRam(eeRam) -, m_iopRam(iopRam) + : m_dmac(dmac) + , m_eeRam(eeRam) + , m_iopRam(iopRam) { - } void CSIF::Reset() { - m_nMAINADDR = 0; - m_nSUBADDR = 0; - m_nMSFLAG = 0; - m_nSMFLAG = 0x60000; + m_nMAINADDR = 0; + m_nSUBADDR = 0; + m_nMSFLAG = 0; + m_nSMFLAG = 0x60000; - m_nEERecvAddr = 0; - m_nDataAddr = 0; + m_nEERecvAddr = 0; + m_nDataAddr = 0; - m_dmaBufferAddress = 0; - m_dmaBufferSize = 0; - m_cmdBufferAddress = 0; - m_cmdBufferSize = 0; + m_dmaBufferAddress = 0; + m_dmaBufferSize = 0; + m_cmdBufferAddress = 0; + m_cmdBufferSize = 0; m_packetQueue.clear(); m_packetProcessed = true; @@ -199,9 +198,9 @@ uint32 CSIF::ReceiveDMA6(uint32 nSrcAddr, uint32 nSize, uint32 nDstAddr, bool is else { assert(nDstAddr < PS2::IOP_RAM_SIZE); - CLog::GetInstance().Print(LOG_NAME, "WriteToIop(dstAddr = 0x%08X, srcAddr = 0x%08X, size = 0x%08X);\r\n", - nDstAddr, nSrcAddr, nSize); - nSize &= 0x7FFFFFFF; //Fix for Gregory Horror Show's crash + CLog::GetInstance().Print(LOG_NAME, "WriteToIop(dstAddr = 0x%08X, srcAddr = 0x%08X, size = 0x%08X);\r\n", + nDstAddr, nSrcAddr, nSize); + nSize &= 0x7FFFFFFF; //Fix for Gregory Horror Show's crash if(nDstAddr >= 0 && nDstAddr <= CIopBios::CONTROL_BLOCK_END) { CLog::GetInstance().Print(LOG_NAME, "Warning: Trying to DMA in Bios Control Area.\r\n"); @@ -216,12 +215,12 @@ uint32 CSIF::ReceiveDMA6(uint32 nSrcAddr, uint32 nSize, uint32 nDstAddr, bool is void CSIF::SendPacket(void* packet, uint32 size) { - m_packetQueue.insert(m_packetQueue.begin(), - reinterpret_cast(packet), - reinterpret_cast(packet) + size); m_packetQueue.insert(m_packetQueue.begin(), - reinterpret_cast(&size), - reinterpret_cast(&size) + 4); + reinterpret_cast(packet), + reinterpret_cast(packet) + size); + m_packetQueue.insert(m_packetQueue.begin(), + reinterpret_cast(&size), + reinterpret_cast(&size) + 4); } void CSIF::ProcessPackets() @@ -255,7 +254,7 @@ void CSIF::SendDMA(void* pData, uint32 nSize) uint32 nQuads = (nSize + 0x0F) / 0x10; m_dmac.SetRegister(CDMAC::D5_MADR, m_nEERecvAddr); - m_dmac.SetRegister(CDMAC::D5_QWC, nQuads); + m_dmac.SetRegister(CDMAC::D5_QWC, nQuads); m_dmac.SetRegister(CDMAC::D5_CHCR, CDMAC::CHCR_STR); } @@ -263,12 +262,12 @@ void CSIF::LoadState(Framework::CZipArchiveReader& archive) { { auto registerFile = CRegisterStateFile(*archive.BeginReadFile(STATE_REGS_XML)); - m_nMAINADDR = registerFile.GetRegister32(STATE_REG_MAINADDR); - m_nSUBADDR = registerFile.GetRegister32(STATE_REG_SUBADDR); - m_nMSFLAG = registerFile.GetRegister32(STATE_REG_MSFLAG); - m_nSMFLAG = registerFile.GetRegister32(STATE_REG_SMFLAG); - m_nEERecvAddr = registerFile.GetRegister32(STATE_REG_EERECVADDR); - m_nDataAddr = registerFile.GetRegister32(STATE_REG_DATAADDR); + m_nMAINADDR = registerFile.GetRegister32(STATE_REG_MAINADDR); + m_nSUBADDR = registerFile.GetRegister32(STATE_REG_SUBADDR); + m_nMSFLAG = registerFile.GetRegister32(STATE_REG_MSFLAG); + m_nSMFLAG = registerFile.GetRegister32(STATE_REG_SMFLAG); + m_nEERecvAddr = registerFile.GetRegister32(STATE_REG_EERECVADDR); + m_nDataAddr = registerFile.GetRegister32(STATE_REG_DATAADDR); m_packetProcessed = registerFile.GetRegister32(STATE_REG_PACKETPROCESSED) != 0; } @@ -282,12 +281,12 @@ void CSIF::SaveState(Framework::CZipArchiveWriter& archive) { { auto registerFile = new CRegisterStateFile(STATE_REGS_XML); - registerFile->SetRegister32(STATE_REG_MAINADDR, m_nMAINADDR); - registerFile->SetRegister32(STATE_REG_SUBADDR, m_nSUBADDR); - registerFile->SetRegister32(STATE_REG_MSFLAG, m_nMSFLAG); - registerFile->SetRegister32(STATE_REG_SMFLAG, m_nSMFLAG); - registerFile->SetRegister32(STATE_REG_EERECVADDR, m_nEERecvAddr); - registerFile->SetRegister32(STATE_REG_DATAADDR, m_nDataAddr); + registerFile->SetRegister32(STATE_REG_MAINADDR, m_nMAINADDR); + registerFile->SetRegister32(STATE_REG_SUBADDR, m_nSUBADDR); + registerFile->SetRegister32(STATE_REG_MSFLAG, m_nMSFLAG); + registerFile->SetRegister32(STATE_REG_SMFLAG, m_nSMFLAG); + registerFile->SetRegister32(STATE_REG_EERECVADDR, m_nEERecvAddr); + registerFile->SetRegister32(STATE_REG_DATAADDR, m_nDataAddr); registerFile->SetRegister32(STATE_REG_PACKETPROCESSED, m_packetProcessed); archive.InsertFile(registerFile); } @@ -355,7 +354,7 @@ CSIF::CallReplyMap CSIF::LoadCallReplies(Framework::CZipArchiveReader& archive) const auto& structFile(structFilePair.second); uint32 replyId = lexical_cast_hex(structFilePair.first); CALLREQUESTINFO callReply; - LoadState_RpcCall(structFile, callReply.call); + LoadState_RpcCall(structFile, callReply.call); LoadState_RequestEnd(structFile, callReply.reply); callReplies[replyId] = callReply; } @@ -380,75 +379,75 @@ CSIF::BindReplyMap CSIF::LoadBindReplies(Framework::CZipArchiveReader& archive) void CSIF::SaveState_Header(const std::string& prefix, CStructFile& file, const SIFCMDHEADER& packetHeader) { file.SetRegister32((prefix + STATE_PACKET_HEADER_PACKETSIZE).c_str(), packetHeader.packetSize); - file.SetRegister32((prefix + STATE_PACKET_HEADER_DESTSIZE).c_str(), packetHeader.destSize); - file.SetRegister32((prefix + STATE_PACKET_HEADER_DEST).c_str(), packetHeader.dest); - file.SetRegister32((prefix + STATE_PACKET_HEADER_CID).c_str(), packetHeader.commandId); - file.SetRegister32((prefix + STATE_PACKET_HEADER_OPTIONAL).c_str(), packetHeader.optional); + file.SetRegister32((prefix + STATE_PACKET_HEADER_DESTSIZE).c_str(), packetHeader.destSize); + file.SetRegister32((prefix + STATE_PACKET_HEADER_DEST).c_str(), packetHeader.dest); + file.SetRegister32((prefix + STATE_PACKET_HEADER_CID).c_str(), packetHeader.commandId); + file.SetRegister32((prefix + STATE_PACKET_HEADER_OPTIONAL).c_str(), packetHeader.optional); } void CSIF::LoadState_Header(const std::string& prefix, const CStructFile& file, SIFCMDHEADER& packetHeader) { packetHeader.packetSize = file.GetRegister32((prefix + STATE_PACKET_HEADER_PACKETSIZE).c_str()); - packetHeader.destSize = file.GetRegister32((prefix + STATE_PACKET_HEADER_DESTSIZE).c_str()); - packetHeader.dest = file.GetRegister32((prefix + STATE_PACKET_HEADER_DEST).c_str()); - packetHeader.commandId = file.GetRegister32((prefix + STATE_PACKET_HEADER_CID).c_str()); - packetHeader.optional = file.GetRegister32((prefix + STATE_PACKET_HEADER_OPTIONAL).c_str()); + packetHeader.destSize = file.GetRegister32((prefix + STATE_PACKET_HEADER_DESTSIZE).c_str()); + packetHeader.dest = file.GetRegister32((prefix + STATE_PACKET_HEADER_DEST).c_str()); + packetHeader.commandId = file.GetRegister32((prefix + STATE_PACKET_HEADER_CID).c_str()); + packetHeader.optional = file.GetRegister32((prefix + STATE_PACKET_HEADER_OPTIONAL).c_str()); } void CSIF::SaveState_RpcCall(CStructFile& file, const SIFRPCCALL& call) { SaveState_Header("call", file, call.header); - file.SetRegister32(STATE_PACKET_CALL_RECORDID, call.recordId); - file.SetRegister32(STATE_PACKET_CALL_PACKETADDR, call.packetAddr); - file.SetRegister32(STATE_PACKET_CALL_RPCID, call.rpcId); - file.SetRegister32(STATE_PACKET_CALL_CLIENTDATAADDR, call.clientDataAddr); - file.SetRegister32(STATE_PACKET_CALL_RPCNUMBER, call.rpcNumber); - file.SetRegister32(STATE_PACKET_CALL_SENDSIZE, call.sendSize); - file.SetRegister32(STATE_PACKET_CALL_RECV, call.recv); - file.SetRegister32(STATE_PACKET_CALL_RECVSIZE, call.recvSize); - file.SetRegister32(STATE_PACKET_CALL_RECVMODE, call.recvMode); - file.SetRegister32(STATE_PACKET_CALL_SERVERDATAADDR, call.serverDataAddr); + file.SetRegister32(STATE_PACKET_CALL_RECORDID, call.recordId); + file.SetRegister32(STATE_PACKET_CALL_PACKETADDR, call.packetAddr); + file.SetRegister32(STATE_PACKET_CALL_RPCID, call.rpcId); + file.SetRegister32(STATE_PACKET_CALL_CLIENTDATAADDR, call.clientDataAddr); + file.SetRegister32(STATE_PACKET_CALL_RPCNUMBER, call.rpcNumber); + file.SetRegister32(STATE_PACKET_CALL_SENDSIZE, call.sendSize); + file.SetRegister32(STATE_PACKET_CALL_RECV, call.recv); + file.SetRegister32(STATE_PACKET_CALL_RECVSIZE, call.recvSize); + file.SetRegister32(STATE_PACKET_CALL_RECVMODE, call.recvMode); + file.SetRegister32(STATE_PACKET_CALL_SERVERDATAADDR, call.serverDataAddr); } void CSIF::LoadState_RpcCall(const CStructFile& file, SIFRPCCALL& call) { LoadState_Header("call", file, call.header); - call.recordId = file.GetRegister32(STATE_PACKET_CALL_RECORDID); - call.packetAddr = file.GetRegister32(STATE_PACKET_CALL_PACKETADDR); - call.rpcId = file.GetRegister32(STATE_PACKET_CALL_RPCID); - call.clientDataAddr = file.GetRegister32(STATE_PACKET_CALL_CLIENTDATAADDR); - call.rpcNumber = file.GetRegister32(STATE_PACKET_CALL_RPCNUMBER); - call.sendSize = file.GetRegister32(STATE_PACKET_CALL_SENDSIZE); - call.recv = file.GetRegister32(STATE_PACKET_CALL_RECV); - call.recvSize = file.GetRegister32(STATE_PACKET_CALL_RECVSIZE); - call.recvMode = file.GetRegister32(STATE_PACKET_CALL_RECVMODE); - call.serverDataAddr = file.GetRegister32(STATE_PACKET_CALL_SERVERDATAADDR); + call.recordId = file.GetRegister32(STATE_PACKET_CALL_RECORDID); + call.packetAddr = file.GetRegister32(STATE_PACKET_CALL_PACKETADDR); + call.rpcId = file.GetRegister32(STATE_PACKET_CALL_RPCID); + call.clientDataAddr = file.GetRegister32(STATE_PACKET_CALL_CLIENTDATAADDR); + call.rpcNumber = file.GetRegister32(STATE_PACKET_CALL_RPCNUMBER); + call.sendSize = file.GetRegister32(STATE_PACKET_CALL_SENDSIZE); + call.recv = file.GetRegister32(STATE_PACKET_CALL_RECV); + call.recvSize = file.GetRegister32(STATE_PACKET_CALL_RECVSIZE); + call.recvMode = file.GetRegister32(STATE_PACKET_CALL_RECVMODE); + call.serverDataAddr = file.GetRegister32(STATE_PACKET_CALL_SERVERDATAADDR); } void CSIF::SaveState_RequestEnd(CStructFile& file, const SIFRPCREQUESTEND& requestEnd) { SaveState_Header("requestEnd", file, requestEnd.header); - file.SetRegister32(STATE_PACKET_REQUEST_END_RECORDID, requestEnd.recordId); - file.SetRegister32(STATE_PACKET_REQUEST_END_PACKETADDR, requestEnd.packetAddr); - file.SetRegister32(STATE_PACKET_REQUEST_END_RPCID, requestEnd.rpcId); - file.SetRegister32(STATE_PACKET_REQUEST_END_CLIENTDATAADDR, requestEnd.clientDataAddr); - file.SetRegister32(STATE_PACKET_REQUEST_END_CID, requestEnd.commandId); - file.SetRegister32(STATE_PACKET_REQUEST_END_SERVERDATAADDR, requestEnd.serverDataAddr); - file.SetRegister32(STATE_PACKET_REQUEST_END_BUFFER, requestEnd.buffer); - file.SetRegister32(STATE_PACKET_REQUEST_END_CLIENTBUFFER, requestEnd.cbuffer); + file.SetRegister32(STATE_PACKET_REQUEST_END_RECORDID, requestEnd.recordId); + file.SetRegister32(STATE_PACKET_REQUEST_END_PACKETADDR, requestEnd.packetAddr); + file.SetRegister32(STATE_PACKET_REQUEST_END_RPCID, requestEnd.rpcId); + file.SetRegister32(STATE_PACKET_REQUEST_END_CLIENTDATAADDR, requestEnd.clientDataAddr); + file.SetRegister32(STATE_PACKET_REQUEST_END_CID, requestEnd.commandId); + file.SetRegister32(STATE_PACKET_REQUEST_END_SERVERDATAADDR, requestEnd.serverDataAddr); + file.SetRegister32(STATE_PACKET_REQUEST_END_BUFFER, requestEnd.buffer); + file.SetRegister32(STATE_PACKET_REQUEST_END_CLIENTBUFFER, requestEnd.cbuffer); } void CSIF::LoadState_RequestEnd(const CStructFile& file, SIFRPCREQUESTEND& requestEnd) { LoadState_Header("requestEnd", file, requestEnd.header); - requestEnd.recordId = file.GetRegister32(STATE_PACKET_REQUEST_END_RECORDID); - requestEnd.packetAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_PACKETADDR); - requestEnd.rpcId = file.GetRegister32(STATE_PACKET_REQUEST_END_RPCID); - requestEnd.clientDataAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_CLIENTDATAADDR); - requestEnd.commandId = file.GetRegister32(STATE_PACKET_REQUEST_END_CID); - requestEnd.serverDataAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_SERVERDATAADDR); - requestEnd.buffer = file.GetRegister32(STATE_PACKET_REQUEST_END_BUFFER); - requestEnd.cbuffer = file.GetRegister32(STATE_PACKET_REQUEST_END_CLIENTBUFFER); + requestEnd.recordId = file.GetRegister32(STATE_PACKET_REQUEST_END_RECORDID); + requestEnd.packetAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_PACKETADDR); + requestEnd.rpcId = file.GetRegister32(STATE_PACKET_REQUEST_END_RPCID); + requestEnd.clientDataAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_CLIENTDATAADDR); + requestEnd.commandId = file.GetRegister32(STATE_PACKET_REQUEST_END_CID); + requestEnd.serverDataAddr = file.GetRegister32(STATE_PACKET_REQUEST_END_SERVERDATAADDR); + requestEnd.buffer = file.GetRegister32(STATE_PACKET_REQUEST_END_BUFFER); + requestEnd.cbuffer = file.GetRegister32(STATE_PACKET_REQUEST_END_CLIENTBUFFER); } ///////////////////////////////////////////////////////// @@ -464,14 +463,14 @@ void CSIF::Cmd_Initialize(const SIFCMDHEADER* hdr) { struct INIT { - SIFCMDHEADER Header; - uint32 nEEAddress; + SIFCMDHEADER Header; + uint32 nEEAddress; }; auto init = reinterpret_cast(hdr); if(init->Header.optional == 0) { - m_nEERecvAddr = init->nEEAddress; + m_nEERecvAddr = init->nEEAddress; m_nEERecvAddr &= (PS2::EE_RAM_SIZE - 1); } else if(init->Header.optional == 1) @@ -481,10 +480,10 @@ void CSIF::Cmd_Initialize(const SIFCMDHEADER* hdr) SIFSETSREG sreg; memset(&sreg, 0, sizeof(SIFSETSREG)); - sreg.header.commandId = SIF_CMD_SETSREG; + sreg.header.commandId = SIF_CMD_SETSREG; sreg.header.packetSize = sizeof(SIFSETSREG); - sreg.index = 0; //Should be SIF_SREG_RPCINIT - sreg.value = 1; + sreg.index = 0; //Should be SIF_SREG_RPCINIT + sreg.value = 1; SendPacket(&sreg, sizeof(SIFSETSREG)); } @@ -500,18 +499,18 @@ void CSIF::Cmd_Bind(const SIFCMDHEADER* hdr) SIFRPCREQUESTEND rend; memset(&rend, 0, sizeof(SIFRPCREQUESTEND)); - rend.header.packetSize = sizeof(SIFRPCREQUESTEND); - rend.header.dest = hdr->dest; - rend.header.commandId = SIF_CMD_REND; - rend.header.optional = 0; - rend.recordId = bind->recordId; - rend.packetAddr = bind->packetAddr; - rend.rpcId = bind->rpcId; - rend.clientDataAddr = bind->clientDataAddr; - rend.commandId = SIF_CMD_BIND; - rend.serverDataAddr = bind->serverId; - rend.buffer = RPC_RECVADDR; - rend.cbuffer = 0xDEADCAFE; + rend.header.packetSize = sizeof(SIFRPCREQUESTEND); + rend.header.dest = hdr->dest; + rend.header.commandId = SIF_CMD_REND; + rend.header.optional = 0; + rend.recordId = bind->recordId; + rend.packetAddr = bind->packetAddr; + rend.rpcId = bind->rpcId; + rend.clientDataAddr = bind->clientDataAddr; + rend.commandId = SIF_CMD_BIND; + rend.serverDataAddr = bind->serverId; + rend.buffer = RPC_RECVADDR; + rend.cbuffer = 0xDEADCAFE; CLog::GetInstance().Print(LOG_NAME, "Bound client data (0x%08X) with server id 0x%08X.\r\n", bind->clientDataAddr, bind->serverId); @@ -540,10 +539,10 @@ void CSIF::Cmd_Call(const SIFCMDHEADER* hdr) if(moduleIterator != std::end(m_modules)) { CSifModule* pModule(moduleIterator->second); - sendReply = pModule->Invoke(call->rpcNumber, - reinterpret_cast(m_eeRam + m_nDataAddr), call->sendSize, - reinterpret_cast(m_eeRam + nRecvAddr), call->recvSize, - m_eeRam); + sendReply = pModule->Invoke(call->rpcNumber, + reinterpret_cast(m_eeRam + m_nDataAddr), call->sendSize, + reinterpret_cast(m_eeRam + nRecvAddr), call->recvSize, + m_eeRam); } else { @@ -553,15 +552,15 @@ void CSIF::Cmd_Call(const SIFCMDHEADER* hdr) { SIFRPCREQUESTEND rend; memset(&rend, 0, sizeof(SIFRPCREQUESTEND)); - rend.header.packetSize = sizeof(SIFRPCREQUESTEND); - rend.header.dest = hdr->dest; - rend.header.commandId = SIF_CMD_REND; - rend.header.optional = 0; - rend.recordId = call->recordId; - rend.packetAddr = call->packetAddr; - rend.rpcId = call->rpcId; - rend.clientDataAddr = call->clientDataAddr; - rend.commandId = SIF_CMD_CALL; + rend.header.packetSize = sizeof(SIFRPCREQUESTEND); + rend.header.dest = hdr->dest; + rend.header.commandId = SIF_CMD_REND; + rend.header.optional = 0; + rend.recordId = call->recordId; + rend.packetAddr = call->packetAddr; + rend.rpcId = call->rpcId; + rend.clientDataAddr = call->clientDataAddr; + rend.commandId = SIF_CMD_CALL; if(sendReply) { @@ -585,7 +584,7 @@ void CSIF::Cmd_GetOtherData(const SIFCMDHEADER* hdr) auto otherData = reinterpret_cast(hdr); CLog::GetInstance().Print(LOG_NAME, "GetOtherData(dstPtr = 0x%08X, srcPtr = 0x%08X, size = 0x%08X);\r\n", - otherData->dstPtr, otherData->srcPtr, otherData->size); + otherData->dstPtr, otherData->srcPtr, otherData->size); uint32 dstPtr = otherData->dstPtr & (PS2::EE_RAM_SIZE - 1); uint32 srcPtr = otherData->srcPtr & (PS2::IOP_RAM_SIZE - 1); @@ -595,15 +594,15 @@ void CSIF::Cmd_GetOtherData(const SIFCMDHEADER* hdr) { SIFRPCREQUESTEND rend; memset(&rend, 0, sizeof(SIFRPCREQUESTEND)); - rend.header.packetSize = sizeof(SIFRPCREQUESTEND); - rend.header.dest = hdr->dest; - rend.header.commandId = SIF_CMD_REND; - rend.header.optional = 0; - rend.recordId = otherData->recordId; - rend.packetAddr = otherData->packetAddr; - rend.rpcId = otherData->rpcId; - rend.clientDataAddr = otherData->receiveDataAddr; - rend.commandId = SIF_CMD_OTHERDATA; + rend.header.packetSize = sizeof(SIFRPCREQUESTEND); + rend.header.dest = hdr->dest; + rend.header.commandId = SIF_CMD_REND; + rend.header.optional = 0; + rend.recordId = otherData->recordId; + rend.packetAddr = otherData->packetAddr; + rend.rpcId = otherData->rpcId; + rend.clientDataAddr = otherData->receiveDataAddr; + rend.commandId = SIF_CMD_OTHERDATA; SendPacket(&rend, sizeof(SIFRPCREQUESTEND)); } diff --git a/Source/ee/SIF.h b/Source/ee/SIF.h index 6cbd9850f..a60d5c025 100644 --- a/Source/ee/SIF.h +++ b/Source/ee/SIF.h @@ -13,44 +13,44 @@ class CSIF { public: - typedef std::function ModuleResetHandler; - typedef std::function CustomCommandHandler; + typedef std::function ModuleResetHandler; + typedef std::function CustomCommandHandler; - CSIF(CDMAC&, uint8*, uint8*); - virtual ~CSIF() = default; + CSIF(CDMAC&, uint8*, uint8*); + virtual ~CSIF() = default; - void Reset(); - - void ProcessPackets(); - void MarkPacketProcessed(); + void Reset(); - void RegisterModule(uint32, CSifModule*); - bool IsModuleRegistered(uint32) const; - void UnregisterModule(uint32); - void SetDmaBuffer(uint32, uint32); - void SetCmdBuffer(uint32, uint32); - void SendCallReply(uint32, const void*); - void SetModuleResetHandler(const ModuleResetHandler&); - void SetCustomCommandHandler(const CustomCommandHandler&); + void ProcessPackets(); + void MarkPacketProcessed(); - uint32 ReceiveDMA5(uint32, uint32, uint32, bool); - uint32 ReceiveDMA6(uint32, uint32, uint32, bool); + void RegisterModule(uint32, CSifModule*); + bool IsModuleRegistered(uint32) const; + void UnregisterModule(uint32); + void SetDmaBuffer(uint32, uint32); + void SetCmdBuffer(uint32, uint32); + void SendCallReply(uint32, const void*); + void SetModuleResetHandler(const ModuleResetHandler&); + void SetCustomCommandHandler(const CustomCommandHandler&); - void SendPacket(void*, uint32); + uint32 ReceiveDMA5(uint32, uint32, uint32, bool); + uint32 ReceiveDMA6(uint32, uint32, uint32, bool); - void SendDMA(void*, uint32); + void SendPacket(void*, uint32); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); + void SendDMA(void*, uint32); - void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); + + void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); private: struct CALLREQUESTINFO { - SIFRPCCALL call; - SIFRPCREQUESTEND reply; + SIFRPCCALL call; + SIFRPCREQUESTEND reply; }; typedef std::map ModuleMap; @@ -58,53 +58,53 @@ private: typedef std::map CallReplyMap; typedef std::map BindReplyMap; - void DeleteModules(); + void DeleteModules(); - void SaveCallReplies(Framework::CZipArchiveWriter&); - void SaveBindReplies(Framework::CZipArchiveWriter&); + void SaveCallReplies(Framework::CZipArchiveWriter&); + void SaveBindReplies(Framework::CZipArchiveWriter&); - static PacketQueue LoadPacketQueue(Framework::CZipArchiveReader&); - static CallReplyMap LoadCallReplies(Framework::CZipArchiveReader&); - static BindReplyMap LoadBindReplies(Framework::CZipArchiveReader&); + static PacketQueue LoadPacketQueue(Framework::CZipArchiveReader&); + static CallReplyMap LoadCallReplies(Framework::CZipArchiveReader&); + static BindReplyMap LoadBindReplies(Framework::CZipArchiveReader&); - static void SaveState_Header(const std::string&, CStructFile&, const SIFCMDHEADER&); - static void SaveState_RpcCall(CStructFile&, const SIFRPCCALL&); - static void SaveState_RequestEnd(CStructFile&, const SIFRPCREQUESTEND&); + static void SaveState_Header(const std::string&, CStructFile&, const SIFCMDHEADER&); + static void SaveState_RpcCall(CStructFile&, const SIFRPCCALL&); + static void SaveState_RequestEnd(CStructFile&, const SIFRPCREQUESTEND&); - static void LoadState_Header(const std::string&, const CStructFile&, SIFCMDHEADER&); - static void LoadState_RpcCall(const CStructFile&, SIFRPCCALL&); - static void LoadState_RequestEnd(const CStructFile&, SIFRPCREQUESTEND&); + static void LoadState_Header(const std::string&, const CStructFile&, SIFCMDHEADER&); + static void LoadState_RpcCall(const CStructFile&, SIFRPCCALL&); + static void LoadState_RequestEnd(const CStructFile&, SIFRPCREQUESTEND&); - void Cmd_SetEERecvAddr(const SIFCMDHEADER*); - void Cmd_Initialize(const SIFCMDHEADER*); - void Cmd_Bind(const SIFCMDHEADER*); - void Cmd_Call(const SIFCMDHEADER*); - void Cmd_GetOtherData(const SIFCMDHEADER*); + void Cmd_SetEERecvAddr(const SIFCMDHEADER*); + void Cmd_Initialize(const SIFCMDHEADER*); + void Cmd_Bind(const SIFCMDHEADER*); + void Cmd_Call(const SIFCMDHEADER*); + void Cmd_GetOtherData(const SIFCMDHEADER*); - uint8* m_eeRam; - uint8* m_iopRam; - uint32 m_dmaBufferAddress = 0; - uint32 m_dmaBufferSize = 0; - uint32 m_cmdBufferAddress = 0; - uint32 m_cmdBufferSize = 0; - CDMAC& m_dmac; + uint8* m_eeRam; + uint8* m_iopRam; + uint32 m_dmaBufferAddress = 0; + uint32 m_dmaBufferSize = 0; + uint32 m_cmdBufferAddress = 0; + uint32 m_cmdBufferSize = 0; + CDMAC& m_dmac; - uint32 m_nMAINADDR = 0; - uint32 m_nSUBADDR = 0; - uint32 m_nMSFLAG = 0; - uint32 m_nSMFLAG = 0; + uint32 m_nMAINADDR = 0; + uint32 m_nSUBADDR = 0; + uint32 m_nMSFLAG = 0; + uint32 m_nSMFLAG = 0; - uint32 m_nEERecvAddr = 0; - uint32 m_nDataAddr = 0; + uint32 m_nEERecvAddr = 0; + uint32 m_nDataAddr = 0; - ModuleMap m_modules; + ModuleMap m_modules; - PacketQueue m_packetQueue; - bool m_packetProcessed; + PacketQueue m_packetQueue; + bool m_packetProcessed; - CallReplyMap m_callReplies; - BindReplyMap m_bindReplies; + CallReplyMap m_callReplies; + BindReplyMap m_bindReplies; - ModuleResetHandler m_moduleResetHandler; - CustomCommandHandler m_customCommandHandler; + ModuleResetHandler m_moduleResetHandler; + CustomCommandHandler m_customCommandHandler; }; diff --git a/Source/ee/Timer.cpp b/Source/ee/Timer.cpp index b7db5f9f7..42b8bc4f2 100644 --- a/Source/ee/Timer.cpp +++ b/Source/ee/Timer.cpp @@ -5,10 +5,10 @@ #define LOG_NAME ("timer") -#define STATE_REGS_XML ("timer/regs.xml") +#define STATE_REGS_XML ("timer/regs.xml") CTimer::CTimer(CINTC& intc) -: m_intc(intc) + : m_intc(intc) { Reset(); } @@ -26,8 +26,8 @@ void CTimer::Count(unsigned int ticks) if(!(timer.nMODE & MODE_COUNT_ENABLE)) continue; - uint32 previousCount = timer.nCOUNT; - uint32 nextCount = timer.nCOUNT; + uint32 previousCount = timer.nCOUNT; + uint32 nextCount = timer.nCOUNT; uint32 divider = 1; switch(timer.nMODE & 0x03) @@ -42,7 +42,7 @@ void CTimer::Count(unsigned int ticks) divider = 256; break; case 0x03: - divider = 9437; // PAL + divider = 9437; // PAL break; } @@ -240,11 +240,11 @@ void CTimer::LoadState(Framework::CZipArchiveReader& archive) { auto& timer = m_timer[i]; std::string timerPrefix = "TIMER" + std::to_string(i) + "_"; - timer.nCOUNT = registerFile.GetRegister32((timerPrefix + "COUNT").c_str()); - timer.nMODE = registerFile.GetRegister32((timerPrefix + "MODE").c_str()); - timer.nCOMP = registerFile.GetRegister32((timerPrefix + "COMP").c_str()); - timer.nHOLD = registerFile.GetRegister32((timerPrefix + "HOLD").c_str()); - timer.clockRemain = registerFile.GetRegister32((timerPrefix + "REM").c_str()); + timer.nCOUNT = registerFile.GetRegister32((timerPrefix + "COUNT").c_str()); + timer.nMODE = registerFile.GetRegister32((timerPrefix + "MODE").c_str()); + timer.nCOMP = registerFile.GetRegister32((timerPrefix + "COMP").c_str()); + timer.nHOLD = registerFile.GetRegister32((timerPrefix + "HOLD").c_str()); + timer.clockRemain = registerFile.GetRegister32((timerPrefix + "REM").c_str()); } } diff --git a/Source/ee/Timer.h b/Source/ee/Timer.h index b1a41c872..26d9f5fdf 100644 --- a/Source/ee/Timer.h +++ b/Source/ee/Timer.h @@ -10,39 +10,39 @@ class CTimer public: enum { - MODE_GATE_ENABLE = 0x004, - - MODE_GATE_SELECT = 0x008, + MODE_GATE_ENABLE = 0x004, + + MODE_GATE_SELECT = 0x008, MODE_GATE_SELECT_HBLANK = 0x000, MODE_GATE_SELECT_VBLANK = 0x008, - MODE_GATE_MODE = 0x030, + MODE_GATE_MODE = 0x030, MODE_GATE_MODE_COUNTLOW = 0x000, MODE_GATE_MODE_HIGHEDGE = 0x010, - MODE_GATE_MODE_LOWEDGE = 0x020, + MODE_GATE_MODE_LOWEDGE = 0x020, MODE_GATE_MODE_BOTHEDGE = 0x030, - - MODE_ZERO_RETURN = 0x040, - MODE_COUNT_ENABLE = 0x080, - MODE_EQUAL_FLAG = 0x400, - MODE_OVERFLOW_FLAG = 0x800, + + MODE_ZERO_RETURN = 0x040, + MODE_COUNT_ENABLE = 0x080, + MODE_EQUAL_FLAG = 0x400, + MODE_OVERFLOW_FLAG = 0x800, }; - CTimer(CINTC&); - virtual ~CTimer() = default; + CTimer(CINTC&); + virtual ~CTimer() = default; - void Reset(); + void Reset(); - void Count(unsigned int); + void Count(unsigned int); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); - void LoadState(Framework::CZipArchiveReader&); - void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); + void SaveState(Framework::CZipArchiveWriter&); - void NotifyVBlankStart(); - void NotifyVBlankEnd(); + void NotifyVBlankStart(); + void NotifyVBlankEnd(); private: enum @@ -50,21 +50,21 @@ private: MAX_TIMER = 4, }; - void DisassembleGet(uint32); - void DisassembleSet(uint32, uint32); + void DisassembleGet(uint32); + void DisassembleSet(uint32, uint32); - void ProcessGateEdgeChange(uint32, uint32); + void ProcessGateEdgeChange(uint32, uint32); struct TIMER { - uint32 nCOUNT; - uint32 nMODE; - uint32 nCOMP; - uint32 nHOLD; + uint32 nCOUNT; + uint32 nMODE; + uint32 nCOMP; + uint32 nHOLD; - uint32 clockRemain; + uint32 clockRemain; }; - TIMER m_timer[MAX_TIMER]; - CINTC& m_intc; + TIMER m_timer[MAX_TIMER]; + CINTC& m_intc; }; diff --git a/Source/ee/VUShared.cpp b/Source/ee/VUShared.cpp index e91c506ff..d9a9a47fe 100644 --- a/Source/ee/VUShared.cpp +++ b/Source/ee/VUShared.cpp @@ -4,36 +4,33 @@ #include "offsetof_def.h" #include "FpAddTruncate.h" -#define LATENCY_MAC (4) -#define LATENCY_DIV (7) -#define LATENCY_SQRT (7) -#define LATENCY_RSQRT (13) +#define LATENCY_MAC (4) +#define LATENCY_DIV (7) +#define LATENCY_SQRT (7) +#define LATENCY_RSQRT (13) #define STATUS_ZS 0x40 #define STATUS_SS 0x80 const VUShared::REGISTER_PIPEINFO VUShared::g_pipeInfoQ = -{ - offsetof(CMIPS, m_State.nCOP2Q), - offsetof(CMIPS, m_State.pipeQ.heldValue), - offsetof(CMIPS, m_State.pipeQ.counter) -}; + { + offsetof(CMIPS, m_State.nCOP2Q), + offsetof(CMIPS, m_State.pipeQ.heldValue), + offsetof(CMIPS, m_State.pipeQ.counter)}; const VUShared::FLAG_PIPEINFO VUShared::g_pipeInfoMac = -{ - offsetof(CMIPS, m_State.nCOP2MF), - offsetof(CMIPS, m_State.pipeMac.index), - offsetof(CMIPS, m_State.pipeMac.values), - offsetof(CMIPS, m_State.pipeMac.pipeTimes) -}; + { + offsetof(CMIPS, m_State.nCOP2MF), + offsetof(CMIPS, m_State.pipeMac.index), + offsetof(CMIPS, m_State.pipeMac.values), + offsetof(CMIPS, m_State.pipeMac.pipeTimes)}; const VUShared::FLAG_PIPEINFO VUShared::g_pipeInfoClip = -{ - offsetof(CMIPS, m_State.nCOP2CF), - offsetof(CMIPS, m_State.pipeClip.index), - offsetof(CMIPS, m_State.pipeClip.values), - offsetof(CMIPS, m_State.pipeClip.pipeTimes) -}; + { + offsetof(CMIPS, m_State.nCOP2CF), + offsetof(CMIPS, m_State.pipeClip.index), + offsetof(CMIPS, m_State.pipeClip.values), + offsetof(CMIPS, m_State.pipeClip.pipeTimes)}; using namespace VUShared; @@ -115,7 +112,7 @@ uint32* VUShared::GetAccumulatorElement(CMIPS* pCtx, unsigned int nElement) return &pCtx->m_State.nCOP2A.nV3; break; } - return NULL; + return NULL; } size_t VUShared::GetAccumulatorElement(unsigned int nElement) @@ -127,10 +124,10 @@ void VUShared::PullVector(CMipsJitter* codeGen, uint8 dest, size_t vector) { assert(vector != offsetof(CMIPS, m_State.nCOP2[0])); codeGen->MD_PullRel(vector, - DestinationHasElement(dest, 0), - DestinationHasElement(dest, 1), - DestinationHasElement(dest, 2), - DestinationHasElement(dest, 3)); + DestinationHasElement(dest, 0), + DestinationHasElement(dest, 1), + DestinationHasElement(dest, 2), + DestinationHasElement(dest, 3)); } void VUShared::PushIntegerRegister(CMipsJitter* codeGen, unsigned int nRegister) @@ -258,7 +255,7 @@ void VUShared::GetStatus(CMipsJitter* codeGen, size_t dstOffset, uint32 relative void VUShared::SetStatus(CMipsJitter* codeGen, size_t srcOffset) { //Only sticky flags can be set - + //Clear sticky flags codeGen->PushCst(0); codeGen->PullRel(offsetof(CMIPS, m_State.nCOP2SF)); @@ -536,25 +533,25 @@ void VUShared::ADDq(CMipsJitter* codeGen, uint8 nDest, uint8 nFd, uint8 nFs, uin void VUShared::ADDA(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint32 relativePipeTime) { ADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::ADDAbc(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { ADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::ADDAi(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { ADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::CLIP(CMipsJitter* codeGen, uint8 nFs, uint8 nFt, uint32 relativePipeTime) @@ -794,9 +791,9 @@ void VUShared::ISWbase(CMipsJitter* codeGen, uint8 dest) if(VUShared::DestinationHasElement(static_cast(dest), i)) { codeGen->PushRelRef(offsetof(CMIPS, m_vuMem)); - codeGen->PushIdx(1); //Push computed address - codeGen->AddRef(); //Make new ref value - codeGen->PushIdx(2); //Push value to store + codeGen->PushIdx(1); //Push computed address + codeGen->AddRef(); //Make new ref value + codeGen->PushIdx(2); //Push value to store codeGen->StoreAtRef(); } @@ -890,69 +887,69 @@ void VUShared::LQI(CMipsJitter* codeGen, uint8 dest, uint8 it, uint8 is, uint32 void VUShared::MADD(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint32 relativePipeTime) { MADD_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MADDbc(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MADD_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MADDi(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MADD_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MADDq(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MADD_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::MADDA(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint32 relativePipeTime) { MADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MADDAbc(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MADDAi(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MADDAq(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MADDA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::MAX(CMipsJitter* codeGen, uint8 nDest, uint8 nFd, uint8 nFs, uint8 nFt) @@ -1047,69 +1044,69 @@ void VUShared::MR32(CMipsJitter* codeGen, uint8 nDest, uint8 nFt, uint8 nFs) void VUShared::MSUB(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint32 relativePipeTime) { MSUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MSUBbc(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MSUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MSUBi(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MSUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MSUBq(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MSUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::MSUBA(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint32 relativePipeTime) { MSUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MSUBAbc(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MSUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MSUBAi(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MSUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MSUBAq(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MSUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::MFIR(CMipsJitter* codeGen, uint8 dest, uint8 ft, uint8 is) @@ -1133,69 +1130,69 @@ void VUShared::MTIR(CMipsJitter* codeGen, uint8 it, uint8 fs, uint8 fsf) void VUShared::MUL(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint32 relativePipeTime) { MUL_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MULbc(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MUL_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MULi(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MUL_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MULq(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { MUL_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::MULA(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint32 relativePipeTime) { MULA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::MULAbc(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { MULA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::MULAi(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MULA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::MULAq(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { MULA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::OPMULA(CMipsJitter* codeGen, uint8 nFs, uint8 nFt) @@ -1388,61 +1385,61 @@ void VUShared::SQRT(CMipsJitter* codeGen, uint8 nFt, uint8 nFtf, uint32 relative void VUShared::SUB(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint32 relativePipeTime) { SUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::SUBbc(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { SUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::SUBi(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { SUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::SUBq(CMipsJitter* codeGen, uint8 dest, uint8 fd, uint8 fs, uint32 relativePipeTime) { SUB_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2Q), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[(fd != 0) ? fd : 32]), + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2Q), + true, relativePipeTime); } void VUShared::SUBA(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint32 relativePipeTime) { SUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft]), - false, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft]), + false, relativePipeTime); } void VUShared::SUBAbc(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint8 ft, uint8 bc, uint32 relativePipeTime) { SUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2[ft].nV[bc]), + true, relativePipeTime); } void VUShared::SUBAi(CMipsJitter* codeGen, uint8 dest, uint8 fs, uint32 relativePipeTime) { SUBA_base(codeGen, dest, - offsetof(CMIPS, m_State.nCOP2[fs]), - offsetof(CMIPS, m_State.nCOP2I), - true, relativePipeTime); + offsetof(CMIPS, m_State.nCOP2[fs]), + offsetof(CMIPS, m_State.nCOP2I), + true, relativePipeTime); } void VUShared::WAITQ(CMipsJitter* codeGen) @@ -1490,14 +1487,14 @@ void VUShared::CheckFlagPipeline(const FLAG_PIPEINFO& pipeInfo, CMipsJitter* cod for(unsigned int i = 0; i < FLAG_PIPELINE_SLOTS; i++) { codeGen->PushRelAddrRef(pipeInfo.timeArray); - + //Compute index into array codeGen->PushRel(pipeInfo.index); codeGen->PushCst(i); codeGen->Add(); codeGen->PushCst(FLAG_PIPELINE_SLOTS - 1); codeGen->And(); - + codeGen->Shl(2); codeGen->AddRef(); codeGen->LoadFromRef(); @@ -1509,14 +1506,14 @@ void VUShared::CheckFlagPipeline(const FLAG_PIPEINFO& pipeInfo, CMipsJitter* cod codeGen->BeginIf(Jitter::CONDITION_LE); { codeGen->PushRelAddrRef(pipeInfo.valueArray); - + //Compute index into array codeGen->PushRel(pipeInfo.index); codeGen->PushCst(i); codeGen->Add(); codeGen->PushCst(FLAG_PIPELINE_SLOTS - 1); codeGen->And(); - + codeGen->Shl(2); codeGen->AddRef(); codeGen->LoadFromRef(); @@ -1564,8 +1561,10 @@ void VUShared::QueueInFlagPipeline(const FLAG_PIPEINFO& pipeInfo, CMipsJitter* c codeGen->StoreAtRef(); } - assert(codeGen->GetTopCursor() == offsetCursor); codeGen->PullTop(); - assert(codeGen->GetTopCursor() == valueCursor); codeGen->PullTop(); + assert(codeGen->GetTopCursor() == offsetCursor); + codeGen->PullTop(); + assert(codeGen->GetTopCursor() == valueCursor); + codeGen->PullTop(); //Increment counter codeGen->PushRel(pipeInfo.index); @@ -1589,5 +1588,6 @@ void VUShared::ResetFlagPipeline(const FLAG_PIPEINFO& pipeInfo, CMipsJitter* cod codeGen->PullRel(pipeInfo.valueArray + (i * 4)); } - assert(codeGen->GetTopCursor() == valueCursor); codeGen->PullTop(); + assert(codeGen->GetTopCursor() == valueCursor); + codeGen->PullTop(); } diff --git a/Source/ee/VUShared.h b/Source/ee/VUShared.h index 86c45eb97..61a76816a 100644 --- a/Source/ee/VUShared.h +++ b/Source/ee/VUShared.h @@ -36,210 +36,210 @@ namespace VUShared struct OPERANDSET { - unsigned int writeF; - unsigned int readF0; - unsigned int readF1; - unsigned int writeI; - unsigned int readI0; - unsigned int readI1; - bool syncQ; - bool readQ; + unsigned int writeF; + unsigned int readF0; + unsigned int readF1; + unsigned int writeI; + unsigned int readI0; + unsigned int readI1; + bool syncQ; + bool readQ; //When set, means that a branch following the instruction will be //able to use the integer value directly - bool branchValue; + bool branchValue; }; struct VUINSTRUCTION; struct VUSUBTABLE { - uint32 nShift; - uint32 nMask; - VUINSTRUCTION* pTable; + uint32 nShift; + uint32 nMask; + VUINSTRUCTION* pTable; }; struct VUINSTRUCTION { - const char* name; - VUSUBTABLE* subTable; - void (*pGetAffectedOperands)(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32, uint32, OPERANDSET&); + const char* name; + VUSUBTABLE* subTable; + void (*pGetAffectedOperands)(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32, uint32, OPERANDSET&); }; - int32 GetImm11Offset(uint16); - int32 GetBranch(uint16); + int32 GetImm11Offset(uint16); + int32 GetBranch(uint16); - void VerifyVuReflectionTable(MIPSReflection::INSTRUCTION*, VUShared::VUINSTRUCTION*, size_t); + void VerifyVuReflectionTable(MIPSReflection::INSTRUCTION*, VUShared::VUINSTRUCTION*, size_t); - bool DestinationHasElement(uint8, unsigned int); - void ComputeMemAccessAddr(CMipsJitter*, unsigned int, uint32, uint32, uint32); - uint32 GetDestOffset(uint8); - uint32* GetVectorElement(CMIPS*, unsigned int, unsigned int); - size_t GetVectorElement(unsigned int, unsigned int); - uint32* GetAccumulatorElement(CMIPS*, unsigned int); - size_t GetAccumulatorElement(unsigned int); + bool DestinationHasElement(uint8, unsigned int); + void ComputeMemAccessAddr(CMipsJitter*, unsigned int, uint32, uint32, uint32); + uint32 GetDestOffset(uint8); + uint32* GetVectorElement(CMIPS*, unsigned int, unsigned int); + size_t GetVectorElement(unsigned int, unsigned int); + uint32* GetAccumulatorElement(CMIPS*, unsigned int); + size_t GetAccumulatorElement(unsigned int); - void PullVector(CMipsJitter*, uint8, size_t); - void PushIntegerRegister(CMipsJitter*, unsigned int); + void PullVector(CMipsJitter*, uint8, size_t); + void PushIntegerRegister(CMipsJitter*, unsigned int); - void ClampVector(CMipsJitter*); - void TestSZFlags(CMipsJitter*, uint8, size_t, uint32); + void ClampVector(CMipsJitter*); + void TestSZFlags(CMipsJitter*, uint8, size_t, uint32); - void GetStatus(CMipsJitter*, size_t, uint32); - void SetStatus(CMipsJitter*, size_t); + void GetStatus(CMipsJitter*, size_t, uint32); + void SetStatus(CMipsJitter*, size_t); - void ADDA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); - void MADD_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); - void MADDA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); - void SUB_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); - void SUBA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); - void MSUB_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); - void MSUBA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); - void MUL_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); - void MULA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); + void ADDA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); + void MADD_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); + void MADDA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); + void SUB_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); + void SUBA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); + void MSUB_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); + void MSUBA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); + void MUL_base(CMipsJitter*, uint8, size_t, size_t, size_t, bool, uint32); + void MULA_base(CMipsJitter*, uint8, size_t, size_t, bool, uint32); //Shared instructions - void ABS(CMipsJitter*, uint8, uint8, uint8); - void ADD(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void ADDbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); - void ADDi(CMipsJitter*, uint8, uint8, uint8, uint32); - void ADDq(CMipsJitter*, uint8, uint8, uint8, uint32); - void ADDA(CMipsJitter*, uint8, uint8, uint8, uint32); - void ADDAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void ADDAi(CMipsJitter*, uint8, uint8, uint32); - void CLIP(CMipsJitter*, uint8, uint8, uint32); - void DIV(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void FTOI0(CMipsJitter*, uint8, uint8, uint8); - void FTOI4(CMipsJitter*, uint8, uint8, uint8); - void FTOI12(CMipsJitter*, uint8, uint8, uint8); - void FTOI15(CMipsJitter*, uint8, uint8, uint8); - void IADD(CMipsJitter*, uint8, uint8, uint8); - void IADDI(CMipsJitter*, uint8, uint8, uint8); - void IAND(CMipsJitter*, uint8, uint8, uint8); - void ILWbase(CMipsJitter*, uint8); - void ILWR(CMipsJitter*, uint8, uint8, uint8, uint32); - void IOR(CMipsJitter*, uint8, uint8, uint8); - void ISUB(CMipsJitter*, uint8, uint8, uint8); - void ITOF0(CMipsJitter*, uint8, uint8, uint8); - void ITOF4(CMipsJitter*, uint8, uint8, uint8); - void ITOF12(CMipsJitter*, uint8, uint8, uint8); - void ITOF15(CMipsJitter*, uint8, uint8, uint8); - void ISWbase(CMipsJitter*, uint8); - void ISWR(CMipsJitter*, uint8, uint8, uint8, uint32); - void LQbase(CMipsJitter*, uint8, uint8); - void LQD(CMipsJitter*, uint8, uint8, uint8, uint32); - void LQI(CMipsJitter*, uint8, uint8, uint8, uint32); - void MADD(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MADDbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); - void MADDi(CMipsJitter*, uint8, uint8, uint8, uint32); - void MADDq(CMipsJitter*, uint8, uint8, uint8, uint32); - void MADDA(CMipsJitter*, uint8, uint8, uint8, uint32); - void MADDAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MADDAi(CMipsJitter*, uint8, uint8, uint32); - void MADDAq(CMipsJitter*, uint8, uint8, uint32); - void MAX(CMipsJitter*, uint8, uint8, uint8, uint8); - void MAXbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8); - void MAXi(CMipsJitter*, uint8, uint8, uint8); - void MINI(CMipsJitter*, uint8, uint8, uint8, uint8); - void MINIbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8); - void MINIi(CMipsJitter*, uint8, uint8, uint8); - void MOVE(CMipsJitter*, uint8, uint8, uint8); - void MR32(CMipsJitter*, uint8, uint8, uint8); - void MSUB(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MSUBbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); - void MSUBi(CMipsJitter*, uint8, uint8, uint8, uint32); - void MSUBq(CMipsJitter*, uint8, uint8, uint8, uint32); - void MSUBA(CMipsJitter*, uint8, uint8, uint8, uint32); - void MSUBAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MSUBAi(CMipsJitter*, uint8, uint8, uint32); - void MSUBAq(CMipsJitter*, uint8, uint8, uint32); - void MFIR(CMipsJitter*, uint8, uint8, uint8); - void MTIR(CMipsJitter*, uint8, uint8, uint8); - void MUL(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MULbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); - void MULi(CMipsJitter*, uint8, uint8, uint8, uint32); - void MULq(CMipsJitter*, uint8, uint8, uint8, uint32); - void MULA(CMipsJitter*, uint8, uint8, uint8, uint32); - void MULAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void MULAi(CMipsJitter*, uint8, uint8, uint32); - void MULAq(CMipsJitter*, uint8, uint8, uint32); - void OPMSUB(CMipsJitter*, uint8, uint8, uint8, uint32); - void OPMULA(CMipsJitter*, uint8, uint8); - void RINIT(CMipsJitter*, uint8, uint8); - void RGET(CMipsJitter*, uint8, uint8); - void RNEXT(CMipsJitter*, uint8, uint8); - void RSQRT(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void RXOR(CMipsJitter*, uint8, uint8); - void SQbase(CMipsJitter*, uint8, uint8); - void SQD(CMipsJitter*, uint8, uint8, uint8, uint32); - void SQI(CMipsJitter*, uint8, uint8, uint8, uint32); - void SQRT(CMipsJitter*, uint8, uint8, uint32); - void SUB(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void SUBbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); - void SUBi(CMipsJitter*, uint8, uint8, uint8, uint32); - void SUBq(CMipsJitter*, uint8, uint8, uint8, uint32); - void SUBA(CMipsJitter*, uint8, uint8, uint8, uint32); - void SUBAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); - void SUBAi(CMipsJitter*, uint8, uint8, uint32); - void WAITQ(CMipsJitter*); + void ABS(CMipsJitter*, uint8, uint8, uint8); + void ADD(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void ADDbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); + void ADDi(CMipsJitter*, uint8, uint8, uint8, uint32); + void ADDq(CMipsJitter*, uint8, uint8, uint8, uint32); + void ADDA(CMipsJitter*, uint8, uint8, uint8, uint32); + void ADDAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void ADDAi(CMipsJitter*, uint8, uint8, uint32); + void CLIP(CMipsJitter*, uint8, uint8, uint32); + void DIV(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void FTOI0(CMipsJitter*, uint8, uint8, uint8); + void FTOI4(CMipsJitter*, uint8, uint8, uint8); + void FTOI12(CMipsJitter*, uint8, uint8, uint8); + void FTOI15(CMipsJitter*, uint8, uint8, uint8); + void IADD(CMipsJitter*, uint8, uint8, uint8); + void IADDI(CMipsJitter*, uint8, uint8, uint8); + void IAND(CMipsJitter*, uint8, uint8, uint8); + void ILWbase(CMipsJitter*, uint8); + void ILWR(CMipsJitter*, uint8, uint8, uint8, uint32); + void IOR(CMipsJitter*, uint8, uint8, uint8); + void ISUB(CMipsJitter*, uint8, uint8, uint8); + void ITOF0(CMipsJitter*, uint8, uint8, uint8); + void ITOF4(CMipsJitter*, uint8, uint8, uint8); + void ITOF12(CMipsJitter*, uint8, uint8, uint8); + void ITOF15(CMipsJitter*, uint8, uint8, uint8); + void ISWbase(CMipsJitter*, uint8); + void ISWR(CMipsJitter*, uint8, uint8, uint8, uint32); + void LQbase(CMipsJitter*, uint8, uint8); + void LQD(CMipsJitter*, uint8, uint8, uint8, uint32); + void LQI(CMipsJitter*, uint8, uint8, uint8, uint32); + void MADD(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MADDbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); + void MADDi(CMipsJitter*, uint8, uint8, uint8, uint32); + void MADDq(CMipsJitter*, uint8, uint8, uint8, uint32); + void MADDA(CMipsJitter*, uint8, uint8, uint8, uint32); + void MADDAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MADDAi(CMipsJitter*, uint8, uint8, uint32); + void MADDAq(CMipsJitter*, uint8, uint8, uint32); + void MAX(CMipsJitter*, uint8, uint8, uint8, uint8); + void MAXbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8); + void MAXi(CMipsJitter*, uint8, uint8, uint8); + void MINI(CMipsJitter*, uint8, uint8, uint8, uint8); + void MINIbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8); + void MINIi(CMipsJitter*, uint8, uint8, uint8); + void MOVE(CMipsJitter*, uint8, uint8, uint8); + void MR32(CMipsJitter*, uint8, uint8, uint8); + void MSUB(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MSUBbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); + void MSUBi(CMipsJitter*, uint8, uint8, uint8, uint32); + void MSUBq(CMipsJitter*, uint8, uint8, uint8, uint32); + void MSUBA(CMipsJitter*, uint8, uint8, uint8, uint32); + void MSUBAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MSUBAi(CMipsJitter*, uint8, uint8, uint32); + void MSUBAq(CMipsJitter*, uint8, uint8, uint32); + void MFIR(CMipsJitter*, uint8, uint8, uint8); + void MTIR(CMipsJitter*, uint8, uint8, uint8); + void MUL(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MULbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); + void MULi(CMipsJitter*, uint8, uint8, uint8, uint32); + void MULq(CMipsJitter*, uint8, uint8, uint8, uint32); + void MULA(CMipsJitter*, uint8, uint8, uint8, uint32); + void MULAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void MULAi(CMipsJitter*, uint8, uint8, uint32); + void MULAq(CMipsJitter*, uint8, uint8, uint32); + void OPMSUB(CMipsJitter*, uint8, uint8, uint8, uint32); + void OPMULA(CMipsJitter*, uint8, uint8); + void RINIT(CMipsJitter*, uint8, uint8); + void RGET(CMipsJitter*, uint8, uint8); + void RNEXT(CMipsJitter*, uint8, uint8); + void RSQRT(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void RXOR(CMipsJitter*, uint8, uint8); + void SQbase(CMipsJitter*, uint8, uint8); + void SQD(CMipsJitter*, uint8, uint8, uint8, uint32); + void SQI(CMipsJitter*, uint8, uint8, uint8, uint32); + void SQRT(CMipsJitter*, uint8, uint8, uint32); + void SUB(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void SUBbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint8, uint32); + void SUBi(CMipsJitter*, uint8, uint8, uint8, uint32); + void SUBq(CMipsJitter*, uint8, uint8, uint8, uint32); + void SUBA(CMipsJitter*, uint8, uint8, uint8, uint32); + void SUBAbc(CMipsJitter*, uint8, uint8, uint8, uint8, uint32); + void SUBAi(CMipsJitter*, uint8, uint8, uint32); + void WAITQ(CMipsJitter*); - void FlushPipeline(const REGISTER_PIPEINFO&, CMipsJitter*); - void CheckPipeline(const REGISTER_PIPEINFO&, CMipsJitter*, uint32); - void QueueInPipeline(const REGISTER_PIPEINFO&, CMipsJitter*, uint32, uint32); - void CheckFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*, uint32); - void QueueInFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*, uint32, uint32); - void ResetFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*); + void FlushPipeline(const REGISTER_PIPEINFO&, CMipsJitter*); + void CheckPipeline(const REGISTER_PIPEINFO&, CMipsJitter*, uint32); + void QueueInPipeline(const REGISTER_PIPEINFO&, CMipsJitter*, uint32, uint32); + void CheckFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*, uint32); + void QueueInFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*, uint32, uint32); + void ResetFlagPipeline(const FLAG_PIPEINFO&, CMipsJitter*); //Shared addressing modes - void ReflOpFdFsI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFdFsQ(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFdFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFdFsFtBc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFsDstItDec(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFsDstItInc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFtIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFtDstIsDec(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFtDstIsInc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpClip(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpAccFsI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpAccFsQ(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpAccFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpAccFsFtBc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpRFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpFtR(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpQFtf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpQFsfFtf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpIdIsIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpItFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpItIsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpItIsImm5(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFdFsI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFdFsQ(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFdFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFdFsFtBc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFsDstItDec(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFsDstItInc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFtFs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFtIs(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFtDstIsDec(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFtDstIsInc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpClip(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpAccFsI(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpAccFsQ(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpAccFsFt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpAccFsFtBc(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpRFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpFtR(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpQFtf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpQFsfFtf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpIdIsIt(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpItFsf(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpItIsDst(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); + void ReflOpItIsImm5(MIPSReflection::INSTRUCTION*, CMIPS*, uint32, uint32, char*, unsigned int); - void ReflOpAffNone(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffAccFsI(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffFdFsQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffFdFsI(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffRFsf(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffFtR(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - - void ReflOpAffWrARdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffWrARdFsQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffWrCfRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffWrFdRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffWrQRdFt(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - void ReflOpAffWrQRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffNone(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffAccFsI(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffFdFsQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffFdFsI(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffRFsf(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffFtR(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - VUINSTRUCTION* DereferenceInstruction(VUSUBTABLE*, uint32); - void SubTableAffectedOperands(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32, uint32, OPERANDSET&); + void ReflOpAffWrARdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffWrARdFsQ(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffWrCfRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffWrFdRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffWrQRdFt(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); + void ReflOpAffWrQRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32, OPERANDSET&); - extern const char* m_sBroadcast[4]; - extern const char* m_sDestination[16]; + VUINSTRUCTION* DereferenceInstruction(VUSUBTABLE*, uint32); + void SubTableAffectedOperands(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32, uint32, OPERANDSET&); + + extern const char* m_sBroadcast[4]; + extern const char* m_sDestination[16]; extern const REGISTER_PIPEINFO g_pipeInfoQ; - extern const FLAG_PIPEINFO g_pipeInfoMac; - extern const FLAG_PIPEINFO g_pipeInfoClip; + extern const FLAG_PIPEINFO g_pipeInfoMac; + extern const FLAG_PIPEINFO g_pipeInfoClip; } #endif diff --git a/Source/ee/VUShared_Reflection.cpp b/Source/ee/VUShared_Reflection.cpp index 9fed6f199..5e1f8ba4a 100644 --- a/Source/ee/VUShared_Reflection.cpp +++ b/Source/ee/VUShared_Reflection.cpp @@ -5,31 +5,31 @@ using namespace MIPSReflection; using namespace VUShared; const char* VUShared::m_sBroadcast[4] = -{ - "x", - "y", - "z", - "w", + { + "x", + "y", + "z", + "w", }; const char* VUShared::m_sDestination[16] = -{ - "", //0000 - "w", //000w - "z", //00z0 - "zw", //00zw - "y", //0y00 - "yw", //0y0w - "yz", //0yz0 - "yzw", //0yzw - "x", //x000 - "xw", //x00w - "xz", //x0z0 - "xzw", //x0zw - "xy", //xy00 - "xyw", //xy0w - "xyz", //xyz0 - "xyzw", //xyzw + { + "", //0000 + "w", //000w + "z", //00z0 + "zw", //00zw + "y", //0y00 + "yw", //0y0w + "yz", //0yz0 + "yzw", //0yzw + "x", //x000 + "xw", //x00w + "xz", //x0z0 + "xzw", //x0zw + "xy", //xy00 + "xyw", //xy0w + "xyz", //xyz0 + "xyzw", //xyzw }; int32 VUShared::GetImm11Offset(uint16 nImm11) @@ -68,179 +68,179 @@ void VUShared::VerifyVuReflectionTable(MIPSReflection::INSTRUCTION* refl, VUShar void VUShared::ReflOpFdFsI(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s, I", nFD, m_sDestination[nDest], nFS, m_sDestination[nDest]); } void VUShared::ReflOpFdFsQ(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s, Q", nFD, m_sDestination[nDest], nFS, m_sDestination[nDest]); } void VUShared::ReflOpFdFsFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s, VF%i%s", nFD, m_sDestination[nDest], nFS, m_sDestination[nDest], nFT, m_sDestination[nDest]); } void VUShared::ReflOpFdFsFtBc(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); - uint8 nBc = (uint8)((nOpcode >> 0) & 0x0003); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nBc = (uint8)((nOpcode >> 0) & 0x0003); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s, VF%i%s", nFD, m_sDestination[nDest], nFS, m_sDestination[nDest], nFT, m_sBroadcast[nBc]); } void VUShared::ReflOpFsDstItDec(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); - uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); sprintf(sText, "VF%i%s, (--VI%i)", nFS, m_sDestination[nDest], nIT); } void VUShared::ReflOpFsDstItInc(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); - uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); sprintf(sText, "VF%i%s, (VI%i++)", nFS, m_sDestination[nDest], nIT); } void VUShared::ReflOpFtFs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "VF%i%s, VF%i%s", nFT, m_sDestination[nDest], nFS, m_sDestination[nDest]); } void VUShared::ReflOpFtIs(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); - uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nIS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nFT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nIS = static_cast((nOpcode >> 11) & 0x001F); sprintf(sText, "VF%i%s, VI%i", nFT, m_sDestination[nDest], nIS); } void VUShared::ReflOpFtDstIsDec(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - auto dest = static_cast((opcode >> 21) & 0x000F); - auto ft = static_cast((opcode >> 16) & 0x001F); - auto is = static_cast((opcode >> 11) & 0x001F); + auto dest = static_cast((opcode >> 21) & 0x000F); + auto ft = static_cast((opcode >> 16) & 0x001F); + auto is = static_cast((opcode >> 11) & 0x001F); sprintf(text, "VF%i%s, (--VI%i)", ft, m_sDestination[dest], is); } void VUShared::ReflOpFtDstIsInc(INSTRUCTION*, CMIPS*, uint32, uint32 opcode, char* text, unsigned int count) { - auto dest = static_cast((opcode >> 21) & 0x000F); - auto ft = static_cast((opcode >> 16) & 0x001F); - auto is = static_cast((opcode >> 11) & 0x001F); + auto dest = static_cast((opcode >> 21) & 0x000F); + auto ft = static_cast((opcode >> 16) & 0x001F); + auto is = static_cast((opcode >> 11) & 0x001F); sprintf(text, "VF%i%s, (VI%i++)", ft, m_sDestination[dest], is); } void VUShared::ReflOpClip(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); sprintf(sText, "VF%ixyz, VF%iw", nFS, nFT); } void VUShared::ReflOpAccFsI(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); sprintf(sText, "ACC%s, VF%i%s, I", m_sDestination[nDest], nFS, m_sDestination[nDest]); } void VUShared::ReflOpAccFsQ(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nDest = static_cast((nOpcode >> 21) & 0x000F); sprintf(sText, "ACC%s, VF%i%s, Q", m_sDestination[nDest], nFS, m_sDestination[nDest]); } void VUShared::ReflOpAccFsFt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "ACC%s, VF%i%s, VF%i%s", m_sDestination[nDest], nFS, m_sDestination[nDest], nFT, m_sDestination[nDest]); } void VUShared::ReflOpAccFsFtBc(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nBc = (uint8)((nOpcode >> 0) & 0x0003); - uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nBc = (uint8)((nOpcode >> 0) & 0x0003); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); sprintf(sText, "ACC%s, VF%i%s, VF%i%s", m_sDestination[nDest], nFS, m_sDestination[nDest], nFT, m_sBroadcast[nBc]); } void VUShared::ReflOpRFsf(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFS = (uint8 )((nOpcode >> 11) & 0x001F); - uint8 nFSF = (uint8 )((nOpcode >> 21) & 0x0003); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFSF = (uint8)((nOpcode >> 21) & 0x0003); sprintf(sText, "R, VF%i%s", nFS, m_sBroadcast[nFSF]); } void VUShared::ReflOpFtR(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nDest = (uint8 )((nOpcode >> 21) & 0x000F); - uint8 nFT = (uint8 )((nOpcode >> 16) & 0x001F); + uint8 nDest = (uint8)((nOpcode >> 21) & 0x000F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); sprintf(sText, "VF%i%s, R", nFT, m_sDestination[nDest]); } void VUShared::ReflOpQFtf(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFTF = (uint8)((nOpcode >> 23) & 0x0003); + uint8 nFTF = (uint8)((nOpcode >> 23) & 0x0003); sprintf(sText, "Q, VF%i%s", nFT, m_sBroadcast[nFTF]); } void VUShared::ReflOpQFsfFtf(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFTF = (uint8)((nOpcode >> 23) & 0x0003); - uint8 nFSF = (uint8)((nOpcode >> 21) & 0x0003); + uint8 nFTF = (uint8)((nOpcode >> 23) & 0x0003); + uint8 nFSF = (uint8)((nOpcode >> 21) & 0x0003); sprintf(sText, "Q, VF%i%s, VF%i%s", nFS, m_sBroadcast[nFSF], nFT, m_sBroadcast[nFTF]); } @@ -249,25 +249,25 @@ void VUShared::ReflOpIdIsIt(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, u { uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); uint8 nIS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nID = static_cast((nOpcode >> 6) & 0x001F); + uint8 nID = static_cast((nOpcode >> 6) & 0x001F); sprintf(sText, "VI%i, VI%i, VI%i", nID, nIS, nIT); } void VUShared::ReflOpItIsDst(INSTRUCTION* instr, CMIPS* context, uint32 address, uint32 opcode, char* text, unsigned int count) { - uint8 dest = static_cast((opcode >> 21) & 0x000F); - uint8 it = static_cast((opcode >> 16) & 0x001F); - uint8 is = static_cast((opcode >> 11) & 0x001F); + uint8 dest = static_cast((opcode >> 21) & 0x000F); + uint8 it = static_cast((opcode >> 16) & 0x001F); + uint8 is = static_cast((opcode >> 11) & 0x001F); sprintf(text, "VI%i, (VI%i)%s", it, is, m_sDestination[dest]); } void VUShared::ReflOpItIsImm5(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nIS = static_cast((nOpcode >> 11) & 0x001F); - uint16 nImm = static_cast((nOpcode >> 6) & 0x001F); + uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nIS = static_cast((nOpcode >> 11) & 0x001F); + uint16 nImm = static_cast((nOpcode >> 6) & 0x001F); if(nImm & 0x10) { nImm |= 0xFFE0; @@ -278,9 +278,9 @@ void VUShared::ReflOpItIsImm5(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, void VUShared::ReflOpItFsf(INSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, char* sText, unsigned int nCount) { - uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); - uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); - uint8 nFSF = static_cast((nOpcode >> 21) & 0x0003); + uint8 nIT = static_cast((nOpcode >> 16) & 0x001F); + uint8 nFS = static_cast((nOpcode >> 11) & 0x001F); + uint8 nFSF = static_cast((nOpcode >> 21) & 0x0003); sprintf(sText, "VI%i, VF%i%s", nIT, nFS, m_sBroadcast[nFSF]); } @@ -312,15 +312,15 @@ void VUShared::ReflOpAffNone(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress void VUShared::ReflOpAffAccFsI(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); operandSet.readF0 = nFS; } void VUShared::ReflOpAffFdFsQ(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); operandSet.readF0 = nFS; operandSet.writeF = nFD; @@ -329,8 +329,8 @@ void VUShared::ReflOpAffFdFsQ(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddres void VUShared::ReflOpAffFdFsI(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); - uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFD = (uint8)((nOpcode >> 6) & 0x001F); operandSet.readF0 = nFS; operandSet.writeF = nFD; @@ -338,8 +338,8 @@ void VUShared::ReflOpAffFdFsI(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddres void VUShared::ReflOpAffFtFs(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); - uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); operandSet.readF0 = nFS; operandSet.writeF = nFT; @@ -347,13 +347,13 @@ void VUShared::ReflOpAffFtFs(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress void VUShared::ReflOpAffRFsf(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFS = (uint8 )((nOpcode >> 11) & 0x001F); + uint8 nFS = (uint8)((nOpcode >> 11) & 0x001F); operandSet.readF0 = nFS; } void VUShared::ReflOpAffFtR(VUINSTRUCTION* pInstr, CMIPS* pCtx, uint32 nAddress, uint32 nOpcode, OPERANDSET& operandSet) { - uint8 nFT = (uint8 )((nOpcode >> 16) & 0x001F); + uint8 nFT = (uint8)((nOpcode >> 16) & 0x001F); operandSet.writeF = nFT; } @@ -396,7 +396,7 @@ void VUShared::ReflOpAffWrFdRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32 opcode { auto ft = static_cast((opcode >> 16) & 0x001F); auto fs = static_cast((opcode >> 11) & 0x001F); - auto fd = static_cast((opcode >> 6) & 0x001F); + auto fd = static_cast((opcode >> 6) & 0x001F); operandSet.writeF = fd; operandSet.readF0 = ft; @@ -406,7 +406,7 @@ void VUShared::ReflOpAffWrFdRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32 opcode void VUShared::ReflOpAffWrQRdFt(VUINSTRUCTION*, CMIPS*, uint32, uint32 opcode, OPERANDSET& operandSet) { auto ft = static_cast((opcode >> 16) & 0x001F); - + //Would probably be write Q operandSet.readF0 = ft; operandSet.syncQ = true; @@ -416,7 +416,7 @@ void VUShared::ReflOpAffWrQRdFtFs(VUINSTRUCTION*, CMIPS*, uint32, uint32 opcode, { auto ft = static_cast((opcode >> 16) & 0x001F); auto fs = static_cast((opcode >> 11) & 0x001F); - + //Would probably be write Q operandSet.readF0 = ft; operandSet.readF1 = fs; diff --git a/Source/ee/Vif.cpp b/Source/ee/Vif.cpp index 25f543079..f8c3a7e92 100644 --- a/Source/ee/Vif.cpp +++ b/Source/ee/Vif.cpp @@ -11,40 +11,39 @@ #define LOG_NAME ("vif") -#define STATE_PATH_REGS_FORMAT ("vpu/vif_%d.xml") -#define STATE_PATH_FIFO_FORMAT ("vpu/vif_%d_fifo") +#define STATE_PATH_REGS_FORMAT ("vpu/vif_%d.xml") +#define STATE_PATH_FIFO_FORMAT ("vpu/vif_%d_fifo") -#define STATE_REGS_STAT ("STAT") -#define STATE_REGS_CODE ("CODE") -#define STATE_REGS_CYCLE ("CYCLE") -#define STATE_REGS_NUM ("NUM") -#define STATE_REGS_MASK ("MASK") -#define STATE_REGS_MODE ("MODE") -#define STATE_REGS_ROW0 ("ROW0") -#define STATE_REGS_ROW1 ("ROW1") -#define STATE_REGS_ROW2 ("ROW2") -#define STATE_REGS_ROW3 ("ROW3") -#define STATE_REGS_COL0 ("COL0") -#define STATE_REGS_COL1 ("COL1") -#define STATE_REGS_COL2 ("COL2") -#define STATE_REGS_COL3 ("COL3") -#define STATE_REGS_MARK ("MARK") -#define STATE_REGS_ITOP ("ITOP") -#define STATE_REGS_ITOPS ("ITOPS") -#define STATE_REGS_READTICK ("readTick") -#define STATE_REGS_WRITETICK ("writeTick") -#define STATE_REGS_FIFOINDEX ("fifoIndex") +#define STATE_REGS_STAT ("STAT") +#define STATE_REGS_CODE ("CODE") +#define STATE_REGS_CYCLE ("CYCLE") +#define STATE_REGS_NUM ("NUM") +#define STATE_REGS_MASK ("MASK") +#define STATE_REGS_MODE ("MODE") +#define STATE_REGS_ROW0 ("ROW0") +#define STATE_REGS_ROW1 ("ROW1") +#define STATE_REGS_ROW2 ("ROW2") +#define STATE_REGS_ROW3 ("ROW3") +#define STATE_REGS_COL0 ("COL0") +#define STATE_REGS_COL1 ("COL1") +#define STATE_REGS_COL2 ("COL2") +#define STATE_REGS_COL3 ("COL3") +#define STATE_REGS_MARK ("MARK") +#define STATE_REGS_ITOP ("ITOP") +#define STATE_REGS_ITOPS ("ITOPS") +#define STATE_REGS_READTICK ("readTick") +#define STATE_REGS_WRITETICK ("writeTick") +#define STATE_REGS_FIFOINDEX ("fifoIndex") CVif::CVif(unsigned int number, CVpu& vpu, CINTC& intc, uint8* ram, uint8* spr) -: m_number(number) -, m_ram(ram) -, m_spr(spr) -, m_intc(intc) -, m_stream(ram, spr) -, m_vpu(vpu) -, m_vifProfilerZone(CProfiler::GetInstance().RegisterZone(string_format("VIF%d", number).c_str())) + : m_number(number) + , m_ram(ram) + , m_spr(spr) + , m_intc(intc) + , m_stream(ram, spr) + , m_vpu(vpu) + , m_vifProfilerZone(CProfiler::GetInstance().RegisterZone(string_format("VIF%d", number).c_str())) { - } void CVif::Reset() @@ -133,9 +132,8 @@ uint32 CVif::GetRegister(uint32 address) void CVif::SetRegister(uint32 address, uint32 value) { if( - (address >= VIF0_FIFO_START && address < VIF0_FIFO_END) || - (address >= VIF1_FIFO_START && address < VIF1_FIFO_END) - ) + (address >= VIF0_FIFO_START && address < VIF0_FIFO_END) || + (address >= VIF1_FIFO_START && address < VIF1_FIFO_END)) { ProcessFifoWrite(address, value); } @@ -177,26 +175,26 @@ void CVif::SaveState(Framework::CZipArchiveWriter& archive) { auto path = string_format(STATE_PATH_REGS_FORMAT, m_number); auto registerFile = new CRegisterStateFile(path.c_str()); - registerFile->SetRegister32(STATE_REGS_STAT, m_STAT); - registerFile->SetRegister32(STATE_REGS_CODE, m_CODE); - registerFile->SetRegister32(STATE_REGS_CYCLE, m_CYCLE); - registerFile->SetRegister32(STATE_REGS_NUM, m_NUM); - registerFile->SetRegister32(STATE_REGS_MODE, m_MODE); - registerFile->SetRegister32(STATE_REGS_MASK, m_MASK); - registerFile->SetRegister32(STATE_REGS_MARK, m_MARK); - registerFile->SetRegister32(STATE_REGS_ROW0, m_R[0]); - registerFile->SetRegister32(STATE_REGS_ROW1, m_R[1]); - registerFile->SetRegister32(STATE_REGS_ROW2, m_R[2]); - registerFile->SetRegister32(STATE_REGS_ROW3, m_R[3]); - registerFile->SetRegister32(STATE_REGS_COL0, m_C[0]); - registerFile->SetRegister32(STATE_REGS_COL1, m_C[1]); - registerFile->SetRegister32(STATE_REGS_COL2, m_C[2]); - registerFile->SetRegister32(STATE_REGS_COL3, m_C[3]); - registerFile->SetRegister32(STATE_REGS_ITOP, m_ITOP); - registerFile->SetRegister32(STATE_REGS_ITOPS, m_ITOPS); - registerFile->SetRegister32(STATE_REGS_READTICK, m_readTick); - registerFile->SetRegister32(STATE_REGS_WRITETICK, m_writeTick); - registerFile->SetRegister32(STATE_REGS_FIFOINDEX, m_fifoIndex); + registerFile->SetRegister32(STATE_REGS_STAT, m_STAT); + registerFile->SetRegister32(STATE_REGS_CODE, m_CODE); + registerFile->SetRegister32(STATE_REGS_CYCLE, m_CYCLE); + registerFile->SetRegister32(STATE_REGS_NUM, m_NUM); + registerFile->SetRegister32(STATE_REGS_MODE, m_MODE); + registerFile->SetRegister32(STATE_REGS_MASK, m_MASK); + registerFile->SetRegister32(STATE_REGS_MARK, m_MARK); + registerFile->SetRegister32(STATE_REGS_ROW0, m_R[0]); + registerFile->SetRegister32(STATE_REGS_ROW1, m_R[1]); + registerFile->SetRegister32(STATE_REGS_ROW2, m_R[2]); + registerFile->SetRegister32(STATE_REGS_ROW3, m_R[3]); + registerFile->SetRegister32(STATE_REGS_COL0, m_C[0]); + registerFile->SetRegister32(STATE_REGS_COL1, m_C[1]); + registerFile->SetRegister32(STATE_REGS_COL2, m_C[2]); + registerFile->SetRegister32(STATE_REGS_COL3, m_C[3]); + registerFile->SetRegister32(STATE_REGS_ITOP, m_ITOP); + registerFile->SetRegister32(STATE_REGS_ITOPS, m_ITOPS); + registerFile->SetRegister32(STATE_REGS_READTICK, m_readTick); + registerFile->SetRegister32(STATE_REGS_WRITETICK, m_writeTick); + registerFile->SetRegister32(STATE_REGS_FIFOINDEX, m_fifoIndex); archive.InsertFile(registerFile); } { @@ -210,26 +208,26 @@ void CVif::LoadState(Framework::CZipArchiveReader& archive) { auto path = string_format(STATE_PATH_REGS_FORMAT, m_number); CRegisterStateFile registerFile(*archive.BeginReadFile(path.c_str())); - m_STAT <<= registerFile.GetRegister32(STATE_REGS_STAT); - m_CODE <<= registerFile.GetRegister32(STATE_REGS_CODE); - m_CYCLE <<= registerFile.GetRegister32(STATE_REGS_CYCLE); - m_NUM = static_cast(registerFile.GetRegister32(STATE_REGS_NUM)); - m_MODE = registerFile.GetRegister32(STATE_REGS_MODE); - m_MASK = registerFile.GetRegister32(STATE_REGS_MASK); - m_MARK = registerFile.GetRegister32(STATE_REGS_MARK); - m_R[0] = registerFile.GetRegister32(STATE_REGS_ROW0); - m_R[1] = registerFile.GetRegister32(STATE_REGS_ROW1); - m_R[2] = registerFile.GetRegister32(STATE_REGS_ROW2); - m_R[3] = registerFile.GetRegister32(STATE_REGS_ROW3); - m_C[0] = registerFile.GetRegister32(STATE_REGS_COL0); - m_C[1] = registerFile.GetRegister32(STATE_REGS_COL1); - m_C[2] = registerFile.GetRegister32(STATE_REGS_COL2); - m_C[3] = registerFile.GetRegister32(STATE_REGS_COL3); - m_ITOP = registerFile.GetRegister32(STATE_REGS_ITOP); - m_ITOPS = registerFile.GetRegister32(STATE_REGS_ITOPS); - m_readTick = registerFile.GetRegister32(STATE_REGS_READTICK); - m_writeTick = registerFile.GetRegister32(STATE_REGS_WRITETICK); - m_fifoIndex = registerFile.GetRegister32(STATE_REGS_FIFOINDEX); + m_STAT <<= registerFile.GetRegister32(STATE_REGS_STAT); + m_CODE <<= registerFile.GetRegister32(STATE_REGS_CODE); + m_CYCLE <<= registerFile.GetRegister32(STATE_REGS_CYCLE); + m_NUM = static_cast(registerFile.GetRegister32(STATE_REGS_NUM)); + m_MODE = registerFile.GetRegister32(STATE_REGS_MODE); + m_MASK = registerFile.GetRegister32(STATE_REGS_MASK); + m_MARK = registerFile.GetRegister32(STATE_REGS_MARK); + m_R[0] = registerFile.GetRegister32(STATE_REGS_ROW0); + m_R[1] = registerFile.GetRegister32(STATE_REGS_ROW1); + m_R[2] = registerFile.GetRegister32(STATE_REGS_ROW2); + m_R[3] = registerFile.GetRegister32(STATE_REGS_ROW3); + m_C[0] = registerFile.GetRegister32(STATE_REGS_COL0); + m_C[1] = registerFile.GetRegister32(STATE_REGS_COL1); + m_C[2] = registerFile.GetRegister32(STATE_REGS_COL2); + m_C[3] = registerFile.GetRegister32(STATE_REGS_COL3); + m_ITOP = registerFile.GetRegister32(STATE_REGS_ITOP); + m_ITOPS = registerFile.GetRegister32(STATE_REGS_ITOPS); + m_readTick = registerFile.GetRegister32(STATE_REGS_READTICK); + m_writeTick = registerFile.GetRegister32(STATE_REGS_WRITETICK); + m_fifoIndex = registerFile.GetRegister32(STATE_REGS_FIFOINDEX); } { auto path = string_format(STATE_PATH_FIFO_FORMAT, m_number); @@ -261,7 +259,7 @@ uint32 CVif::ReceiveDMA(uint32 address, uint32 qwc, uint32 unused, bool tagInclu #ifdef _DEBUG CLog::GetInstance().Print(LOG_NAME, "vif%i : Processing packet @ 0x%08X, qwc = 0x%X, tagIncluded = %i\r\n", - m_number, address, qwc, static_cast(tagIncluded)); + m_number, address, qwc, static_cast(tagIncluded)); #endif m_stream.SetDmaParams(address, qwc * 0x10, tagIncluded); @@ -373,7 +371,7 @@ void CVif::ExecuteCommand(StreamType& stream, CODE nCommand) { #ifdef DELAYED_MSCAL //Check if previous cmd was MSCAL and if we have a pending MSCAL - if(m_previousCODE.nCMD == 0x14) + if(m_previousCODE.nCMD == 0x14) { uint32 prevImm = m_pendingMicroProgram / 8; if(ResumeDelayedMicroProgram()) @@ -443,7 +441,7 @@ void CVif::ExecuteCommand(StreamType& stream, CODE nCommand) break; case 0x15: //MSCALF - //TODO: Wait for GIF PATH 1 and 2 transfers to be over + //TODO: Wait for GIF PATH 1 and 2 transfers to be over StartMicroProgram(nCommand.nIMM * 8); break; case 0x17: @@ -476,9 +474,9 @@ void CVif::Cmd_MPG(StreamType& stream, CODE nCommand) { uint32 nSize = stream.GetAvailableReadBytes(); - uint32 nNum = (m_NUM == 0) ? (256) : (m_NUM); - uint32 nCodeNum = (m_CODE.nNUM == 0) ? (256) : (m_CODE.nNUM); - uint32 nTransfered = (nCodeNum - nNum) * 8; + uint32 nNum = (m_NUM == 0) ? (256) : (m_NUM); + uint32 nCodeNum = (m_CODE.nNUM == 0) ? (256) : (m_CODE.nNUM); + uint32 nTransfered = (nCodeNum - nNum) * 8; nCodeNum *= 8; nNum *= 8; @@ -600,7 +598,7 @@ void CVif::Cmd_UNPACK(StreamType& stream, CODE nCommand, uint32 nDstAddr) bool useMask = (nCommand.nCMD & 0x10) != 0; uint32 cl = m_CYCLE.nCL; uint32 wl = m_CYCLE.nWL; - if(wl == 0) + if(wl == 0) { wl = UINT_MAX; cl = 0; @@ -693,7 +691,7 @@ void CVif::Cmd_UNPACK(StreamType& stream, CODE nCommand, uint32 nDstAddr) assert(0); } } - + currentNum--; } @@ -908,8 +906,8 @@ bool CVif::Unpack_V45(StreamType& stream, uint128& result) uint16 nColor = 0; stream.Read(&nColor, 2); - result.nV0 = ((nColor >> 0) & 0x1F) << 3; - result.nV1 = ((nColor >> 5) & 0x1F) << 3; + result.nV0 = ((nColor >> 0) & 0x1F) << 3; + result.nV1 = ((nColor >> 5) & 0x1F) << 3; result.nV2 = ((nColor >> 10) & 0x1F) << 3; result.nV3 = ((nColor >> 15) & 0x01) << 7; @@ -977,7 +975,10 @@ bool CVif::ResumeDelayedMicroProgram() void CVif::DisassembleGet(uint32 address) { -#define LOG_GET(registerId) case registerId: CLog::GetInstance().Print(LOG_NAME, "= " #registerId ".\r\n"); break; +#define LOG_GET(registerId) \ + case registerId: \ + CLog::GetInstance().Print(LOG_NAME, "= " #registerId ".\r\n"); \ + break; switch(address) { @@ -1023,7 +1024,10 @@ void CVif::DisassembleSet(uint32 address, uint32 value) } else { -#define LOG_SET(registerId) case registerId: CLog::GetInstance().Print(LOG_NAME, #registerId " = 0x%08X.\r\n", value); break; +#define LOG_SET(registerId) \ + case registerId: \ + CLog::GetInstance().Print(LOG_NAME, #registerId " = 0x%08X.\r\n", value); \ + break; switch(address) { @@ -1055,27 +1059,26 @@ void CVif::DisassembleCommand(CODE code) if(code.nCMD >= 0x60) { - static const char* packFormats[16] = - { - "S-32", - "S-16", - "S-8", - "(Unknown)", - "V2-32", - "V2-16", - "V2-8", - "(Unknown)", - "V3-32", - "V3-16", - "V3-8", - "(Unknown)", - "V4-32", - "V4-16", - "V4-8", - "V4-5" - }; + static const char* packFormats[16] = + { + "S-32", + "S-16", + "S-8", + "(Unknown)", + "V2-32", + "V2-16", + "V2-8", + "(Unknown)", + "V3-32", + "V3-16", + "V3-8", + "(Unknown)", + "V4-32", + "V4-16", + "V4-8", + "V4-5"}; CLog::GetInstance().Print(LOG_NAME, "UNPACK(format = %s, imm = 0x%x, num = 0x%x);\r\n", - packFormats[code.nCMD & 0x0F], code.nIMM, code.nNUM); + packFormats[code.nCMD & 0x0F], code.nIMM, code.nNUM); } else { @@ -1151,11 +1154,10 @@ void CVif::DisassembleCommand(CODE code) //CFifoStream //-------------------------------------------------- -CVif::CFifoStream::CFifoStream(uint8* ram, uint8* spr) -: m_ram(ram) -, m_spr(spr) +CVif::CFifoStream::CFifoStream(uint8* ram, uint8* spr) + : m_ram(ram) + , m_spr(spr) { - } void CVif::CFifoStream::Reset() diff --git a/Source/ee/Vif.h b/Source/ee/Vif.h index 44da16a64..0b1993431 100644 --- a/Source/ee/Vif.h +++ b/Source/ee/Vif.h @@ -17,55 +17,55 @@ class CVif public: enum { - REGS0_START = 0x10003800, - VIF0_STAT = 0x10003800, - VIF0_FBRST = 0x10003810, - VIF0_MARK = 0x10003830, - VIF0_CYCLE = 0x10003840, - VIF0_MODE = 0x10003850, - VIF0_NUM = 0x10003860, - VIF0_CODE = 0x10003880, - VIF0_R0 = 0x10003900, - VIF0_R1 = 0x10003910, - VIF0_R2 = 0x10003920, - VIF0_R3 = 0x10003930, - REGS0_END = 0x10003A00, + REGS0_START = 0x10003800, + VIF0_STAT = 0x10003800, + VIF0_FBRST = 0x10003810, + VIF0_MARK = 0x10003830, + VIF0_CYCLE = 0x10003840, + VIF0_MODE = 0x10003850, + VIF0_NUM = 0x10003860, + VIF0_CODE = 0x10003880, + VIF0_R0 = 0x10003900, + VIF0_R1 = 0x10003910, + VIF0_R2 = 0x10003920, + VIF0_R3 = 0x10003930, + REGS0_END = 0x10003A00, - REGS1_START = 0x10003C00, - VIF1_STAT = 0x10003C00, - VIF1_FBRST = 0x10003C10, - VIF1_MARK = 0x10003C30, - VIF1_CYCLE = 0x10003C40, - VIF1_MODE = 0x10003C50, - VIF1_NUM = 0x10003C60, - VIF1_CODE = 0x10003C80, - VIF1_R0 = 0x10003D00, - VIF1_R1 = 0x10003D10, - VIF1_R2 = 0x10003D20, - VIF1_R3 = 0x10003D30, - REGS1_END = 0x10003E00, + REGS1_START = 0x10003C00, + VIF1_STAT = 0x10003C00, + VIF1_FBRST = 0x10003C10, + VIF1_MARK = 0x10003C30, + VIF1_CYCLE = 0x10003C40, + VIF1_MODE = 0x10003C50, + VIF1_NUM = 0x10003C60, + VIF1_CODE = 0x10003C80, + VIF1_R0 = 0x10003D00, + VIF1_R1 = 0x10003D10, + VIF1_R2 = 0x10003D20, + VIF1_R3 = 0x10003D30, + REGS1_END = 0x10003E00, - VIF0_FIFO_START = 0x10004000, - VIF0_FIFO_END = 0x10004FFF, - VIF1_FIFO_START = 0x10005000, - VIF1_FIFO_END = 0x10005FFF, + VIF0_FIFO_START = 0x10004000, + VIF0_FIFO_END = 0x10004FFF, + VIF1_FIFO_START = 0x10005000, + VIF1_FIFO_END = 0x10005FFF, }; - CVif(unsigned int, CVpu&, CINTC&, uint8*, uint8*); - virtual ~CVif() = default; + CVif(unsigned int, CVpu&, CINTC&, uint8*, uint8*); + virtual ~CVif() = default; - virtual void Reset(); - uint32 GetRegister(uint32); - void SetRegister(uint32, uint32); - virtual void SaveState(Framework::CZipArchiveWriter&); - virtual void LoadState(Framework::CZipArchiveReader&); + virtual void Reset(); + uint32 GetRegister(uint32); + void SetRegister(uint32, uint32); + virtual void SaveState(Framework::CZipArchiveWriter&); + virtual void LoadState(Framework::CZipArchiveReader&); - virtual uint32 GetTOP() const; - virtual uint32 GetITOP() const; + virtual uint32 GetTOP() const; + virtual uint32 GetITOP() const; - virtual uint32 ReceiveDMA(uint32, uint32, uint32, bool); + virtual uint32 ReceiveDMA(uint32, uint32, uint32, bool); - bool IsWaitingForProgramEnd() const; + bool IsWaitingForProgramEnd() const; protected: enum @@ -87,78 +87,78 @@ protected: class CFifoStream { public: - CFifoStream(uint8*, uint8*); - virtual ~CFifoStream() = default; + CFifoStream(uint8*, uint8*); + virtual ~CFifoStream() = default; - void Reset(); + void Reset(); - uint32 GetAvailableReadBytes() const; - uint32 GetRemainingDmaTransferSize() const; - void Read(void*, uint32); - void Flush(); - void Align32(); - void SetDmaParams(uint32, uint32, bool); - void SetFifoParams(uint8*, uint32); + uint32 GetAvailableReadBytes() const; + uint32 GetRemainingDmaTransferSize() const; + void Read(void*, uint32); + void Flush(); + void Align32(); + void SetDmaParams(uint32, uint32, bool); + void SetFifoParams(uint8*, uint32); - uint8* GetDirectPointer() const; - void Advance(uint32); + uint8* GetDirectPointer() const; + void Advance(uint32); private: - void SyncBuffer(); + void SyncBuffer(); enum { BUFFERSIZE = 0x10 }; - uint8* m_ram = nullptr; - uint8* m_spr = nullptr; + uint8* m_ram = nullptr; + uint8* m_spr = nullptr; - uint128 m_buffer; - uint32 m_bufferPosition = BUFFERSIZE; - uint32 m_startAddress = 0; - uint32 m_nextAddress = 0; - uint32 m_endAddress = 0; - bool m_tagIncluded = false; - uint8* m_source = nullptr; + uint128 m_buffer; + uint32 m_bufferPosition = BUFFERSIZE; + uint32 m_startAddress = 0; + uint32 m_nextAddress = 0; + uint32 m_endAddress = 0; + bool m_tagIncluded = false; + uint8* m_source = nullptr; }; typedef CFifoStream StreamType; struct STAT : public convertible { - unsigned int nVPS : 2; - unsigned int nVEW : 1; - unsigned int nReserved0 : 3; - unsigned int nMRK : 1; - unsigned int nDBF : 1; - unsigned int nVSS : 1; - unsigned int nVFS : 1; - unsigned int nVIS : 1; - unsigned int nINT : 1; - unsigned int nER0 : 1; - unsigned int nER1 : 1; - unsigned int nReserved2 : 9; - unsigned int nFDR : 1; //VIF1 only - unsigned int nFQC : 4; - unsigned int nReserved3 : 4; + unsigned int nVPS : 2; + unsigned int nVEW : 1; + unsigned int nReserved0 : 3; + unsigned int nMRK : 1; + unsigned int nDBF : 1; + unsigned int nVSS : 1; + unsigned int nVFS : 1; + unsigned int nVIS : 1; + unsigned int nINT : 1; + unsigned int nER0 : 1; + unsigned int nER1 : 1; + unsigned int nReserved2 : 9; + unsigned int nFDR : 1; //VIF1 only + unsigned int nFQC : 4; + unsigned int nReserved3 : 4; }; static_assert(sizeof(STAT) == sizeof(uint32), "Size of STAT struct must be 4 bytes."); struct CYCLE : public convertible { - unsigned int nCL : 8; - unsigned int nWL : 8; - unsigned int reserved : 16; + unsigned int nCL : 8; + unsigned int nWL : 8; + unsigned int reserved : 16; }; static_assert(sizeof(CYCLE) == sizeof(uint32), "Size of CYCLE struct must be 4 bytes."); struct CODE : public convertible { - unsigned int nIMM : 16; - unsigned int nNUM : 8; - unsigned int nCMD : 7; - unsigned int nI : 1; + unsigned int nIMM : 16; + unsigned int nNUM : 8; + unsigned int nCMD : 7; + unsigned int nI : 1; }; static_assert(sizeof(CODE) == sizeof(uint32), "Size of CODE struct must be 4 bytes."); @@ -177,66 +177,66 @@ protected: MASK_MASK = 3 }; - void ProcessFifoWrite(uint32, uint32); + void ProcessFifoWrite(uint32, uint32); - void ProcessPacket(StreamType&); - virtual void ExecuteCommand(StreamType&, CODE); - virtual void Cmd_UNPACK(StreamType&, CODE, uint32); + void ProcessPacket(StreamType&); + virtual void ExecuteCommand(StreamType&, CODE); + virtual void Cmd_UNPACK(StreamType&, CODE, uint32); - void Cmd_MPG(StreamType&, CODE); - void Cmd_STROW(StreamType&, CODE); - void Cmd_STCOL(StreamType&, CODE); - void Cmd_STMASK(StreamType&, CODE); + void Cmd_MPG(StreamType&, CODE); + void Cmd_STROW(StreamType&, CODE); + void Cmd_STCOL(StreamType&, CODE); + void Cmd_STMASK(StreamType&, CODE); - bool Unpack_ReadValue(const CODE&, StreamType&, uint128&, bool); - bool Unpack_S32(StreamType&, uint128&); - bool Unpack_S16(StreamType&, uint128&, bool); - bool Unpack_S8(StreamType&, uint128&, bool); - bool Unpack_V16(StreamType&, uint128&, unsigned int, bool); - bool Unpack_V8(StreamType&, uint128&, unsigned int, bool); - bool Unpack_V32(StreamType&, uint128&, unsigned int); - bool Unpack_V45(StreamType&, uint128&); + bool Unpack_ReadValue(const CODE&, StreamType&, uint128&, bool); + bool Unpack_S32(StreamType&, uint128&); + bool Unpack_S16(StreamType&, uint128&, bool); + bool Unpack_S8(StreamType&, uint128&, bool); + bool Unpack_V16(StreamType&, uint128&, unsigned int, bool); + bool Unpack_V8(StreamType&, uint128&, unsigned int, bool); + bool Unpack_V32(StreamType&, uint128&, unsigned int); + bool Unpack_V45(StreamType&, uint128&); - uint32 GetMaskOp(unsigned int, unsigned int) const; + uint32 GetMaskOp(unsigned int, unsigned int) const; - virtual void PrepareMicroProgram(); - void StartMicroProgram(uint32); + virtual void PrepareMicroProgram(); + void StartMicroProgram(uint32); #ifdef DELAYED_MSCAL - void StartDelayedMicroProgram(uint32); - bool ResumeDelayedMicroProgram(); + void StartDelayedMicroProgram(uint32); + bool ResumeDelayedMicroProgram(); #endif - void DisassembleCommand(CODE); - void DisassembleGet(uint32); - void DisassembleSet(uint32, uint32); + void DisassembleCommand(CODE); + void DisassembleGet(uint32); + void DisassembleSet(uint32, uint32); - unsigned int m_number = 0; - CVpu& m_vpu; - CINTC& m_intc; - uint8* m_ram = nullptr; - uint8* m_spr = nullptr; - CFifoStream m_stream; + unsigned int m_number = 0; + CVpu& m_vpu; + CINTC& m_intc; + uint8* m_ram = nullptr; + uint8* m_spr = nullptr; + CFifoStream m_stream; - uint8 m_fifoBuffer[FIFO_SIZE]; - uint32 m_fifoIndex = 0; + uint8 m_fifoBuffer[FIFO_SIZE]; + uint32 m_fifoIndex = 0; - STAT m_STAT; - CYCLE m_CYCLE; - CODE m_CODE; - uint8 m_NUM; - uint32 m_MODE; - uint32 m_R[4]; - uint32 m_C[4]; - uint32 m_MASK; - uint32 m_MARK; - uint32 m_ITOP; - uint32 m_ITOPS; - uint32 m_readTick; - uint32 m_writeTick; + STAT m_STAT; + CYCLE m_CYCLE; + CODE m_CODE; + uint8 m_NUM; + uint32 m_MODE; + uint32 m_R[4]; + uint32 m_C[4]; + uint32 m_MASK; + uint32 m_MARK; + uint32 m_ITOP; + uint32 m_ITOPS; + uint32 m_readTick; + uint32 m_writeTick; #ifdef DELAYED_MSCAL - uint32 m_pendingMicroProgram; - CODE m_previousCODE; + uint32 m_pendingMicroProgram; + CODE m_previousCODE; #endif - CProfiler::ZoneHandle m_vifProfilerZone = 0; + CProfiler::ZoneHandle m_vifProfilerZone = 0; }; diff --git a/Source/ee/Vif1.cpp b/Source/ee/Vif1.cpp index 51b93e51f..b67fef86c 100644 --- a/Source/ee/Vif1.cpp +++ b/Source/ee/Vif1.cpp @@ -8,31 +8,29 @@ #include "Vpu.h" #include "Vif1.h" -#define STATE_PATH_FORMAT ("vpu/vif1_%d.xml") -#define STATE_REGS_BASE ("BASE") -#define STATE_REGS_TOP ("TOP") -#define STATE_REGS_TOPS ("TOPS") -#define STATE_REGS_OFST ("OFST") +#define STATE_PATH_FORMAT ("vpu/vif1_%d.xml") +#define STATE_REGS_BASE ("BASE") +#define STATE_REGS_TOP ("TOP") +#define STATE_REGS_TOPS ("TOPS") +#define STATE_REGS_OFST ("OFST") CVif1::CVif1(unsigned int number, CVpu& vpu, CGIF& gif, CINTC& intc, uint8* ram, uint8* spr) -: CVif(1, vpu, intc, ram, spr) -, m_gif(gif) + : CVif(1, vpu, intc, ram, spr) + , m_gif(gif) { - } CVif1::~CVif1() { - } void CVif1::Reset() { CVif::Reset(); - m_BASE = 0; - m_TOP = 0; - m_TOPS = 0; - m_OFST = 0; + m_BASE = 0; + m_TOP = 0; + m_TOPS = 0; + m_OFST = 0; } void CVif1::SaveState(Framework::CZipArchiveWriter& archive) @@ -41,10 +39,10 @@ void CVif1::SaveState(Framework::CZipArchiveWriter& archive) auto path = string_format(STATE_PATH_FORMAT, m_number); CRegisterStateFile* registerFile = new CRegisterStateFile(path.c_str()); - registerFile->SetRegister32(STATE_REGS_BASE, m_BASE); - registerFile->SetRegister32(STATE_REGS_TOP, m_TOP); - registerFile->SetRegister32(STATE_REGS_TOPS, m_TOPS); - registerFile->SetRegister32(STATE_REGS_OFST, m_OFST); + registerFile->SetRegister32(STATE_REGS_BASE, m_BASE); + registerFile->SetRegister32(STATE_REGS_TOP, m_TOP); + registerFile->SetRegister32(STATE_REGS_TOPS, m_TOPS); + registerFile->SetRegister32(STATE_REGS_OFST, m_OFST); archive.InsertFile(registerFile); } @@ -54,10 +52,10 @@ void CVif1::LoadState(Framework::CZipArchiveReader& archive) auto path = string_format(STATE_PATH_FORMAT, m_number); CRegisterStateFile registerFile(*archive.BeginReadFile(path.c_str())); - m_BASE = registerFile.GetRegister32(STATE_REGS_BASE); - m_TOP = registerFile.GetRegister32(STATE_REGS_TOP); - m_TOPS = registerFile.GetRegister32(STATE_REGS_TOPS); - m_OFST = registerFile.GetRegister32(STATE_REGS_OFST); + m_BASE = registerFile.GetRegister32(STATE_REGS_BASE); + m_TOP = registerFile.GetRegister32(STATE_REGS_TOP); + m_TOPS = registerFile.GetRegister32(STATE_REGS_TOPS); + m_OFST = registerFile.GetRegister32(STATE_REGS_OFST); } uint32 CVif1::GetTOP() const @@ -184,7 +182,7 @@ void CVif1::Cmd_DIRECT(StreamType& stream, CODE nCommand) void CVif1::Cmd_UNPACK(StreamType& stream, CODE nCommand, uint32 nDstAddr) { bool nFlg = (m_CODE.nIMM & 0x8000) != 0; - if(nFlg) + if(nFlg) { nDstAddr += m_TOPS; } diff --git a/Source/ee/Vif1.h b/Source/ee/Vif1.h index 4033601d3..b78fd1999 100644 --- a/Source/ee/Vif1.h +++ b/Source/ee/Vif1.h @@ -8,29 +8,29 @@ class CINTC; class CVif1 : public CVif { public: - CVif1(unsigned int, CVpu&, CGIF&, CINTC&, uint8*, uint8*); - virtual ~CVif1(); + CVif1(unsigned int, CVpu&, CGIF&, CINTC&, uint8*, uint8*); + virtual ~CVif1(); - void Reset() override; - void SaveState(Framework::CZipArchiveWriter&) override; - void LoadState(Framework::CZipArchiveReader&) override; + void Reset() override; + void SaveState(Framework::CZipArchiveWriter&) override; + void LoadState(Framework::CZipArchiveReader&) override; - uint32 GetTOP() const override; + uint32 GetTOP() const override; - uint32 ReceiveDMA(uint32, uint32, uint32, bool) override; + uint32 ReceiveDMA(uint32, uint32, uint32, bool) override; private: - void ExecuteCommand(StreamType&, CODE) override; + void ExecuteCommand(StreamType&, CODE) override; - void Cmd_DIRECT(StreamType&, CODE); - void Cmd_UNPACK(StreamType&, CODE, uint32) override; + void Cmd_DIRECT(StreamType&, CODE); + void Cmd_UNPACK(StreamType&, CODE, uint32) override; - void PrepareMicroProgram() override; + void PrepareMicroProgram() override; - CGIF& m_gif; + CGIF& m_gif; - uint32 m_BASE; - uint32 m_OFST; - uint32 m_TOP; - uint32 m_TOPS; + uint32 m_BASE; + uint32 m_OFST; + uint32 m_TOP; + uint32 m_TOPS; }; diff --git a/Source/ee/Vpu.cpp b/Source/ee/Vpu.cpp index 6a7f0916e..7dad8b40f 100644 --- a/Source/ee/Vpu.cpp +++ b/Source/ee/Vpu.cpp @@ -8,33 +8,32 @@ #include "GIF.h" #include "Vpu.h" -#define LOG_NAME ("vpu") +#define LOG_NAME ("vpu") CVpu::CVpu(unsigned int number, const VPUINIT& vpuInit, CGIF& gif, CINTC& intc, uint8* ram, uint8* spr) -: m_number(number) -, m_vif((number == 0) ? std::make_unique(0, *this, intc, ram, spr) : std::make_unique(1, *this, gif, intc, ram, spr)) -, m_microMem(vpuInit.microMem) -, m_vuMem(vpuInit.vuMem) -, m_vuMemSize((number == 0) ? PS2::VUMEM0SIZE : PS2::VUMEM1SIZE) -, m_ctx(vpuInit.context) -, m_gif(gif) -, m_executor(*vpuInit.context, (number == 0) ? PS2::MICROMEM0SIZE : PS2::MICROMEM1SIZE) -, m_vuProfilerZone(CProfiler::GetInstance().RegisterZone("VU")) + : m_number(number) + , m_vif((number == 0) ? std::make_unique(0, *this, intc, ram, spr) : std::make_unique(1, *this, gif, intc, ram, spr)) + , m_microMem(vpuInit.microMem) + , m_vuMem(vpuInit.vuMem) + , m_vuMemSize((number == 0) ? PS2::VUMEM0SIZE : PS2::VUMEM1SIZE) + , m_ctx(vpuInit.context) + , m_gif(gif) + , m_executor(*vpuInit.context, (number == 0) ? PS2::MICROMEM0SIZE : PS2::MICROMEM1SIZE) + , m_vuProfilerZone(CProfiler::GetInstance().RegisterZone("VU")) #ifdef DEBUGGER_INCLUDED -, m_microMemMiniState(new uint8[(number == 0) ? PS2::MICROMEM0SIZE : PS2::MICROMEM1SIZE]) -, m_vuMemMiniState(new uint8[(number == 0) ? PS2::VUMEM0SIZE : PS2::VUMEM1SIZE]) -, m_topMiniState(0) -, m_itopMiniState(0) + , m_microMemMiniState(new uint8[(number == 0) ? PS2::MICROMEM0SIZE : PS2::MICROMEM1SIZE]) + , m_vuMemMiniState(new uint8[(number == 0) ? PS2::VUMEM0SIZE : PS2::VUMEM1SIZE]) + , m_topMiniState(0) + , m_itopMiniState(0) #endif { - } CVpu::~CVpu() { #ifdef DEBUGGER_INCLUDED - delete [] m_microMemMiniState; - delete [] m_vuMemMiniState; + delete[] m_microMemMiniState; + delete[] m_vuMemMiniState; #endif } @@ -180,14 +179,14 @@ void CVpu::ProcessXgKick(uint32 address) address &= 0x3FF; address *= 0x10; -// assert(nAddress < PS2::VUMEM1SIZE); + // assert(nAddress < PS2::VUMEM1SIZE); CGsPacketMetadata metadata; #ifdef DEBUGGER_INCLUDED - metadata.pathIndex = 1; - metadata.vuMemPacketAddress = address; - metadata.vpu1Top = GetVuTopMiniState(); - metadata.vpu1Itop = GetVuItopMiniState(); + metadata.pathIndex = 1; + metadata.vuMemPacketAddress = address; + metadata.vpu1Top = GetVuTopMiniState(); + metadata.vpu1Itop = GetVuItopMiniState(); memcpy(&metadata.vu1State, &GetVuMiniState(), sizeof(MIPSSTATE)); memcpy(metadata.vuMem1, GetVuMemoryMiniState(), PS2::VUMEM1SIZE); memcpy(metadata.microMem1, GetMicroMemoryMiniState(), PS2::MICROMEM1SIZE); diff --git a/Source/ee/Vpu.h b/Source/ee/Vpu.h index ae28435d7..b653e19c5 100644 --- a/Source/ee/Vpu.h +++ b/Source/ee/Vpu.h @@ -17,20 +17,19 @@ class CVpu public: enum VU1REGISTERS { - VU_TOP = 0x8400, - VU_XGKICK = 0x8410, - VU_ITOP = 0x8420, - VU_CMSAR1 = 0x1000FFC0, //This is meant to be used by the EE through CTC2 + VU_TOP = 0x8400, + VU_XGKICK = 0x8410, + VU_ITOP = 0x8420, + VU_CMSAR1 = 0x1000FFC0, //This is meant to be used by the EE through CTC2 }; struct VPUINIT { - VPUINIT(uint8* microMem, uint8* vuMem, CMIPS* context) - : microMem(microMem) - , vuMem(vuMem) - , context(context) + VPUINIT(uint8* microMem, uint8* vuMem, CMIPS* context) + : microMem(microMem) + , vuMem(vuMem) + , context(context) { - } uint8* microMem; @@ -38,60 +37,60 @@ public: CMIPS* context; }; - CVpu(unsigned int, const VPUINIT&, CGIF&, CINTC&, uint8*, uint8*); - virtual ~CVpu(); + CVpu(unsigned int, const VPUINIT&, CGIF&, CINTC&, uint8*, uint8*); + virtual ~CVpu(); - void Execute(int32); - void Reset(); - void SaveState(Framework::CZipArchiveWriter&); - void LoadState(Framework::CZipArchiveReader&); + void Execute(int32); + void Reset(); + void SaveState(Framework::CZipArchiveWriter&); + void LoadState(Framework::CZipArchiveReader&); - CMIPS& GetContext() const; - uint8* GetMicroMemory() const; - uint8* GetVuMemory() const; - uint32 GetVuMemorySize() const; - bool IsVuRunning() const; + CMIPS& GetContext() const; + uint8* GetMicroMemory() const; + uint8* GetVuMemory() const; + uint32 GetVuMemorySize() const; + bool IsVuRunning() const; - CVif& GetVif(); + CVif& GetVif(); - void ExecuteMicroProgram(uint32); - void InvalidateMicroProgram(); + void ExecuteMicroProgram(uint32); + void InvalidateMicroProgram(); - void ProcessXgKick(uint32); + void ProcessXgKick(uint32); #ifdef DEBUGGER_INCLUDED - bool MustBreak() const; - void DisableBreakpointsOnce(); + bool MustBreak() const; + void DisableBreakpointsOnce(); - void SaveMiniState(); - const MIPSSTATE& GetVuMiniState() const; - uint8* GetVuMemoryMiniState() const; - uint8* GetMicroMemoryMiniState() const; - uint32 GetVuTopMiniState() const; - uint32 GetVuItopMiniState() const; + void SaveMiniState(); + const MIPSSTATE& GetVuMiniState() const; + uint8* GetVuMemoryMiniState() const; + uint8* GetMicroMemoryMiniState() const; + uint32 GetVuTopMiniState() const; + uint32 GetVuItopMiniState() const; #endif protected: typedef std::unique_ptr VifPtr; - uint8* m_microMem = nullptr; - uint8* m_vuMem = nullptr; - uint32 m_vuMemSize = 0; - CMIPS* m_ctx = nullptr; - CGIF& m_gif; - VifPtr m_vif; + uint8* m_microMem = nullptr; + uint8* m_vuMem = nullptr; + uint32 m_vuMemSize = 0; + CMIPS* m_ctx = nullptr; + CGIF& m_gif; + VifPtr m_vif; #ifdef DEBUGGER_INCLUDED - MIPSSTATE m_vuMiniState; - uint8* m_microMemMiniState; - uint8* m_vuMemMiniState; - uint32 m_topMiniState; - uint32 m_itopMiniState; + MIPSSTATE m_vuMiniState; + uint8* m_microMemMiniState; + uint8* m_vuMemMiniState; + uint32 m_topMiniState; + uint32 m_itopMiniState; #endif - unsigned int m_number = 0; - CVuExecutor m_executor; - bool m_running = false; + unsigned int m_number = 0; + CVuExecutor m_executor; + bool m_running = false; - CProfiler::ZoneHandle m_vuProfilerZone = 0; + CProfiler::ZoneHandle m_vuProfilerZone = 0; }; diff --git a/Source/ee/VuAnalysis.cpp b/Source/ee/VuAnalysis.cpp index 129f96c92..f453c4454 100644 --- a/Source/ee/VuAnalysis.cpp +++ b/Source/ee/VuAnalysis.cpp @@ -49,9 +49,8 @@ void CVuAnalysis::Analyse(CMIPS* ctx, uint32 begin, uint32 end) //Check for JR or END bit if( - (lowerInstruction & 0xFE000000) == (0x24 << 25) || - (upperInstruction & 0x40000000) - ) + (lowerInstruction & 0xFE000000) == (0x24 << 25) || + (upperInstruction & 0x40000000)) { subroutineAddresses.insert(potentialRoutineStart); potentialRoutineStart = address + 8; @@ -75,9 +74,8 @@ void CVuAnalysis::Analyse(CMIPS* ctx, uint32 begin, uint32 end) //Check for JR or END bit if( - (lowerInstruction & 0xFE000000) == (0x24 << 25) || - (upperInstruction & 0x40000000) - ) + (lowerInstruction & 0xFE000000) == (0x24 << 25) || + (upperInstruction & 0x40000000)) { ctx->m_analysis->InsertSubroutine(subroutineAddress, address + 8, 0, 0, 0, 0); routineCount++; diff --git a/Source/ee/VuAnalysis.h b/Source/ee/VuAnalysis.h index 27b767046..4ee3f3408 100644 --- a/Source/ee/VuAnalysis.h +++ b/Source/ee/VuAnalysis.h @@ -9,8 +9,8 @@ class CMIPS; class CVuAnalysis { public: - static void Analyse(CMIPS*, uint32, uint32); + static void Analyse(CMIPS*, uint32, uint32); private: - static uint32 FindBlockStart(CMIPS*, uint32); + static uint32 FindBlockStart(CMIPS*, uint32); }; diff --git a/Source/ee/VuBasicBlock.cpp b/Source/ee/VuBasicBlock.cpp index 5da8643b0..c10d9561a 100644 --- a/Source/ee/VuBasicBlock.cpp +++ b/Source/ee/VuBasicBlock.cpp @@ -5,9 +5,8 @@ #include "Vpu.h" CVuBasicBlock::CVuBasicBlock(CMIPS& context, uint32 begin, uint32 end) -: CBasicBlock(context, begin, end) + : CBasicBlock(context, begin, end) { - } void CVuBasicBlock::CompileRange(CMipsJitter* jitter) @@ -44,12 +43,11 @@ void CVuBasicBlock::CompileRange(CMipsJitter* jitter) bool hasPendingXgKick = false; const auto clearPendingXgKick = - [&]() - { - assert(hasPendingXgKick); - EmitXgKick(jitter); - hasPendingXgKick = false; - }; + [&]() { + assert(hasPendingXgKick); + EmitXgKick(jitter); + hasPendingXgKick = false; + }; for(uint32 address = m_begin; address <= fixedEnd; address += 8) { @@ -66,7 +64,7 @@ void CVuBasicBlock::CompileRange(CMipsJitter* jitter) //No upper instruction writes to Q assert(hiOps.syncQ == false); - + //No lower instruction reads Q assert(loOps.readQ == false); @@ -88,9 +86,8 @@ void CVuBasicBlock::CompileRange(CMipsJitter* jitter) { assert(hiOps.writeF != loOps.writeF); if( - (hiOps.writeF == loOps.readF0) || - (hiOps.writeF == loOps.readF1) - ) + (hiOps.writeF == loOps.readF0) || + (hiOps.writeF == loOps.readF1)) { savedReg = hiOps.writeF; jitter->MD_PushRel(offsetof(CMIPS, m_State.nCOP2[savedReg])); @@ -228,9 +225,8 @@ CVuBasicBlock::INTEGER_BRANCH_DELAY_INFO CVuBasicBlock::GetIntegerBranchDelayInf { auto branchLoOps = arch->GetAffectedOperands(&m_context, branchOpcodeAddr, branchOpcodeLo); if( - (branchLoOps.readI0 == priorLoOps.writeI) || - (branchLoOps.readI1 == priorLoOps.writeI) - ) + (branchLoOps.readI0 == priorLoOps.writeI) || + (branchLoOps.readI1 == priorLoOps.writeI)) { //Check if our block is a "special" loop. Disable delayed integer processing if it's the case //TODO: Handle that case better @@ -238,9 +234,9 @@ CVuBasicBlock::INTEGER_BRANCH_DELAY_INFO CVuBasicBlock::GetIntegerBranchDelayInf if(!isSpecialLoop) { // we need to use the value of intReg 4 steps prior or use initial value. - result.regIndex = priorLoOps.writeI; + result.regIndex = priorLoOps.writeI; result.saveRegAddress = std::max(adjustedEnd - 5 * 8, m_begin); - result.useRegAddress = adjustedEnd - 8; + result.useRegAddress = adjustedEnd - 8; } } } diff --git a/Source/ee/VuBasicBlock.h b/Source/ee/VuBasicBlock.h index 750c16cbd..f790fa9a3 100644 --- a/Source/ee/VuBasicBlock.h +++ b/Source/ee/VuBasicBlock.h @@ -5,23 +5,23 @@ class CVuBasicBlock : public CBasicBlock { public: - CVuBasicBlock(CMIPS&, uint32, uint32); - virtual ~CVuBasicBlock() = default; + CVuBasicBlock(CMIPS&, uint32, uint32); + virtual ~CVuBasicBlock() = default; protected: - void CompileRange(CMipsJitter*) override; + void CompileRange(CMipsJitter*) override; private: struct INTEGER_BRANCH_DELAY_INFO { unsigned int regIndex = 0; - uint32 saveRegAddress = MIPS_INVALID_PC; - uint32 useRegAddress = MIPS_INVALID_PC; + uint32 saveRegAddress = MIPS_INVALID_PC; + uint32 useRegAddress = MIPS_INVALID_PC; }; - static bool IsConditionalBranch(uint32); + static bool IsConditionalBranch(uint32); - INTEGER_BRANCH_DELAY_INFO GetIntegerBranchDelayInfo(uint32) const; - bool CheckIsSpecialIntegerLoop(uint32, unsigned int) const; - static void EmitXgKick(CMipsJitter*); + INTEGER_BRANCH_DELAY_INFO GetIntegerBranchDelayInfo(uint32) const; + bool CheckIsSpecialIntegerLoop(uint32, unsigned int) const; + static void EmitXgKick(CMipsJitter*); }; diff --git a/Source/ee/VuExecutor.cpp b/Source/ee/VuExecutor.cpp index c84a7add3..e983ee2c6 100644 --- a/Source/ee/VuExecutor.cpp +++ b/Source/ee/VuExecutor.cpp @@ -3,9 +3,8 @@ #include CVuExecutor::CVuExecutor(CMIPS& context, uint32 maxAddress) -: CMipsExecutor(context, maxAddress) + : CMipsExecutor(context, maxAddress) { - } void CVuExecutor::Reset() @@ -66,7 +65,7 @@ void CVuExecutor::PartitionFunction(uint32 functionAddress) partitionPoints.insert(functionAddress); //Find the end - for(uint32 address = functionAddress; ; address += 4) + for(uint32 address = functionAddress;; address += 4) { //Probably going too far... if(address >= m_maxAddress) @@ -131,7 +130,7 @@ void CVuExecutor::PartitionFunction(uint32 functionAddress) } currentPoint = point; } -/* + /* //Convenient cutting for debugging purposes for(uint32 address = functionAddress; address <= endAddress; address += 8) { diff --git a/Source/ee/VuExecutor.h b/Source/ee/VuExecutor.h index 282f8eac3..9924e7695 100644 --- a/Source/ee/VuExecutor.h +++ b/Source/ee/VuExecutor.h @@ -6,16 +6,16 @@ class CVuExecutor : public CMipsExecutor { public: - CVuExecutor(CMIPS&, uint32); - virtual ~CVuExecutor() = default; + CVuExecutor(CMIPS&, uint32); + virtual ~CVuExecutor() = default; - void Reset() override; + void Reset() override; protected: typedef std::unordered_multimap CachedBlockMap; - BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32) override; - void PartitionFunction(uint32) override; + BasicBlockPtr BlockFactory(CMIPS&, uint32, uint32) override; + void PartitionFunction(uint32) override; - CachedBlockMap m_cachedBlocks; + CachedBlockMap m_cachedBlocks; }; diff --git a/Source/gs/GSH_Null.cpp b/Source/gs/GSH_Null.cpp index adcfa1218..0b50c064b 100644 --- a/Source/gs/GSH_Null.cpp +++ b/Source/gs/GSH_Null.cpp @@ -2,47 +2,38 @@ CGSH_Null::CGSH_Null() { - } CGSH_Null::~CGSH_Null() { - } void CGSH_Null::InitializeImpl() { - } void CGSH_Null::ReleaseImpl() { - } void CGSH_Null::ProcessHostToLocalTransfer() { - } void CGSH_Null::ProcessLocalToHostTransfer() { - } void CGSH_Null::ProcessLocalToLocalTransfer() { - } void CGSH_Null::ProcessClutTransfer(uint32, uint32) { - } void CGSH_Null::ReadFramebuffer(uint32, uint32, void*) { - } CGSHandler::FactoryFunction CGSH_Null::GetFactoryFunction() diff --git a/Source/gs/GSH_Null.h b/Source/gs/GSH_Null.h index 39749c81f..2b2378131 100644 --- a/Source/gs/GSH_Null.h +++ b/Source/gs/GSH_Null.h @@ -5,20 +5,20 @@ class CGSH_Null : public CGSHandler { public: - CGSH_Null(); - virtual ~CGSH_Null(); + CGSH_Null(); + virtual ~CGSH_Null(); - virtual void ProcessHostToLocalTransfer() override; - virtual void ProcessLocalToHostTransfer() override; - virtual void ProcessLocalToLocalTransfer() override; - virtual void ProcessClutTransfer(uint32, uint32) override; - virtual void ReadFramebuffer(uint32, uint32, void*) override; + virtual void ProcessHostToLocalTransfer() override; + virtual void ProcessLocalToHostTransfer() override; + virtual void ProcessLocalToLocalTransfer() override; + virtual void ProcessClutTransfer(uint32, uint32) override; + virtual void ReadFramebuffer(uint32, uint32, void*) override; - static FactoryFunction GetFactoryFunction(); + static FactoryFunction GetFactoryFunction(); private: - virtual void InitializeImpl() override; - virtual void ReleaseImpl() override; + virtual void InitializeImpl() override; + virtual void ReleaseImpl() override; - static CGSHandler* GSHandlerFactory(); + static CGSHandler* GSHandlerFactory(); }; diff --git a/Source/gs/GSH_OpenGL/GSH_OpenGL.cpp b/Source/gs/GSH_OpenGL/GSH_OpenGL.cpp index f33889590..e8e046515 100644 --- a/Source/gs/GSH_OpenGL/GSH_OpenGL.cpp +++ b/Source/gs/GSH_OpenGL/GSH_OpenGL.cpp @@ -11,40 +11,37 @@ #define FRAMEBUFFER_HEIGHT 1024 const GLenum CGSH_OpenGL::g_nativeClampModes[CGSHandler::CLAMP_MODE_MAX] = -{ - GL_REPEAT, - GL_CLAMP_TO_EDGE, - GL_REPEAT, - GL_REPEAT -}; + { + GL_REPEAT, + GL_CLAMP_TO_EDGE, + GL_REPEAT, + GL_REPEAT}; const unsigned int CGSH_OpenGL::g_shaderClampModes[CGSHandler::CLAMP_MODE_MAX] = -{ - TEXTURE_CLAMP_MODE_STD, - TEXTURE_CLAMP_MODE_STD, - TEXTURE_CLAMP_MODE_REGION_CLAMP, - TEXTURE_CLAMP_MODE_REGION_REPEAT -}; + { + TEXTURE_CLAMP_MODE_STD, + TEXTURE_CLAMP_MODE_STD, + TEXTURE_CLAMP_MODE_REGION_CLAMP, + TEXTURE_CLAMP_MODE_REGION_REPEAT}; const unsigned int CGSH_OpenGL::g_alphaTestInverse[CGSHandler::ALPHA_TEST_MAX] = -{ - ALPHA_TEST_ALWAYS, - ALPHA_TEST_NEVER, - ALPHA_TEST_GEQUAL, - ALPHA_TEST_GREATER, - ALPHA_TEST_NOTEQUAL, - ALPHA_TEST_LESS, - ALPHA_TEST_LEQUAL, - ALPHA_TEST_EQUAL -}; + { + ALPHA_TEST_ALWAYS, + ALPHA_TEST_NEVER, + ALPHA_TEST_GEQUAL, + ALPHA_TEST_GREATER, + ALPHA_TEST_NOTEQUAL, + ALPHA_TEST_LESS, + ALPHA_TEST_LEQUAL, + ALPHA_TEST_EQUAL}; static uint32 MakeColor(uint8 r, uint8 g, uint8 b, uint8 a) { return (a << 24) | (b << 16) | (g << 8) | (r); } -CGSH_OpenGL::CGSH_OpenGL() -: m_pCvtBuffer(nullptr) +CGSH_OpenGL::CGSH_OpenGL() + : m_pCvtBuffer(nullptr) { RegisterPreferences(); LoadPreferences(); @@ -57,7 +54,7 @@ CGSH_OpenGL::CGSH_OpenGL() CGSH_OpenGL::~CGSH_OpenGL() { - delete [] m_pCvtBuffer; + delete[] m_pCvtBuffer; } void CGSH_OpenGL::InitializeImpl() @@ -143,10 +140,9 @@ void CGSH_OpenGL::FlipImpl() for(const auto& candidateFramebuffer : m_framebuffers) { if( - (candidateFramebuffer->m_basePtr == fb.GetBufPtr()) && - (GetFramebufferBitDepth(candidateFramebuffer->m_psm) == GetFramebufferBitDepth(fb.nPSM)) && - (candidateFramebuffer->m_width == fb.GetBufWidth()) - ) + (candidateFramebuffer->m_basePtr == fb.GetBufPtr()) && + (GetFramebufferBitDepth(candidateFramebuffer->m_psm) == GetFramebufferBitDepth(fb.nPSM)) && + (candidateFramebuffer->m_width == fb.GetBufWidth())) { //We have a winner framebuffer = candidateFramebuffer; @@ -189,40 +185,39 @@ void CGSH_OpenGL::FlipImpl() glViewport(0, 0, m_presentationParams.windowWidth, m_presentationParams.windowHeight); break; case PRESENTATION_MODE_FIT: + { + int viewportWidth[2]; + int viewportHeight[2]; { - int viewportWidth[2]; - int viewportHeight[2]; - { - viewportWidth[0] = m_presentationParams.windowWidth; - viewportHeight[0] = (sourceWidth != 0) ? (m_presentationParams.windowWidth * sourceHeight) / sourceWidth : 0; - } - { - viewportWidth[1] = (sourceHeight != 0) ? (m_presentationParams.windowHeight * sourceWidth) / sourceHeight : 0; - viewportHeight[1] = m_presentationParams.windowHeight; - } - int selectedViewport = 0; - if( - (viewportWidth[0] > static_cast(m_presentationParams.windowWidth)) || - (viewportHeight[0] > static_cast(m_presentationParams.windowHeight)) - ) - { - selectedViewport = 1; - assert( - viewportWidth[1] <= static_cast(m_presentationParams.windowWidth) && - viewportHeight[1] <= static_cast(m_presentationParams.windowHeight)); - } - int offsetX = static_cast(m_presentationParams.windowWidth - viewportWidth[selectedViewport]) / 2; - int offsetY = static_cast(m_presentationParams.windowHeight - viewportHeight[selectedViewport]) / 2; - glViewport(offsetX, offsetY, viewportWidth[selectedViewport], viewportHeight[selectedViewport]); + viewportWidth[0] = m_presentationParams.windowWidth; + viewportHeight[0] = (sourceWidth != 0) ? (m_presentationParams.windowWidth * sourceHeight) / sourceWidth : 0; } - break; + { + viewportWidth[1] = (sourceHeight != 0) ? (m_presentationParams.windowHeight * sourceWidth) / sourceHeight : 0; + viewportHeight[1] = m_presentationParams.windowHeight; + } + int selectedViewport = 0; + if( + (viewportWidth[0] > static_cast(m_presentationParams.windowWidth)) || + (viewportHeight[0] > static_cast(m_presentationParams.windowHeight))) + { + selectedViewport = 1; + assert( + viewportWidth[1] <= static_cast(m_presentationParams.windowWidth) && + viewportHeight[1] <= static_cast(m_presentationParams.windowHeight)); + } + int offsetX = static_cast(m_presentationParams.windowWidth - viewportWidth[selectedViewport]) / 2; + int offsetY = static_cast(m_presentationParams.windowHeight - viewportHeight[selectedViewport]) / 2; + glViewport(offsetX, offsetY, viewportWidth[selectedViewport], viewportHeight[selectedViewport]); + } + break; case PRESENTATION_MODE_ORIGINAL: - { - int offsetX = static_cast(m_presentationParams.windowWidth - sourceWidth) / 2; - int offsetY = static_cast(m_presentationParams.windowHeight - sourceHeight) / 2; - glViewport(offsetX, offsetY, sourceWidth, sourceHeight); - } - break; + { + int offsetX = static_cast(m_presentationParams.windowWidth - sourceWidth) / 2; + int offsetY = static_cast(m_presentationParams.windowHeight - sourceHeight) / 2; + glViewport(offsetX, offsetY, sourceWidth, sourceHeight); + } + break; } if(framebuffer) @@ -282,11 +277,9 @@ void CGSH_OpenGL::LoadState(Framework::CZipArchiveReader& archive) { CGSHandler::LoadState(archive); m_mailBox.SendCall( - [this] () - { - m_textureCache.InvalidateRange(0, RAMSIZE); - } - ); + [this]() { + m_textureCache.InvalidateRange(0, RAMSIZE); + }); } void CGSH_OpenGL::RegisterPreferences() @@ -373,16 +366,16 @@ Framework::OpenGl::CVertexArray CGSH_OpenGL::GeneratePresentVertexArray() auto vertexArray = Framework::OpenGl::CVertexArray::Create(); glBindVertexArray(vertexArray); - + glBindBuffer(GL_ARRAY_BUFFER, m_presentVertexBuffer); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::POSITION)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 2, GL_FLOAT, - GL_FALSE, sizeof(float) * 4, reinterpret_cast(0)); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 2, GL_FLOAT, + GL_FALSE, sizeof(float) * 4, reinterpret_cast(0)); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 2, GL_FLOAT, - GL_FALSE, sizeof(float) * 4, reinterpret_cast(8)); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 2, GL_FLOAT, + GL_FALSE, sizeof(float) * 4, reinterpret_cast(8)); glBindVertexArray(0); @@ -405,7 +398,7 @@ Framework::OpenGl::CBuffer CGSH_OpenGL::GenerateCopyToFbVertexBuffer() 1.0f, 1.0f, 1.0f, 1.0f, }; // clang-format on - + glBindBuffer(GL_ARRAY_BUFFER, buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(bufferContents), bufferContents, GL_STATIC_DRAW); @@ -425,12 +418,12 @@ Framework::OpenGl::CVertexArray CGSH_OpenGL::GenerateCopyToFbVertexArray() glBindBuffer(GL_ARRAY_BUFFER, m_copyToFbVertexBuffer); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::POSITION)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 2, GL_FLOAT, - GL_FALSE, sizeof(float) * 4, reinterpret_cast(0)); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 2, GL_FLOAT, + GL_FALSE, sizeof(float) * 4, reinterpret_cast(0)); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 2, GL_FLOAT, - GL_FALSE, sizeof(float) * 4, reinterpret_cast(8)); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 2, GL_FLOAT, + GL_FALSE, sizeof(float) * 4, reinterpret_cast(8)); glBindVertexArray(0); @@ -448,20 +441,20 @@ Framework::OpenGl::CVertexArray CGSH_OpenGL::GeneratePrimVertexArray() glBindBuffer(GL_ARRAY_BUFFER, m_primBuffer); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::POSITION)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 3, GL_FLOAT, - GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, x))); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::POSITION), 3, GL_FLOAT, + GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, x))); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::COLOR)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::COLOR), 4, GL_UNSIGNED_BYTE, - GL_TRUE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, color))); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::COLOR), 4, GL_UNSIGNED_BYTE, + GL_TRUE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, color))); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 3, GL_FLOAT, - GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, s))); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::TEXCOORD), 3, GL_FLOAT, + GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, s))); glEnableVertexAttribArray(static_cast(PRIM_VERTEX_ATTRIB::FOG)); - glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::FOG), 1, GL_FLOAT, - GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, f))); + glVertexAttribPointer(static_cast(PRIM_VERTEX_ATTRIB::FOG), 1, GL_FLOAT, + GL_FALSE, sizeof(PRIM_VERTEX), reinterpret_cast(offsetof(PRIM_VERTEX, f))); glBindVertexArray(0); @@ -483,30 +476,30 @@ Framework::OpenGl::CBuffer CGSH_OpenGL::GenerateUniformBlockBuffer(size_t blockS void CGSH_OpenGL::MakeLinearZOrtho(float* matrix, float left, float right, float bottom, float top) { - matrix[ 0] = 2.0f / (right - left); - matrix[ 1] = 0; - matrix[ 2] = 0; - matrix[ 3] = 0; + matrix[0] = 2.0f / (right - left); + matrix[1] = 0; + matrix[2] = 0; + matrix[3] = 0; - matrix[ 4] = 0; - matrix[ 5] = 2.0f / (top - bottom); - matrix[ 6] = 0; - matrix[ 7] = 0; + matrix[4] = 0; + matrix[5] = 2.0f / (top - bottom); + matrix[6] = 0; + matrix[7] = 0; - matrix[ 8] = 0; - matrix[ 9] = 0; + matrix[8] = 0; + matrix[9] = 0; matrix[10] = 1; matrix[11] = 0; - matrix[12] = - (right + left) / (right - left); - matrix[13] = - (top + bottom) / (top - bottom); + matrix[12] = -(right + left) / (right - left); + matrix[13] = -(top + bottom) / (top - bottom); matrix[14] = 0; matrix[15] = 1; } unsigned int CGSH_OpenGL::GetCurrentReadCircuit() { -// assert((m_nPMODE & 0x3) != 0x03); + // assert((m_nPMODE & 0x3) != 0x03); if(m_nPMODE & 0x1) return 0; if(m_nPMODE & 0x2) return 1; //Getting here is bad @@ -519,7 +512,7 @@ float CGSH_OpenGL::GetZ(float nZ) { return -1; } - + nZ -= m_nMaxZ; if(nZ > m_nMaxZ) return 1.0; if(nZ < -m_nMaxZ) return -1.0; @@ -613,14 +606,14 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) //-------------------------------------------------------- if(!m_renderState.isValid || - (static_cast(m_renderState.shaderCaps) != static_cast(shaderCaps))) + (static_cast(m_renderState.shaderCaps) != static_cast(shaderCaps))) { FlushVertexBuffer(); m_renderState.shaderCaps = shaderCaps; } if(!m_renderState.isValid || - (m_renderState.technique != technique)) + (m_renderState.technique != technique)) { FlushVertexBuffer(); m_renderState.technique = technique; @@ -631,26 +624,26 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) //-------------------------------------------------------- if(!m_renderState.isValid || - (m_renderState.primReg != primReg)) + (m_renderState.primReg != primReg)) { FlushVertexBuffer(); //Humm, not quite sure about this -// if(prim.nAntiAliasing) -// { -// glEnable(GL_BLEND); -// } -// else -// { -// glDisable(GL_BLEND); -// } + // if(prim.nAntiAliasing) + // { + // glEnable(GL_BLEND); + // } + // else + // { + // glDisable(GL_BLEND); + // } m_renderState.blendEnabled = prim.nAlpha ? GL_TRUE : GL_FALSE; m_validGlState &= ~GLSTATE_BLEND; } if(!m_renderState.isValid || - (m_renderState.alphaReg != alphaReg)) + (m_renderState.alphaReg != alphaReg)) { FlushVertexBuffer(); SetupBlendingFunction(alphaReg); @@ -658,7 +651,7 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) } if(!m_renderState.isValid || - (m_renderState.testReg != testReg)) + (m_renderState.testReg != testReg)) { FlushVertexBuffer(); SetupTestFunctions(testReg); @@ -666,8 +659,8 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) } if(!m_renderState.isValid || - (m_renderState.zbufReg != zbufReg) || - (m_renderState.testReg != testReg)) + (m_renderState.zbufReg != zbufReg) || + (m_renderState.testReg != testReg)) { FlushVertexBuffer(); SetupDepthBuffer(zbufReg, testReg); @@ -675,11 +668,11 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) } if(!m_renderState.isValid || - !m_renderState.isFramebufferStateValid || - (m_renderState.frameReg != frameReg) || - (m_renderState.zbufReg != zbufReg) || - (m_renderState.scissorReg != scissorReg) || - (m_renderState.testReg != testReg)) + !m_renderState.isFramebufferStateValid || + (m_renderState.frameReg != frameReg) || + (m_renderState.zbufReg != zbufReg) || + (m_renderState.scissorReg != scissorReg) || + (m_renderState.testReg != testReg)) { FlushVertexBuffer(); SetupFramebuffer(frameReg, zbufReg, scissorReg, testReg); @@ -687,12 +680,12 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) } if(!m_renderState.isValid || - !m_renderState.isTextureStateValid || - (m_renderState.tex0Reg != tex0Reg) || - (m_renderState.tex1Reg != tex1Reg) || - (m_renderState.texAReg != texAReg) || - (m_renderState.clampReg != clampReg) || - (m_renderState.primReg != primReg)) + !m_renderState.isTextureStateValid || + (m_renderState.tex0Reg != tex0Reg) || + (m_renderState.tex1Reg != tex1Reg) || + (m_renderState.texAReg != texAReg) || + (m_renderState.clampReg != clampReg) || + (m_renderState.primReg != primReg)) { FlushVertexBuffer(); SetupTexture(primReg, tex0Reg, tex1Reg, texAReg, clampReg); @@ -700,7 +693,7 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) } if(!m_renderState.isValid || - (m_renderState.fogColReg != fogColReg)) + (m_renderState.fogColReg != fogColReg)) { FlushVertexBuffer(); SetupFogColor(fogColReg); @@ -710,23 +703,23 @@ void CGSH_OpenGL::SetRenderingContext(uint64 primReg) auto offset = make_convertible(m_nReg[GS_REG_XYOFFSET_1 + context]); m_nPrimOfsX = offset.GetX(); m_nPrimOfsY = offset.GetY(); - + CHECKGLERROR(); - m_renderState.isValid = true; - m_renderState.isTextureStateValid = true; + m_renderState.isValid = true; + m_renderState.isTextureStateValid = true; m_renderState.isFramebufferStateValid = true; - m_renderState.primReg = primReg; - m_renderState.alphaReg = alphaReg; - m_renderState.testReg = testReg; - m_renderState.zbufReg = zbufReg; - m_renderState.scissorReg = scissorReg; - m_renderState.frameReg = frameReg; - m_renderState.tex0Reg = tex0Reg; - m_renderState.tex1Reg = tex1Reg; - m_renderState.texAReg = texAReg; - m_renderState.clampReg = clampReg; - m_renderState.fogColReg = fogColReg; + m_renderState.primReg = primReg; + m_renderState.alphaReg = alphaReg; + m_renderState.testReg = testReg; + m_renderState.zbufReg = zbufReg; + m_renderState.scissorReg = scissorReg; + m_renderState.frameReg = frameReg; + m_renderState.tex0Reg = tex0Reg; + m_renderState.tex1Reg = tex1Reg; + m_renderState.texAReg = texAReg; + m_renderState.clampReg = clampReg; + m_renderState.fogColReg = fogColReg; } void CGSH_OpenGL::SetupBlendingFunction(uint64 alphaReg) @@ -946,9 +939,9 @@ void CGSH_OpenGL::SetupDepthBuffer(uint64 zbufReg, uint64 testReg) bool depthWriteEnabled = (zbuf.nMask ? false : true); //If alpha test is enabled for always failing and update only colors, depth writes are disabled if( - (test.nAlphaEnabled == 1) && - (test.nAlphaMethod == ALPHA_TEST_NEVER) && - ((test.nAlphaFail == ALPHA_TEST_FAIL_FBONLY) || (test.nAlphaFail == ALPHA_TEST_FAIL_RGBONLY))) + (test.nAlphaEnabled == 1) && + (test.nAlphaMethod == ALPHA_TEST_NEVER) && + ((test.nAlphaFail == ALPHA_TEST_FAIL_FBONLY) || (test.nAlphaFail == ALPHA_TEST_FAIL_RGBONLY))) { depthWriteEnabled = false; } @@ -1024,7 +1017,7 @@ void CGSH_OpenGL::SetupFramebuffer(uint64 frameReg, uint64 zbufReg, uint64 sciss assert(result == GL_FRAMEBUFFER_COMPLETE); m_renderState.framebufferHandle = framebuffer->m_framebuffer; - m_validGlState |= GLSTATE_FRAMEBUFFER; //glBindFramebuffer used to set just above + m_validGlState |= GLSTATE_FRAMEBUFFER; //glBindFramebuffer used to set just above //We assume that we will be drawing to this framebuffer and that we'll need //to resolve samples at some point if multisampling is enabled @@ -1176,7 +1169,6 @@ CGSH_OpenGL::TECHNIQUE CGSH_OpenGL::GetTechniqueFromTest(const uint64& testReg) { if((test.nAlphaMethod == ALPHA_TEST_NEVER) && (test.nAlphaFail != ALPHA_TEST_FAIL_KEEP)) { - } else { @@ -1255,9 +1247,9 @@ void CGSH_OpenGL::SetupTexture(uint64 primReg, uint64 tex0Reg, uint64 tex1Reg, u m_renderState.texture0MinFilter = GL_LINEAR; } - unsigned int clampMin[2] = { 0, 0 }; - unsigned int clampMax[2] = { 0, 0 }; - float textureScaleRatio[2] = { texInfo.scaleRatioX, texInfo.scaleRatioY }; + unsigned int clampMin[2] = {0, 0}; + unsigned int clampMax[2] = {0, 0}; + float textureScaleRatio[2] = {texInfo.scaleRatioX, texInfo.scaleRatioY}; m_renderState.texture0WrapS = g_nativeClampModes[clamp.nWMS]; m_renderState.texture0WrapT = g_nativeClampModes[clamp.nWMT]; @@ -1291,8 +1283,8 @@ void CGSH_OpenGL::SetupTexture(uint64 primReg, uint64 tex0Reg, uint64 tex1Reg, u } } - if(CGsPixelFormats::IsPsmIDTEX(tex0.nPsm) && - (m_renderState.texture0MinFilter != GL_NEAREST || m_renderState.texture0MagFilter != GL_NEAREST)) + if(CGsPixelFormats::IsPsmIDTEX(tex0.nPsm) && + (m_renderState.texture0MinFilter != GL_NEAREST || m_renderState.texture0MagFilter != GL_NEAREST)) { //We'll need to filter the texture manually m_renderState.texture0MinFilter = GL_NEAREST; @@ -1327,26 +1319,22 @@ void CGSH_OpenGL::SetupTexture(uint64 primReg, uint64 tex0Reg, uint64 tex1Reg, u CGSH_OpenGL::FramebufferPtr CGSH_OpenGL::FindFramebuffer(const FRAME& frame) const { - auto framebufferIterator = std::find_if(std::begin(m_framebuffers), std::end(m_framebuffers), - [&] (const FramebufferPtr& framebuffer) - { - return (framebuffer->m_basePtr == frame.GetBasePtr()) && - (framebuffer->m_psm == frame.nPsm) && - (framebuffer->m_width == frame.GetWidth()); - } - ); + auto framebufferIterator = std::find_if(std::begin(m_framebuffers), std::end(m_framebuffers), + [&](const FramebufferPtr& framebuffer) { + return (framebuffer->m_basePtr == frame.GetBasePtr()) && + (framebuffer->m_psm == frame.nPsm) && + (framebuffer->m_width == frame.GetWidth()); + }); return (framebufferIterator != std::end(m_framebuffers)) ? *(framebufferIterator) : FramebufferPtr(); } CGSH_OpenGL::DepthbufferPtr CGSH_OpenGL::FindDepthbuffer(const ZBUF& zbuf, const FRAME& frame) const { - auto depthbufferIterator = std::find_if(std::begin(m_depthbuffers), std::end(m_depthbuffers), - [&] (const DepthbufferPtr& depthbuffer) - { - return (depthbuffer->m_basePtr == zbuf.GetBasePtr()) && (depthbuffer->m_width == frame.GetWidth()); - } - ); + auto depthbufferIterator = std::find_if(std::begin(m_depthbuffers), std::end(m_depthbuffers), + [&](const DepthbufferPtr& depthbuffer) { + return (depthbuffer->m_basePtr == zbuf.GetBasePtr()) && (depthbuffer->m_width == frame.GetWidth()); + }); return (depthbufferIterator != std::end(m_depthbuffers)) ? *(depthbufferIterator) : DepthbufferPtr(); } @@ -1360,15 +1348,17 @@ void CGSH_OpenGL::Prim_Point() auto xyz = make_convertible(m_VtxBuffer[0].nPosition); auto rgbaq = make_convertible(m_VtxBuffer[0].nRGBAQ); - float x = xyz.GetX(); float y = xyz.GetY(); float z = xyz.GetZ(); + float x = xyz.GetX(); + float y = xyz.GetY(); + float z = xyz.GetZ(); x -= m_nPrimOfsX; y -= m_nPrimOfsY; z = GetZ(z); auto color = MakeColor( - rgbaq.nR, rgbaq.nG, - rgbaq.nB, rgbaq.nA); + rgbaq.nR, rgbaq.nG, + rgbaq.nB, rgbaq.nA); // clang-format off PRIM_VERTEX vertex = @@ -1388,8 +1378,12 @@ void CGSH_OpenGL::Prim_Line() xyz[0] <<= m_VtxBuffer[1].nPosition; xyz[1] <<= m_VtxBuffer[0].nPosition; - float nX1 = xyz[0].GetX(); float nY1 = xyz[0].GetY(); float nZ1 = xyz[0].GetZ(); - float nX2 = xyz[1].GetX(); float nY2 = xyz[1].GetY(); float nZ2 = xyz[1].GetZ(); + float nX1 = xyz[0].GetX(); + float nY1 = xyz[0].GetY(); + float nZ1 = xyz[0].GetZ(); + float nX2 = xyz[1].GetX(); + float nY2 = xyz[1].GetY(); + float nZ2 = xyz[1].GetZ(); nX1 -= m_nPrimOfsX; nX2 -= m_nPrimOfsX; @@ -1404,17 +1398,17 @@ void CGSH_OpenGL::Prim_Line() rgbaq[0] <<= m_VtxBuffer[1].nRGBAQ; rgbaq[1] <<= m_VtxBuffer[0].nRGBAQ; - float nS[2] = { 0 ,0 }; - float nT[2] = { 0, 0 }; - float nQ[2] = { 1, 1 }; + float nS[2] = {0, 0}; + float nT[2] = {0, 0}; + float nQ[2] = {1, 1}; auto color1 = MakeColor( - rgbaq[0].nR, rgbaq[0].nG, - rgbaq[0].nB, rgbaq[0].nA); + rgbaq[0].nR, rgbaq[0].nG, + rgbaq[0].nB, rgbaq[0].nA); auto color2 = MakeColor( - rgbaq[1].nR, rgbaq[1].nG, - rgbaq[1].nB, rgbaq[1].nA); + rgbaq[1].nR, rgbaq[1].nG, + rgbaq[1].nB, rgbaq[1].nA); // clang-format off PRIM_VERTEX vertices[] = @@ -1469,9 +1463,9 @@ void CGSH_OpenGL::Prim_Triangle() nF1 = nF2 = nF3 = 0.0; } - float nS[3] = { 0 ,0, 0 }; - float nT[3] = { 0, 0, 0 }; - float nQ[3] = { 1, 1, 1 }; + float nS[3] = {0, 0, 0}; + float nT[3] = {0, 0, 0}; + float nQ[3] = {1, 1, 1}; if(m_PrimitiveMode.nTexture) { @@ -1497,8 +1491,12 @@ void CGSH_OpenGL::Prim_Triangle() st[1] <<= m_VtxBuffer[1].nST; st[2] <<= m_VtxBuffer[0].nST; - nS[0] = st[0].nS; nS[1] = st[1].nS; nS[2] = st[2].nS; - nT[0] = st[0].nT; nT[1] = st[1].nT; nT[2] = st[2].nT; + nS[0] = st[0].nS; + nS[1] = st[1].nS; + nS[2] = st[2].nS; + nT[0] = st[0].nT; + nT[1] = st[1].nT; + nT[2] = st[2].nT; bool isQ0Neg = (rgbaq[0].nQ < 0); bool isQ1Neg = (rgbaq[1].nQ < 0); @@ -1507,21 +1505,23 @@ void CGSH_OpenGL::Prim_Triangle() assert(isQ0Neg == isQ1Neg); assert(isQ1Neg == isQ2Neg); - nQ[0] = rgbaq[0].nQ; nQ[1] = rgbaq[1].nQ; nQ[2] = rgbaq[2].nQ; + nQ[0] = rgbaq[0].nQ; + nQ[1] = rgbaq[1].nQ; + nQ[2] = rgbaq[2].nQ; } } auto color1 = MakeColor( - rgbaq[0].nR, rgbaq[0].nG, - rgbaq[0].nB, rgbaq[0].nA); + rgbaq[0].nR, rgbaq[0].nG, + rgbaq[0].nB, rgbaq[0].nA); auto color2 = MakeColor( - rgbaq[1].nR, rgbaq[1].nG, - rgbaq[1].nB, rgbaq[1].nA); + rgbaq[1].nR, rgbaq[1].nG, + rgbaq[1].nB, rgbaq[1].nA); auto color3 = MakeColor( - rgbaq[2].nR, rgbaq[2].nG, - rgbaq[2].nB, rgbaq[2].nA); + rgbaq[2].nR, rgbaq[2].nG, + rgbaq[2].nB, rgbaq[2].nA); if(m_PrimitiveMode.nShading == 0) { @@ -1554,8 +1554,11 @@ void CGSH_OpenGL::Prim_Sprite() xyz[0] <<= m_VtxBuffer[1].nPosition; xyz[1] <<= m_VtxBuffer[0].nPosition; - float nX1 = xyz[0].GetX(); float nY1 = xyz[0].GetY(); - float nX2 = xyz[1].GetX(); float nY2 = xyz[1].GetY(); float nZ = xyz[1].GetZ(); + float nX1 = xyz[0].GetX(); + float nY1 = xyz[0].GetY(); + float nX2 = xyz[1].GetX(); + float nY2 = xyz[1].GetY(); + float nZ = xyz[1].GetZ(); RGBAQ rgbaq[2]; rgbaq[0] <<= m_VtxBuffer[1].nRGBAQ; @@ -1569,8 +1572,8 @@ void CGSH_OpenGL::Prim_Sprite() nZ = GetZ(nZ); - float nS[2] = { 0 ,0 }; - float nT[2] = { 0, 0 }; + float nS[2] = {0, 0}; + float nT[2] = {0, 0}; if(m_PrimitiveMode.nTexture) { @@ -1607,19 +1610,19 @@ void CGSH_OpenGL::Prim_Sprite() } auto color = MakeColor( - rgbaq[1].nR, rgbaq[1].nG, - rgbaq[1].nB, rgbaq[1].nA); + rgbaq[1].nR, rgbaq[1].nG, + rgbaq[1].nB, rgbaq[1].nA); PRIM_VERTEX vertices[] = - { - { nX1, nY1, nZ, color, nS[0], nT[0], 1, 0 }, - { nX2, nY1, nZ, color, nS[1], nT[0], 1, 0 }, - { nX1, nY2, nZ, color, nS[0], nT[1], 1, 0 }, + { + {nX1, nY1, nZ, color, nS[0], nT[0], 1, 0}, + {nX2, nY1, nZ, color, nS[1], nT[0], 1, 0}, + {nX1, nY2, nZ, color, nS[0], nT[1], 1, 0}, - { nX1, nY2, nZ, color, nS[0], nT[1], 1, 0 }, - { nX2, nY1, nZ, color, nS[1], nT[0], 1, 0 }, - { nX2, nY2, nZ, color, nS[1], nT[1], 1, 0 }, - }; + {nX1, nY2, nZ, color, nS[0], nT[1], 1, 0}, + {nX2, nY1, nZ, color, nS[1], nT[0], 1, 0}, + {nX2, nY2, nZ, color, nS[1], nT[1], 1, 0}, + }; assert((m_vertexBuffer.size() + 6) <= VERTEX_BUFFER_SIZE); m_vertexBuffer.insert(m_vertexBuffer.end(), std::begin(vertices), std::end(vertices)); @@ -1715,7 +1718,7 @@ void CGSH_OpenGL::DoRenderPass() { glEnable(GL_SCISSOR_TEST); glScissor(m_renderState.scissorX * m_fbScale, m_renderState.scissorY * m_fbScale, - m_renderState.scissorWidth * m_fbScale, m_renderState.scissorHeight * m_fbScale); + m_renderState.scissorWidth * m_fbScale, m_renderState.scissorHeight * m_fbScale); m_validGlState |= GLSTATE_SCISSOR; } @@ -1734,8 +1737,8 @@ void CGSH_OpenGL::DoRenderPass() if((m_validGlState & GLSTATE_COLORMASK) == 0) { glColorMask( - m_renderState.colorMaskR, m_renderState.colorMaskG, - m_renderState.colorMaskB, m_renderState.colorMaskA); + m_renderState.colorMaskR, m_renderState.colorMaskG, + m_renderState.colorMaskB, m_renderState.colorMaskA); m_validGlState |= GLSTATE_COLORMASK; } @@ -1844,9 +1847,9 @@ void CGSH_OpenGL::DrawToDepth(unsigned int primitiveType, uint64 primReg) } void CGSH_OpenGL::CopyToFb( - int32 srcX0, int32 srcY0, int32 srcX1, int32 srcY1, - int32 srcWidth, int32 srcHeight, - int32 dstX0, int32 dstY0, int32 dstX1, int32 dstY1) + int32 srcX0, int32 srcY0, int32 srcX1, int32 srcY1, + int32 srcWidth, int32 srcHeight, + int32 dstX0, int32 dstY0, int32 dstX1, int32 dstY1) { m_validGlState &= ~(GLSTATE_BLEND | GLSTATE_COLORMASK | GLSTATE_SCISSOR | GLSTATE_PROGRAM); m_validGlState &= ~(GLSTATE_VIEWPORT | GLSTATE_DEPTHTEST | GLSTATE_DEPTHMASK); @@ -1896,33 +1899,33 @@ void CGSH_OpenGL::WriteRegisterImpl(uint8 nRegister, uint64 nData) switch(nRegister) { case GS_REG_PRIM: + { + unsigned int newPrimitiveType = static_cast(nData & 0x07); + if(newPrimitiveType != m_primitiveType) { - unsigned int newPrimitiveType = static_cast(nData & 0x07); - if(newPrimitiveType != m_primitiveType) - { - FlushVertexBuffer(); - } - m_primitiveType = newPrimitiveType; - switch(m_primitiveType) - { - case PRIM_POINT: - m_nVtxCount = 1; - break; - case PRIM_LINE: - case PRIM_LINESTRIP: - m_nVtxCount = 2; - break; - case PRIM_TRIANGLE: - case PRIM_TRIANGLESTRIP: - case PRIM_TRIANGLEFAN: - m_nVtxCount = 3; - break; - case PRIM_SPRITE: - m_nVtxCount = 2; - break; - } + FlushVertexBuffer(); } - break; + m_primitiveType = newPrimitiveType; + switch(m_primitiveType) + { + case PRIM_POINT: + m_nVtxCount = 1; + break; + case PRIM_LINE: + case PRIM_LINESTRIP: + m_nVtxCount = 2; + break; + case PRIM_TRIANGLE: + case PRIM_TRIANGLESTRIP: + case PRIM_TRIANGLEFAN: + m_nVtxCount = 3; + break; + case PRIM_SPRITE: + m_nVtxCount = 2; + break; + } + } + break; case GS_REG_XYZ2: case GS_REG_XYZ3: @@ -1944,19 +1947,19 @@ void CGSH_OpenGL::VertexKick(uint8 nRegister, uint64 nValue) if(nFog) { - m_VtxBuffer[m_nVtxCount - 1].nPosition = nValue & 0x00FFFFFFFFFFFFFFULL; - m_VtxBuffer[m_nVtxCount - 1].nRGBAQ = m_nReg[GS_REG_RGBAQ]; - m_VtxBuffer[m_nVtxCount - 1].nUV = m_nReg[GS_REG_UV]; - m_VtxBuffer[m_nVtxCount - 1].nST = m_nReg[GS_REG_ST]; - m_VtxBuffer[m_nVtxCount - 1].nFog = (uint8)(nValue >> 56); + m_VtxBuffer[m_nVtxCount - 1].nPosition = nValue & 0x00FFFFFFFFFFFFFFULL; + m_VtxBuffer[m_nVtxCount - 1].nRGBAQ = m_nReg[GS_REG_RGBAQ]; + m_VtxBuffer[m_nVtxCount - 1].nUV = m_nReg[GS_REG_UV]; + m_VtxBuffer[m_nVtxCount - 1].nST = m_nReg[GS_REG_ST]; + m_VtxBuffer[m_nVtxCount - 1].nFog = (uint8)(nValue >> 56); } else { - m_VtxBuffer[m_nVtxCount - 1].nPosition = nValue; - m_VtxBuffer[m_nVtxCount - 1].nRGBAQ = m_nReg[GS_REG_RGBAQ]; - m_VtxBuffer[m_nVtxCount - 1].nUV = m_nReg[GS_REG_UV]; - m_VtxBuffer[m_nVtxCount - 1].nST = m_nReg[GS_REG_ST]; - m_VtxBuffer[m_nVtxCount - 1].nFog = (uint8)(m_nReg[GS_REG_FOG] >> 56); + m_VtxBuffer[m_nVtxCount - 1].nPosition = nValue; + m_VtxBuffer[m_nVtxCount - 1].nRGBAQ = m_nReg[GS_REG_RGBAQ]; + m_VtxBuffer[m_nVtxCount - 1].nUV = m_nReg[GS_REG_UV]; + m_VtxBuffer[m_nVtxCount - 1].nST = m_nReg[GS_REG_ST]; + m_VtxBuffer[m_nVtxCount - 1].nFog = (uint8)(m_nReg[GS_REG_FOG] >> 56); } m_nVtxCount--; @@ -2071,12 +2074,10 @@ void CGSH_OpenGL::ProcessLocalToHostTransfer() if((trxReg.nRRW != 32) || (trxReg.nRRH != 32)) return; if((trxPos.nSSAX != 0) || (trxPos.nSSAY != 0)) return; - auto framebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), - [] (const FramebufferPtr& framebuffer) - { - return (framebuffer->m_psm == PSMCT32) && (framebuffer->m_basePtr == 0); - } - ); + auto framebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), + [](const FramebufferPtr& framebuffer) { + return (framebuffer->m_psm == PSMCT32) && (framebuffer->m_basePtr == 0); + }); if(framebufferIterator == std::end(m_framebuffers)) return; const auto& framebuffer = (*framebufferIterator); @@ -2102,29 +2103,25 @@ void CGSH_OpenGL::ProcessLocalToHostTransfer() } } - delete [] pixels; + delete[] pixels; } void CGSH_OpenGL::ProcessLocalToLocalTransfer() { auto bltBuf = make_convertible(m_nReg[GS_REG_BITBLTBUF]); - auto srcFramebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), - [&] (const FramebufferPtr& framebuffer) - { - return (framebuffer->m_basePtr == bltBuf.GetSrcPtr()) && - (framebuffer->m_width == bltBuf.GetSrcWidth()); - } - ); - auto dstFramebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), - [&] (const FramebufferPtr& framebuffer) - { - return (framebuffer->m_basePtr == bltBuf.GetDstPtr()) && - (framebuffer->m_width == bltBuf.GetDstWidth()); - } - ); + auto srcFramebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), + [&](const FramebufferPtr& framebuffer) { + return (framebuffer->m_basePtr == bltBuf.GetSrcPtr()) && + (framebuffer->m_width == bltBuf.GetSrcWidth()); + }); + auto dstFramebufferIterator = std::find_if(m_framebuffers.begin(), m_framebuffers.end(), + [&](const FramebufferPtr& framebuffer) { + return (framebuffer->m_basePtr == bltBuf.GetDstPtr()) && + (framebuffer->m_width == bltBuf.GetDstWidth()); + }); if( - srcFramebufferIterator != std::end(m_framebuffers) && - dstFramebufferIterator != std::end(m_framebuffers)) + srcFramebufferIterator != std::end(m_framebuffers) && + dstFramebufferIterator != std::end(m_framebuffers)) { FlushVertexBuffer(); m_renderState.isValid = false; @@ -2137,9 +2134,9 @@ void CGSH_OpenGL::ProcessLocalToLocalTransfer() //Copy buffers glBlitFramebuffer( - 0, 0, srcFramebuffer->m_width * m_fbScale, srcFramebuffer->m_height * m_fbScale, - 0, 0, srcFramebuffer->m_width * m_fbScale, srcFramebuffer->m_height * m_fbScale, - GL_COLOR_BUFFER_BIT, GL_NEAREST); + 0, 0, srcFramebuffer->m_width * m_fbScale, srcFramebuffer->m_height * m_fbScale, + 0, 0, srcFramebuffer->m_width * m_fbScale, srcFramebuffer->m_height * m_fbScale, + GL_COLOR_BUFFER_BIT, GL_NEAREST); CHECKGLERROR(); glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); @@ -2179,10 +2176,10 @@ Framework::CBitmap CGSH_OpenGL::GetScreenshot() ///////////////////////////////////////////////////////////// CGSH_OpenGL::CFramebuffer::CFramebuffer(uint32 basePtr, uint32 width, uint32 height, uint32 psm, uint32 scale, bool multisampled) -: m_basePtr(basePtr) -, m_width(width) -, m_height(height) -, m_psm(psm) + : m_basePtr(basePtr) + , m_width(width) + , m_height(height) + , m_psm(psm) { m_cachedArea.SetArea(psm, basePtr, width, height); @@ -2200,7 +2197,7 @@ CGSH_OpenGL::CFramebuffer::CFramebuffer(uint32 basePtr, uint32 width, uint32 hei glRenderbufferStorageMultisample(GL_RENDERBUFFER, NUM_SAMPLES, GL_RGBA8, m_width * scale, m_height * scale); CHECKGLERROR(); } - + //Build framebuffer glGenFramebuffers(1, &m_framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); @@ -2255,21 +2252,21 @@ void CGSH_OpenGL::PopulateFramebuffer(const FramebufferPtr& framebuffer) glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_copyToFbTexture); glTexImage2D(GL_TEXTURE_2D, 0, texFormat.internalFormat, framebuffer->m_width, framebuffer->m_height, - 0, texFormat.format, texFormat.type, nullptr); + 0, texFormat.format, texFormat.type, nullptr); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - ((this)->*(m_textureUpdater[framebuffer->m_psm]))(framebuffer->m_basePtr, - framebuffer->m_width / 64, 0, 0, framebuffer->m_width, framebuffer->m_height); + ((this)->*(m_textureUpdater[framebuffer->m_psm]))(framebuffer->m_basePtr, + framebuffer->m_width / 64, 0, 0, framebuffer->m_width, framebuffer->m_height); CHECKGLERROR(); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer->m_framebuffer); CopyToFb( - 0, 0, framebuffer->m_width, framebuffer->m_height, - framebuffer->m_width, framebuffer->m_height, - 0, 0, framebuffer->m_width * m_fbScale, framebuffer->m_height * m_fbScale); + 0, 0, framebuffer->m_width, framebuffer->m_height, + framebuffer->m_width, framebuffer->m_height, + 0, 0, framebuffer->m_width * m_fbScale, framebuffer->m_height * m_fbScale); framebuffer->m_resolveNeeded = true; CHECKGLERROR(); @@ -2288,8 +2285,8 @@ void CGSH_OpenGL::CommitFramebufferDirtyPages(const FramebufferPtr& framebuffer, glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, copyToFbTexture); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, framebuffer->m_width, framebuffer->m_height, - 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, framebuffer->m_width, framebuffer->m_height, + 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); @@ -2344,12 +2341,12 @@ void CGSH_OpenGL::CommitFramebufferDirtyPages(const FramebufferPtr& framebuffer, copyToFbEnabler.EnableCopyToFb(framebuffer, m_copyToFbTexture); ((this)->*(m_textureUpdater[framebuffer->m_psm]))(framebuffer->m_basePtr, framebuffer->m_width / 64, - texX, texY, texWidth, texHeight); + texX, texY, texWidth, texHeight); CopyToFb( - texX, texY, (texX + texWidth), (texY + texHeight), - framebuffer->m_width, framebuffer->m_height, - texX * m_fbScale, texY * m_fbScale, (texX + texWidth) * m_fbScale, (texY + texHeight) * m_fbScale); + texX, texY, (texX + texWidth), (texY + texHeight), + framebuffer->m_width, framebuffer->m_height, + texX * m_fbScale, texY * m_fbScale, (texX + texWidth) * m_fbScale, (texY + texHeight) * m_fbScale); framebuffer->m_resolveNeeded = true; CHECKGLERROR(); @@ -2370,9 +2367,9 @@ void CGSH_OpenGL::ResolveFramebufferMultisample(const FramebufferPtr& framebuffe glBindFramebuffer(GL_FRAMEBUFFER, framebuffer->m_resolveFramebuffer); glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer->m_framebuffer); glBlitFramebuffer( - 0, 0, framebuffer->m_width * scale, framebuffer->m_height * scale, - 0, 0, framebuffer->m_width * scale, framebuffer->m_height * scale, - GL_COLOR_BUFFER_BIT, GL_NEAREST); + 0, 0, framebuffer->m_width * scale, framebuffer->m_height * scale, + 0, 0, framebuffer->m_width * scale, framebuffer->m_height * scale, + GL_COLOR_BUFFER_BIT, GL_NEAREST); CHECKGLERROR(); framebuffer->m_resolveNeeded = false; @@ -2383,11 +2380,11 @@ void CGSH_OpenGL::ResolveFramebufferMultisample(const FramebufferPtr& framebuffe ///////////////////////////////////////////////////////////// CGSH_OpenGL::CDepthbuffer::CDepthbuffer(uint32 basePtr, uint32 width, uint32 height, uint32 psm, uint32 scale, bool multisampled) -: m_basePtr(basePtr) -, m_width(width) -, m_height(height) -, m_psm(psm) -, m_depthBuffer(0) + : m_basePtr(basePtr) + , m_width(width) + , m_height(height) + , m_psm(psm) + , m_depthBuffer(0) { //Build depth attachment glGenRenderbuffers(1, &m_depthBuffer); diff --git a/Source/gs/GSH_OpenGL/GSH_OpenGL.h b/Source/gs/GSH_OpenGL/GSH_OpenGL.h index d9b80130c..e6c8ec76d 100644 --- a/Source/gs/GSH_OpenGL/GSH_OpenGL.h +++ b/Source/gs/GSH_OpenGL/GSH_OpenGL.h @@ -10,37 +10,37 @@ #include "opengl/Shader.h" #include "opengl/Resource.h" -#define PREF_CGSH_OPENGL_ENABLEHIGHRESMODE "renderer.opengl.enablehighresmode" -#define PREF_CGSH_OPENGL_FORCEBILINEARTEXTURES "renderer.opengl.forcebilineartextures" +#define PREF_CGSH_OPENGL_ENABLEHIGHRESMODE "renderer.opengl.enablehighresmode" +#define PREF_CGSH_OPENGL_FORCEBILINEARTEXTURES "renderer.opengl.forcebilineartextures" class CGSH_OpenGL : public CGSHandler { public: - CGSH_OpenGL(); - virtual ~CGSH_OpenGL(); + CGSH_OpenGL(); + virtual ~CGSH_OpenGL(); - static void RegisterPreferences(); + static void RegisterPreferences(); - virtual void LoadState(Framework::CZipArchiveReader&) override; - - void ProcessHostToLocalTransfer() override; - void ProcessLocalToHostTransfer() override; - void ProcessLocalToLocalTransfer() override; - void ProcessClutTransfer(uint32, uint32) override; - void ReadFramebuffer(uint32, uint32, void*) override; + virtual void LoadState(Framework::CZipArchiveReader&) override; - Framework::CBitmap GetScreenshot() override; + void ProcessHostToLocalTransfer() override; + void ProcessLocalToHostTransfer() override; + void ProcessLocalToLocalTransfer() override; + void ProcessClutTransfer(uint32, uint32) override; + void ReadFramebuffer(uint32, uint32, void*) override; + + Framework::CBitmap GetScreenshot() override; protected: - void PalCache_Flush(); - void LoadPreferences(); - void InitializeImpl() override; - void ReleaseImpl() override; - void ResetImpl() override; - void NotifyPreferencesChangedImpl() override; - void FlipImpl() override; + void PalCache_Flush(); + void LoadPreferences(); + void InitializeImpl() override; + void ReleaseImpl() override; + void ResetImpl() override; + void NotifyPreferencesChangedImpl() override; + void FlipImpl() override; - GLuint m_presentFramebuffer = 0; + GLuint m_presentFramebuffer = 0; private: typedef CGsTextureCache TextureCache; @@ -53,90 +53,93 @@ private: struct SHADERCAPS : public convertible { - unsigned int texFunction : 2; //0 - Modulate, 1 - Decal, 2 - Highlight, 3 - Hightlight2 - unsigned int texClampS : 2; - unsigned int texClampT : 2; - unsigned int texSourceMode : 2; - unsigned int texHasAlpha : 1; - unsigned int texBilinearFilter : 1; - unsigned int texUseAlphaExpansion : 1; - unsigned int texBlackIsTransparent : 1; - unsigned int hasFog : 1; - unsigned int hasAlphaTest : 1; - unsigned int alphaTestMethod : 3; - unsigned int padding : 15; + unsigned int texFunction : 2; //0 - Modulate, 1 - Decal, 2 - Highlight, 3 - Hightlight2 + unsigned int texClampS : 2; + unsigned int texClampT : 2; + unsigned int texSourceMode : 2; + unsigned int texHasAlpha : 1; + unsigned int texBilinearFilter : 1; + unsigned int texUseAlphaExpansion : 1; + unsigned int texBlackIsTransparent : 1; + unsigned int hasFog : 1; + unsigned int hasAlphaTest : 1; + unsigned int alphaTestMethod : 3; + unsigned int padding : 15; - bool isIndexedTextureSource() const { return texSourceMode == TEXTURE_SOURCE_MODE_IDX4 || texSourceMode == TEXTURE_SOURCE_MODE_IDX8; } + bool isIndexedTextureSource() const + { + return texSourceMode == TEXTURE_SOURCE_MODE_IDX4 || texSourceMode == TEXTURE_SOURCE_MODE_IDX8; + } }; static_assert(sizeof(SHADERCAPS) == sizeof(uint32), "SHADERCAPS structure size must be 4 bytes."); struct RENDERSTATE { - bool isValid; - bool isTextureStateValid; - bool isFramebufferStateValid; + bool isValid; + bool isTextureStateValid; + bool isFramebufferStateValid; //Register State - uint64 primReg; - uint64 frameReg; - uint64 testReg; - uint64 alphaReg; - uint64 zbufReg; - uint64 scissorReg; - uint64 tex0Reg; - uint64 tex1Reg; - uint64 texAReg; - uint64 clampReg; - uint64 fogColReg; + uint64 primReg; + uint64 frameReg; + uint64 testReg; + uint64 alphaReg; + uint64 zbufReg; + uint64 scissorReg; + uint64 tex0Reg; + uint64 tex1Reg; + uint64 texAReg; + uint64 clampReg; + uint64 fogColReg; //Intermediate State - TECHNIQUE technique; - SHADERCAPS shaderCaps; + TECHNIQUE technique; + SHADERCAPS shaderCaps; //OpenGL state - GLuint shaderHandle; - GLuint framebufferHandle; - GLuint texture0Handle; - GLint texture0MinFilter; - GLint texture0MagFilter; - GLint texture0WrapS; - GLint texture0WrapT; - GLuint texture1Handle; - GLsizei viewportWidth; - GLsizei viewportHeight; - GLint scissorX; - GLint scissorY; - GLsizei scissorWidth; - GLsizei scissorHeight; - bool blendEnabled; - bool colorMaskR; - bool colorMaskG; - bool colorMaskB; - bool colorMaskA; - bool depthMask; - bool depthTest; + GLuint shaderHandle; + GLuint framebufferHandle; + GLuint texture0Handle; + GLint texture0MinFilter; + GLint texture0MagFilter; + GLint texture0WrapS; + GLint texture0WrapT; + GLuint texture1Handle; + GLsizei viewportWidth; + GLsizei viewportHeight; + GLint scissorX; + GLint scissorY; + GLsizei scissorWidth; + GLsizei scissorHeight; + bool blendEnabled; + bool colorMaskR; + bool colorMaskG; + bool colorMaskB; + bool colorMaskA; + bool depthMask; + bool depthTest; }; //These need to match the layout of the shader's uniform block struct VERTEXPARAMS { - float projMatrix[16]; - float texMatrix[16]; + float projMatrix[16]; + float texMatrix[16]; }; static_assert(sizeof(VERTEXPARAMS) == 0x80, "Size of VERTEXPARAMS must be 128 bytes."); struct FRAGMENTPARAMS { - float textureSize[2]; - float texelSize[2]; - float clampMin[2]; - float clampMax[2]; - float texA0; - float texA1; - float alphaRef; - float padding1; - float fogColor[3]; - float padding2; + float textureSize[2]; + float texelSize[2]; + float clampMin[2]; + float clampMax[2]; + float texA0; + float texA1; + float alphaRef; + float padding1; + float fogColor[3]; + float padding2; }; static_assert(sizeof(FRAGMENTPARAMS) == 0x40, "Size of FRAGMENTPARAMS must be 64 bytes."); @@ -155,27 +158,27 @@ private: struct VERTEX { - uint64 nPosition; - uint64 nRGBAQ; - uint64 nUV; - uint64 nST; - uint8 nFog; + uint64 nPosition; + uint64 nRGBAQ; + uint64 nUV; + uint64 nST; + uint8 nFog; }; enum { - TEXTURE_SOURCE_MODE_NONE = 0, - TEXTURE_SOURCE_MODE_STD = 1, - TEXTURE_SOURCE_MODE_IDX4 = 2, - TEXTURE_SOURCE_MODE_IDX8 = 3 + TEXTURE_SOURCE_MODE_NONE = 0, + TEXTURE_SOURCE_MODE_STD = 1, + TEXTURE_SOURCE_MODE_IDX4 = 2, + TEXTURE_SOURCE_MODE_IDX8 = 3 }; enum TEXTURE_CLAMP_MODE { - TEXTURE_CLAMP_MODE_STD = 0, - TEXTURE_CLAMP_MODE_REGION_CLAMP = 1, - TEXTURE_CLAMP_MODE_REGION_REPEAT = 2, - TEXTURE_CLAMP_MODE_REGION_REPEAT_SIMPLE = 3 + TEXTURE_CLAMP_MODE_STD = 0, + TEXTURE_CLAMP_MODE_REGION_CLAMP = 1, + TEXTURE_CLAMP_MODE_REGION_REPEAT = 2, + TEXTURE_CLAMP_MODE_REGION_REPEAT_SIMPLE = 3 }; typedef std::unordered_map ShaderMap; @@ -183,19 +186,19 @@ private: class CPalette { public: - CPalette(); - ~CPalette(); + CPalette(); + ~CPalette(); - void Invalidate(uint32); - void Free(); + void Invalidate(uint32); + void Free(); - bool m_live; + bool m_live; - bool m_isIDTEX4; - uint32 m_cpsm; - uint32 m_csa; - GLuint m_texture; - uint32 m_contents[256]; + bool m_isIDTEX4; + uint32 m_cpsm; + uint32 m_csa; + GLuint m_texture; + uint32 m_contents[256]; }; typedef std::shared_ptr PalettePtr; typedef std::list PaletteList; @@ -203,22 +206,22 @@ private: class CFramebuffer { public: - CFramebuffer(uint32, uint32, uint32, uint32, uint32, bool); - ~CFramebuffer(); + CFramebuffer(uint32, uint32, uint32, uint32, uint32, bool); + ~CFramebuffer(); - uint32 m_basePtr; - uint32 m_width; - uint32 m_height; - uint32 m_psm; + uint32 m_basePtr; + uint32 m_width; + uint32 m_height; + uint32 m_psm; - GLuint m_framebuffer = 0; - GLuint m_texture = 0; + GLuint m_framebuffer = 0; + GLuint m_texture = 0; - GLuint m_resolveFramebuffer = 0; - bool m_resolveNeeded = false; - GLuint m_colorBufferMs = 0; + GLuint m_resolveFramebuffer = 0; + bool m_resolveNeeded = false; + GLuint m_colorBufferMs = 0; - CGsCachedArea m_cachedArea; + CGsCachedArea m_cachedArea; }; typedef std::shared_ptr FramebufferPtr; typedef std::vector FramebufferList; @@ -226,24 +229,24 @@ private: class CDepthbuffer { public: - CDepthbuffer(uint32, uint32, uint32, uint32, uint32, bool); - ~CDepthbuffer(); + CDepthbuffer(uint32, uint32, uint32, uint32, uint32, bool); + ~CDepthbuffer(); - uint32 m_basePtr; - uint32 m_width; - uint32 m_height; - uint32 m_psm; - GLuint m_depthBuffer; + uint32 m_basePtr; + uint32 m_width; + uint32 m_height; + uint32 m_psm; + GLuint m_depthBuffer; }; typedef std::shared_ptr DepthbufferPtr; typedef std::vector DepthbufferList; struct TEXTURE_INFO { - GLuint textureHandle = 0; - float offsetX = 0; - float scaleRatioX = 1; - float scaleRatioY = 1; + GLuint textureHandle = 0; + float offsetX = 0; + float scaleRatioX = 1; + float scaleRatioY = 1; }; struct TEXTUREFORMAT_INFO @@ -276,157 +279,160 @@ private: typedef std::vector VertexBuffer; - void WriteRegisterImpl(uint8, uint64) override; + void WriteRegisterImpl(uint8, uint64) override; - void InitializeRC(); - void SetupTextureUpdaters(); - virtual void PresentBackbuffer() = 0; - void MakeLinearZOrtho(float*, float, float, float, float); - unsigned int GetCurrentReadCircuit(); - TEXTURE_INFO PrepareTexture(const TEX0&); - GLuint PreparePalette(const TEX0&); + void InitializeRC(); + void SetupTextureUpdaters(); + virtual void PresentBackbuffer() = 0; + void MakeLinearZOrtho(float*, float, float, float, float); + unsigned int GetCurrentReadCircuit(); + TEXTURE_INFO PrepareTexture(const TEX0&); + GLuint PreparePalette(const TEX0&); - float GetZ(float); + float GetZ(float); - void VertexKick(uint8, uint64); + void VertexKick(uint8, uint64); - Framework::OpenGl::ProgramPtr GetShaderFromCaps(const SHADERCAPS&); - Framework::OpenGl::ProgramPtr GenerateShader(const SHADERCAPS&); - Framework::OpenGl::CShader GenerateVertexShader(const SHADERCAPS&); - Framework::OpenGl::CShader GenerateFragmentShader(const SHADERCAPS&); - std::string GenerateTexCoordClampingSection(TEXTURE_CLAMP_MODE, const char*); - std::string GenerateAlphaTestSection(ALPHA_TEST_METHOD); + Framework::OpenGl::ProgramPtr GetShaderFromCaps(const SHADERCAPS&); + Framework::OpenGl::ProgramPtr GenerateShader(const SHADERCAPS&); + Framework::OpenGl::CShader GenerateVertexShader(const SHADERCAPS&); + Framework::OpenGl::CShader GenerateFragmentShader(const SHADERCAPS&); + std::string GenerateTexCoordClampingSection(TEXTURE_CLAMP_MODE, const char*); + std::string GenerateAlphaTestSection(ALPHA_TEST_METHOD); - Framework::OpenGl::ProgramPtr GeneratePresentProgram(); - Framework::OpenGl::CBuffer GeneratePresentVertexBuffer(); - Framework::OpenGl::CVertexArray GeneratePresentVertexArray(); + Framework::OpenGl::ProgramPtr GeneratePresentProgram(); + Framework::OpenGl::CBuffer GeneratePresentVertexBuffer(); + Framework::OpenGl::CVertexArray GeneratePresentVertexArray(); - Framework::OpenGl::ProgramPtr GenerateCopyToFbProgram(); - Framework::OpenGl::CBuffer GenerateCopyToFbVertexBuffer(); - Framework::OpenGl::CVertexArray GenerateCopyToFbVertexArray(); + Framework::OpenGl::ProgramPtr GenerateCopyToFbProgram(); + Framework::OpenGl::CBuffer GenerateCopyToFbVertexBuffer(); + Framework::OpenGl::CVertexArray GenerateCopyToFbVertexArray(); - Framework::OpenGl::CVertexArray GeneratePrimVertexArray(); - Framework::OpenGl::CBuffer GenerateUniformBlockBuffer(size_t); + Framework::OpenGl::CVertexArray GeneratePrimVertexArray(); + Framework::OpenGl::CBuffer GenerateUniformBlockBuffer(size_t); - void Prim_Point(); - void Prim_Line(); - void Prim_Triangle(); - void Prim_Sprite(); + void Prim_Point(); + void Prim_Line(); + void Prim_Triangle(); + void Prim_Sprite(); - void FlushVertexBuffer(); - void DoRenderPass(); + void FlushVertexBuffer(); + void DoRenderPass(); - void CopyToFb(int32, int32, int32, int32, int32, int32, int32, int32, int32, int32); - void DrawToDepth(unsigned int, uint64); + void CopyToFb(int32, int32, int32, int32, int32, int32, int32, int32, int32, int32); + void DrawToDepth(unsigned int, uint64); - void SetRenderingContext(uint64); - void SetupTestFunctions(uint64); - void SetupDepthBuffer(uint64, uint64); - void SetupFramebuffer(uint64, uint64, uint64, uint64); - void SetupBlendingFunction(uint64); - void SetupFogColor(uint64); + void SetRenderingContext(uint64); + void SetupTestFunctions(uint64); + void SetupDepthBuffer(uint64, uint64); + void SetupFramebuffer(uint64, uint64, uint64, uint64); + void SetupBlendingFunction(uint64); + void SetupFogColor(uint64); - static bool CanRegionRepeatClampModeSimplified(uint32, uint32); - void FillShaderCapsFromTexture(SHADERCAPS&, const uint64&, const uint64&, const uint64&, const uint64&); - void FillShaderCapsFromTest(SHADERCAPS&, const uint64&); - TECHNIQUE GetTechniqueFromTest(const uint64&); + static bool CanRegionRepeatClampModeSimplified(uint32, uint32); + void FillShaderCapsFromTexture(SHADERCAPS&, const uint64&, const uint64&, const uint64&, const uint64&); + void FillShaderCapsFromTest(SHADERCAPS&, const uint64&); + TECHNIQUE GetTechniqueFromTest(const uint64&); - void SetupTexture(uint64, uint64, uint64, uint64, uint64); - static uint32 GetFramebufferBitDepth(uint32); - static TEXTUREFORMAT_INFO GetTextureFormatInfo(uint32); + void SetupTexture(uint64, uint64, uint64, uint64, uint64); + static uint32 GetFramebufferBitDepth(uint32); + static TEXTUREFORMAT_INFO GetTextureFormatInfo(uint32); - FramebufferPtr FindFramebuffer(const FRAME&) const; - DepthbufferPtr FindDepthbuffer(const ZBUF&, const FRAME&) const; + FramebufferPtr FindFramebuffer(const FRAME&) const; + DepthbufferPtr FindDepthbuffer(const ZBUF&, const FRAME&) const; - void DumpTexture(unsigned int, unsigned int, uint32); + void DumpTexture(unsigned int, unsigned int, uint32); //Texture updaters - void TexUpdater_Invalid(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); + void TexUpdater_Invalid(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); - void TexUpdater_Psm32(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); - template void TexUpdater_Psm16(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); + void TexUpdater_Psm32(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); + template + void TexUpdater_Psm16(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); - template void TexUpdater_Psm48(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); - template void TexUpdater_Psm48H(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); + template + void TexUpdater_Psm48(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); + template + void TexUpdater_Psm48H(uint32, uint32, unsigned int, unsigned int, unsigned int, unsigned int); //Context variables (put this in a struct or something?) - float m_nPrimOfsX; - float m_nPrimOfsY; - uint32 m_nTexWidth; - uint32 m_nTexHeight; - float m_nMaxZ; + float m_nPrimOfsX; + float m_nPrimOfsY; + uint32 m_nTexWidth; + uint32 m_nTexHeight; + float m_nMaxZ; - bool m_forceBilinearTextures = false; - unsigned int m_fbScale = 1; - bool m_multisampleEnabled = false; - bool m_accurateAlphaTestEnabled = false; + bool m_forceBilinearTextures = false; + unsigned int m_fbScale = 1; + bool m_multisampleEnabled = false; + bool m_accurateAlphaTestEnabled = false; - uint8* m_pCvtBuffer; + uint8* m_pCvtBuffer; - GLuint PalCache_Search(const TEX0&); - GLuint PalCache_Search(unsigned int, const uint32*); - void PalCache_Insert(const TEX0&, const uint32*, GLuint); - void PalCache_Invalidate(uint32); + GLuint PalCache_Search(const TEX0&); + GLuint PalCache_Search(unsigned int, const uint32*); + void PalCache_Insert(const TEX0&, const uint32*, GLuint); + void PalCache_Invalidate(uint32); - void PopulateFramebuffer(const FramebufferPtr&); - void CommitFramebufferDirtyPages(const FramebufferPtr&, unsigned int, unsigned int); - void ResolveFramebufferMultisample(const FramebufferPtr&, uint32); + void PopulateFramebuffer(const FramebufferPtr&); + void CommitFramebufferDirtyPages(const FramebufferPtr&, unsigned int, unsigned int); + void ResolveFramebufferMultisample(const FramebufferPtr&, uint32); - Framework::OpenGl::ProgramPtr m_presentProgram; - Framework::OpenGl::CBuffer m_presentVertexBuffer; - Framework::OpenGl::CVertexArray m_presentVertexArray; - GLint m_presentTextureUniform = -1; - GLint m_presentTexCoordScaleUniform = -1; + Framework::OpenGl::ProgramPtr m_presentProgram; + Framework::OpenGl::CBuffer m_presentVertexBuffer; + Framework::OpenGl::CVertexArray m_presentVertexArray; + GLint m_presentTextureUniform = -1; + GLint m_presentTexCoordScaleUniform = -1; - Framework::OpenGl::ProgramPtr m_copyToFbProgram; - Framework::OpenGl::CTexture m_copyToFbTexture; - Framework::OpenGl::CBuffer m_copyToFbVertexBuffer; - Framework::OpenGl::CVertexArray m_copyToFbVertexArray; - GLint m_copyToFbSrcPositionUniform = -1; - GLint m_copyToFbSrcSizeUniform = -1; + Framework::OpenGl::ProgramPtr m_copyToFbProgram; + Framework::OpenGl::CTexture m_copyToFbTexture; + Framework::OpenGl::CBuffer m_copyToFbVertexBuffer; + Framework::OpenGl::CVertexArray m_copyToFbVertexArray; + GLint m_copyToFbSrcPositionUniform = -1; + GLint m_copyToFbSrcSizeUniform = -1; - TextureCache m_textureCache; - PaletteList m_paletteCache; - FramebufferList m_framebuffers; - DepthbufferList m_depthbuffers; + TextureCache m_textureCache; + PaletteList m_paletteCache; + FramebufferList m_framebuffers; + DepthbufferList m_depthbuffers; - Framework::OpenGl::CBuffer m_primBuffer; - Framework::OpenGl::CVertexArray m_primVertexArray; + Framework::OpenGl::CBuffer m_primBuffer; + Framework::OpenGl::CVertexArray m_primVertexArray; - VERTEX m_VtxBuffer[3]; - int m_nVtxCount; + VERTEX m_VtxBuffer[3]; + int m_nVtxCount; - PRMODE m_PrimitiveMode; - unsigned int m_primitiveType; - bool m_drawingToDepth = false; + PRMODE m_PrimitiveMode; + unsigned int m_primitiveType; + bool m_drawingToDepth = false; - static const GLenum g_nativeClampModes[CGSHandler::CLAMP_MODE_MAX]; - static const unsigned int g_shaderClampModes[CGSHandler::CLAMP_MODE_MAX]; - static const unsigned int g_alphaTestInverse[CGSHandler::ALPHA_TEST_MAX]; + static const GLenum g_nativeClampModes[CGSHandler::CLAMP_MODE_MAX]; + static const unsigned int g_shaderClampModes[CGSHandler::CLAMP_MODE_MAX]; + static const unsigned int g_alphaTestInverse[CGSHandler::ALPHA_TEST_MAX]; - TEXTUREUPDATER m_textureUpdater[CGSHandler::PSM_MAX]; + TEXTUREUPDATER m_textureUpdater[CGSHandler::PSM_MAX]; enum GLSTATE_BITS : uint32 { - GLSTATE_VERTEX_PARAMS = 0x0001, + GLSTATE_VERTEX_PARAMS = 0x0001, GLSTATE_FRAGMENT_PARAMS = 0x0002, - GLSTATE_PROGRAM = 0x0004, - GLSTATE_SCISSOR = 0x0008, - GLSTATE_BLEND = 0x0010, - GLSTATE_COLORMASK = 0x0020, - GLSTATE_DEPTHMASK = 0x0040, - GLSTATE_TEXTURE = 0x0080, - GLSTATE_FRAMEBUFFER = 0x0100, - GLSTATE_VIEWPORT = 0x0200, - GLSTATE_DEPTHTEST = 0x0400, + GLSTATE_PROGRAM = 0x0004, + GLSTATE_SCISSOR = 0x0008, + GLSTATE_BLEND = 0x0010, + GLSTATE_COLORMASK = 0x0020, + GLSTATE_DEPTHMASK = 0x0040, + GLSTATE_TEXTURE = 0x0080, + GLSTATE_FRAMEBUFFER = 0x0100, + GLSTATE_VIEWPORT = 0x0200, + GLSTATE_DEPTHTEST = 0x0400, }; - ShaderMap m_shaders; - RENDERSTATE m_renderState; - uint32 m_validGlState = 0; - VERTEXPARAMS m_vertexParams; - FRAGMENTPARAMS m_fragmentParams; - Framework::OpenGl::CBuffer m_vertexParamsBuffer; - Framework::OpenGl::CBuffer m_fragmentParamsBuffer; - VertexBuffer m_vertexBuffer; + ShaderMap m_shaders; + RENDERSTATE m_renderState; + uint32 m_validGlState = 0; + VERTEXPARAMS m_vertexParams; + FRAGMENTPARAMS m_fragmentParams; + Framework::OpenGl::CBuffer m_vertexParamsBuffer; + Framework::OpenGl::CBuffer m_fragmentParamsBuffer; + VertexBuffer m_vertexBuffer; }; diff --git a/Source/gs/GSH_OpenGL/GSH_OpenGL_Shader.cpp b/Source/gs/GSH_OpenGL/GSH_OpenGL_Shader.cpp index a7867ad76..18b14f3b3 100644 --- a/Source/gs/GSH_OpenGL/GSH_OpenGL_Shader.cpp +++ b/Source/gs/GSH_OpenGL/GSH_OpenGL_Shader.cpp @@ -9,50 +9,50 @@ #endif static const char* s_andFunction = -"float and(int a, int b)\r\n" -"{\r\n" -" int r = 0;\r\n" -" int ha, hb;\r\n" -" \r\n" -" int m = int(min(float(a), float(b)));\r\n" -" \r\n" -" for(int k = 1; k <= m; k *= 2)\r\n" -" {\r\n" -" ha = a / 2;\r\n" -" hb = b / 2;\r\n" -" if(((a - ha * 2) != 0) && ((b - hb * 2) != 0))\r\n" -" {\r\n" -" r += k;\r\n" -" }\r\n" -" a = ha;\r\n" -" b = hb;\r\n" -" }\r\n" -" \r\n" -" return float(r);\r\n" -"}\r\n"; + "float and(int a, int b)\r\n" + "{\r\n" + " int r = 0;\r\n" + " int ha, hb;\r\n" + " \r\n" + " int m = int(min(float(a), float(b)));\r\n" + " \r\n" + " for(int k = 1; k <= m; k *= 2)\r\n" + " {\r\n" + " ha = a / 2;\r\n" + " hb = b / 2;\r\n" + " if(((a - ha * 2) != 0) && ((b - hb * 2) != 0))\r\n" + " {\r\n" + " r += k;\r\n" + " }\r\n" + " a = ha;\r\n" + " b = hb;\r\n" + " }\r\n" + " \r\n" + " return float(r);\r\n" + "}\r\n"; -static const char* s_orFunction = -"float or(int a, int b)\r\n" -"{\r\n" -" int r = 0;\r\n" -" int ha, hb;\r\n" -" \r\n" -" int m = int(max(float(a), float(b)));\r\n" -" \r\n" -" for(int k = 1; k <= m; k *= 2)\r\n" -" {\r\n" -" ha = a / 2;\r\n" -" hb = b / 2;\r\n" -" if(((a - ha * 2) != 0) || ((b - hb * 2) != 0))\r\n" -" {\r\n" -" r += k;\r\n" -" }\r\n" -" a = ha;\r\n" -" b = hb;\r\n" -" }\r\n" -" \r\n" -" return float(r);\r\n" -"}\r\n"; +static const char* s_orFunction = + "float or(int a, int b)\r\n" + "{\r\n" + " int r = 0;\r\n" + " int ha, hb;\r\n" + " \r\n" + " int m = int(max(float(a), float(b)));\r\n" + " \r\n" + " for(int k = 1; k <= m; k *= 2)\r\n" + " {\r\n" + " ha = a / 2;\r\n" + " hb = b / 2;\r\n" + " if(((a - ha * 2) != 0) || ((b - hb * 2) != 0))\r\n" + " {\r\n" + " r += k;\r\n" + " }\r\n" + " a = ha;\r\n" + " b = hb;\r\n" + " }\r\n" + " \r\n" + " return float(r);\r\n" + "}\r\n"; Framework::OpenGl::ProgramPtr CGSH_OpenGL::GenerateShader(const SHADERCAPS& caps) { @@ -245,7 +245,7 @@ Framework::OpenGl::CShader CGSH_OpenGL::GenerateFragmentShader(const SHADERCAPS& { shaderBuilder << " textureColor = expandAlpha(texture(g_texture, texCoord.st));" << std::endl; } - + if(caps.texSourceMode != TEXTURE_SOURCE_MODE_NONE) { if(!caps.texHasAlpha) @@ -327,16 +327,16 @@ std::string CGSH_OpenGL::GenerateTexCoordClampingSection(TEXTURE_CLAMP_MODE clam switch(clampMode) { case TEXTURE_CLAMP_MODE_REGION_CLAMP: - shaderBuilder << " texCoord." << coordinate << " = min(g_clampMax." << coordinate << ", " << - "max(g_clampMin." << coordinate << ", texCoord." << coordinate << "));" << std::endl; + shaderBuilder << " texCoord." << coordinate << " = min(g_clampMax." << coordinate << ", " + << "max(g_clampMin." << coordinate << ", texCoord." << coordinate << "));" << std::endl; break; case TEXTURE_CLAMP_MODE_REGION_REPEAT: - shaderBuilder << " texCoord." << coordinate << " = or(int(and(int(texCoord." << coordinate << "), " << - "int(g_clampMin." << coordinate << "))), int(g_clampMax." << coordinate << "));"; + shaderBuilder << " texCoord." << coordinate << " = or(int(and(int(texCoord." << coordinate << "), " + << "int(g_clampMin." << coordinate << "))), int(g_clampMax." << coordinate << "));"; break; case TEXTURE_CLAMP_MODE_REGION_REPEAT_SIMPLE: - shaderBuilder << " texCoord." << coordinate << " = mod(texCoord." << coordinate << ", " << - "g_clampMin." << coordinate << ") + g_clampMax." << coordinate << ";" << std::endl; + shaderBuilder << " texCoord." << coordinate << " = mod(texCoord." << coordinate << ", " + << "g_clampMin." << coordinate << ") + g_clampMax." << coordinate << ";" << std::endl; break; } @@ -382,10 +382,10 @@ std::string CGSH_OpenGL::GenerateAlphaTestSection(ALPHA_TEST_METHOD testMethod) break; } - shaderBuilder << test << std::endl; - shaderBuilder << "{" << std::endl; - shaderBuilder << " discard;" << std::endl; - shaderBuilder << "}" << std::endl; + shaderBuilder << test << std::endl; + shaderBuilder << "{" << std::endl; + shaderBuilder << " discard;" << std::endl; + shaderBuilder << "}" << std::endl; std::string shaderSource = shaderBuilder.str(); return shaderSource; diff --git a/Source/gs/GSH_OpenGL/GSH_OpenGL_Texture.cpp b/Source/gs/GSH_OpenGL/GSH_OpenGL_Texture.cpp index 6a35dc800..3a28b2740 100644 --- a/Source/gs/GSH_OpenGL/GSH_OpenGL_Texture.cpp +++ b/Source/gs/GSH_OpenGL/GSH_OpenGL_Texture.cpp @@ -20,16 +20,16 @@ void CGSH_OpenGL::SetupTextureUpdaters() m_textureUpdater[i] = &CGSH_OpenGL::TexUpdater_Invalid; } - m_textureUpdater[PSMCT32] = &CGSH_OpenGL::TexUpdater_Psm32; - m_textureUpdater[PSMCT24] = &CGSH_OpenGL::TexUpdater_Psm32; - m_textureUpdater[PSMCT16] = &CGSH_OpenGL::TexUpdater_Psm16; - m_textureUpdater[PSMCT24_UNK] = &CGSH_OpenGL::TexUpdater_Psm32; - m_textureUpdater[PSMCT16S] = &CGSH_OpenGL::TexUpdater_Psm16; - m_textureUpdater[PSMT8] = &CGSH_OpenGL::TexUpdater_Psm48; - m_textureUpdater[PSMT4] = &CGSH_OpenGL::TexUpdater_Psm48; - m_textureUpdater[PSMT8H] = &CGSH_OpenGL::TexUpdater_Psm48H<24, 0xFF>; - m_textureUpdater[PSMT4HL] = &CGSH_OpenGL::TexUpdater_Psm48H<24, 0x0F>; - m_textureUpdater[PSMT4HH] = &CGSH_OpenGL::TexUpdater_Psm48H<28, 0x0F>; + m_textureUpdater[PSMCT32] = &CGSH_OpenGL::TexUpdater_Psm32; + m_textureUpdater[PSMCT24] = &CGSH_OpenGL::TexUpdater_Psm32; + m_textureUpdater[PSMCT16] = &CGSH_OpenGL::TexUpdater_Psm16; + m_textureUpdater[PSMCT24_UNK] = &CGSH_OpenGL::TexUpdater_Psm32; + m_textureUpdater[PSMCT16S] = &CGSH_OpenGL::TexUpdater_Psm16; + m_textureUpdater[PSMT8] = &CGSH_OpenGL::TexUpdater_Psm48; + m_textureUpdater[PSMT4] = &CGSH_OpenGL::TexUpdater_Psm48; + m_textureUpdater[PSMT8H] = &CGSH_OpenGL::TexUpdater_Psm48H<24, 0xFF>; + m_textureUpdater[PSMT4HL] = &CGSH_OpenGL::TexUpdater_Psm48H<24, 0x0F>; + m_textureUpdater[PSMT4HH] = &CGSH_OpenGL::TexUpdater_Psm48H<28, 0x0F>; } uint32 CGSH_OpenGL::GetFramebufferBitDepth(uint32 psm) @@ -56,19 +56,19 @@ CGSH_OpenGL::TEXTUREFORMAT_INFO CGSH_OpenGL::GetTextureFormatInfo(uint32 psm) case PSMCT32: case PSMCT24: case PSMCT24_UNK: - return TEXTUREFORMAT_INFO { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE }; + return TEXTUREFORMAT_INFO{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE}; case PSMCT16: case PSMCT16S: - return TEXTUREFORMAT_INFO { GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 }; + return TEXTUREFORMAT_INFO{GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1}; case PSMT8: case PSMT4: case PSMT8H: case PSMT4HL: case PSMT4HH: - return TEXTUREFORMAT_INFO { GL_R8, GL_RED, GL_UNSIGNED_BYTE }; + return TEXTUREFORMAT_INFO{GL_R8, GL_RED, GL_UNSIGNED_BYTE}; default: assert(false); - return TEXTUREFORMAT_INFO { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE }; + return TEXTUREFORMAT_INFO{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE}; } } @@ -83,16 +83,16 @@ CGSH_OpenGL::TEXTURE_INFO CGSH_OpenGL::PrepareTexture(const TEX0& tex0) //Case: TEX0 points at the start of a frame buffer with the same width if(candidateFramebuffer->m_basePtr == tex0.GetBufPtr() && - candidateFramebuffer->m_width == tex0.GetBufWidth() && - IsCompatibleFramebufferPSM(candidateFramebuffer->m_psm, tex0.nPsm)) + candidateFramebuffer->m_width == tex0.GetBufWidth() && + IsCompatibleFramebufferPSM(candidateFramebuffer->m_psm, tex0.nPsm)) { canBeUsed = true; } //Another case: TEX0 is pointing to the start of a page within our framebuffer (BGDA does this) else if(candidateFramebuffer->m_basePtr <= tex0.GetBufPtr() && - candidateFramebuffer->m_width == tex0.GetBufWidth() && - candidateFramebuffer->m_psm == tex0.nPsm) + candidateFramebuffer->m_width == tex0.GetBufWidth() && + candidateFramebuffer->m_psm == tex0.nPsm) { uint32 framebufferOffset = tex0.GetBufPtr() - candidateFramebuffer->m_basePtr; @@ -122,9 +122,9 @@ CGSH_OpenGL::TEXTURE_INFO CGSH_OpenGL::PrepareTexture(const TEX0& tex0) float scaleRatioY = static_cast(tex0.GetHeight()) / static_cast(candidateFramebuffer->m_height); texInfo.textureHandle = candidateFramebuffer->m_texture; - texInfo.offsetX = offsetX; - texInfo.scaleRatioX = scaleRatioX; - texInfo.scaleRatioY = scaleRatioY; + texInfo.offsetX = offsetX; + texInfo.scaleRatioX = scaleRatioX; + texInfo.scaleRatioY = scaleRatioY; return texInfo; } @@ -273,11 +273,11 @@ void CGSH_OpenGL::TexUpdater_Psm16(uint32 bufPtr, uint32 bufWidth, unsigned int for(unsigned int x = 0; x < texWidth; x++) { auto pixel = indexor.GetPixel(texX + x, texY + y); - auto cvtPixel = - (((pixel & 0x001F) >> 0) << 11) | //R - (((pixel & 0x03E0) >> 5) << 6) | //G - (((pixel & 0x7C00) >> 10) << 1) | //B - (pixel >> 15); //A + auto cvtPixel = + (((pixel & 0x001F) >> 0) << 11) | //R + (((pixel & 0x03E0) >> 5) << 6) | //G + (((pixel & 0x7C00) >> 10) << 1) | //B + (pixel >> 15); //A dst[x] = cvtPixel; } @@ -336,13 +336,12 @@ void CGSH_OpenGL::TexUpdater_Psm48H(uint32 bufPtr, uint32 bufWidth, unsigned int ///////////////////////////////////////////////////////////// CGSH_OpenGL::CPalette::CPalette() -: m_isIDTEX4(false) -, m_cpsm(0) -, m_csa(0) -, m_texture(0) -, m_live(false) + : m_isIDTEX4(false) + , m_cpsm(0) + , m_csa(0) + , m_texture(0) + , m_live(false) { - } CGSH_OpenGL::CPalette::~CPalette() @@ -374,7 +373,7 @@ void CGSH_OpenGL::CPalette::Invalidate(uint32 csa) GLuint CGSH_OpenGL::PalCache_Search(const TEX0& tex0) { for(auto paletteIterator(m_paletteCache.begin()); - paletteIterator != m_paletteCache.end(); paletteIterator++) + paletteIterator != m_paletteCache.end(); paletteIterator++) { auto palette = *paletteIterator; if(!palette->m_live) continue; @@ -392,12 +391,12 @@ GLuint CGSH_OpenGL::PalCache_Search(const TEX0& tex0) GLuint CGSH_OpenGL::PalCache_Search(unsigned int entryCount, const uint32* contents) { for(auto paletteIterator(m_paletteCache.begin()); - paletteIterator != m_paletteCache.end(); paletteIterator++) + paletteIterator != m_paletteCache.end(); paletteIterator++) { auto palette = *paletteIterator; - + if(palette->m_texture == 0) continue; - + unsigned int palEntryCount = palette->m_isIDTEX4 ? 16 : 256; if(palEntryCount != entryCount) continue; @@ -420,11 +419,11 @@ void CGSH_OpenGL::PalCache_Insert(const TEX0& tex0, const uint32* contents, GLui unsigned int entryCount = CGsPixelFormats::IsPsmIDTEX4(tex0.nPsm) ? 16 : 256; - texture->m_isIDTEX4 = CGsPixelFormats::IsPsmIDTEX4(tex0.nPsm); - texture->m_cpsm = tex0.nCPSM; - texture->m_csa = tex0.nCSA; - texture->m_texture = textureHandle; - texture->m_live = true; + texture->m_isIDTEX4 = CGsPixelFormats::IsPsmIDTEX4(tex0.nPsm); + texture->m_cpsm = tex0.nCPSM; + texture->m_csa = tex0.nCSA; + texture->m_texture = textureHandle; + texture->m_live = true; memcpy(texture->m_contents, contents, entryCount * sizeof(uint32)); m_paletteCache.pop_back(); @@ -434,11 +433,11 @@ void CGSH_OpenGL::PalCache_Insert(const TEX0& tex0, const uint32* contents, GLui void CGSH_OpenGL::PalCache_Invalidate(uint32 csa) { std::for_each(std::begin(m_paletteCache), std::end(m_paletteCache), - [csa] (PalettePtr& palette) { palette->Invalidate(csa); }); + [csa](PalettePtr& palette) { palette->Invalidate(csa); }); } void CGSH_OpenGL::PalCache_Flush() { - std::for_each(std::begin(m_paletteCache), std::end(m_paletteCache), - [] (PalettePtr& palette) { palette->Free(); }); + std::for_each(std::begin(m_paletteCache), std::end(m_paletteCache), + [](PalettePtr& palette) { palette->Free(); }); } diff --git a/Source/gs/GSHandler.cpp b/Source/gs/GSHandler.cpp index 77857fc7e..d617029c0 100644 --- a/Source/gs/GSHandler.cpp +++ b/Source/gs/GSHandler.cpp @@ -11,70 +11,70 @@ #include "GsPixelFormats.h" #include "string_format.h" -#define R_REG(a, v, r) \ - if((a) & 0x4) \ - { \ - v = (uint32)(r >> 32); \ - } \ - else \ - { \ - v = (uint32)(r & 0xFFFFFFFF); \ +#define R_REG(a, v, r) \ + if((a)&0x4) \ + { \ + v = (uint32)(r >> 32); \ + } \ + else \ + { \ + v = (uint32)(r & 0xFFFFFFFF); \ } -#define W_REG(a, v, r) \ - if((a) & 0x4) \ - { \ - (r) &= 0x00000000FFFFFFFFULL; \ - (r) |= (uint64)(v) << 32; \ - } \ - else \ - { \ - (r) &= 0xFFFFFFFF00000000ULL; \ - (r) |= (v); \ +#define W_REG(a, v, r) \ + if((a)&0x4) \ + { \ + (r) &= 0x00000000FFFFFFFFULL; \ + (r) |= (uint64)(v) << 32; \ + } \ + else \ + { \ + (r) &= 0xFFFFFFFF00000000ULL; \ + (r) |= (v); \ } -#define STATE_RAM ("gs/ram") -#define STATE_REGS ("gs/regs") -#define STATE_TRXCTX ("gs/trxcontext") -#define STATE_PRIVREGS ("gs/privregs.xml") +#define STATE_RAM ("gs/ram") +#define STATE_REGS ("gs/regs") +#define STATE_TRXCTX ("gs/trxcontext") +#define STATE_PRIVREGS ("gs/privregs.xml") -#define STATE_PRIVREGS_PMODE ("PMODE") -#define STATE_PRIVREGS_SMODE2 ("SMODE2") -#define STATE_PRIVREGS_DISPFB1 ("DISPFB1") -#define STATE_PRIVREGS_DISPLAY1 ("DISPLAY1") -#define STATE_PRIVREGS_DISPFB2 ("DISPFB2") -#define STATE_PRIVREGS_DISPLAY2 ("DISPLAY2") -#define STATE_PRIVREGS_CSR ("CSR") -#define STATE_PRIVREGS_IMR ("IMR") -#define STATE_PRIVREGS_SIGLBLID ("SIGLBLID") -#define STATE_PRIVREGS_CRTMODE ("CrtMode") +#define STATE_PRIVREGS_PMODE ("PMODE") +#define STATE_PRIVREGS_SMODE2 ("SMODE2") +#define STATE_PRIVREGS_DISPFB1 ("DISPFB1") +#define STATE_PRIVREGS_DISPLAY1 ("DISPLAY1") +#define STATE_PRIVREGS_DISPFB2 ("DISPFB2") +#define STATE_PRIVREGS_DISPLAY2 ("DISPLAY2") +#define STATE_PRIVREGS_CSR ("CSR") +#define STATE_PRIVREGS_IMR ("IMR") +#define STATE_PRIVREGS_SIGLBLID ("SIGLBLID") +#define STATE_PRIVREGS_CRTMODE ("CrtMode") -#define LOG_NAME ("gs") +#define LOG_NAME ("gs") struct MASSIVEWRITE_INFO { #ifdef DEBUGGER_INCLUDED - CGsPacketMetadata metadata; + CGsPacketMetadata metadata; #endif - CGSHandler::RegisterWriteList writes; + CGSHandler::RegisterWriteList writes; }; CGSHandler::CGSHandler() -: m_threadDone(false) -, m_drawCallCount(0) -, m_pCLUT(nullptr) -, m_pRAM(nullptr) -, m_frameDump(nullptr) -, m_loggingEnabled(true) + : m_threadDone(false) + , m_drawCallCount(0) + , m_pCLUT(nullptr) + , m_pRAM(nullptr) + , m_frameDump(nullptr) + , m_loggingEnabled(true) { RegisterPreferences(); - + m_presentationParams.mode = static_cast(CAppConfig::GetInstance().GetPreferenceInteger(PREF_CGSHANDLER_PRESENTATION_MODE)); m_presentationParams.windowWidth = 512; m_presentationParams.windowHeight = 384; - + m_pRAM = new uint8[RAMSIZE]; - m_pCLUT = new uint16[CLUTENTRYCOUNT]; + m_pCLUT = new uint16[CLUTENTRYCOUNT]; for(int i = 0; i < PSM_MAX; i++) { @@ -82,30 +82,30 @@ CGSHandler::CGSHandler() m_transferReadHandlers[i] = &CGSHandler::TransferReadHandlerInvalid; } - m_transferWriteHandlers[PSMCT32] = &CGSHandler::TransferWriteHandlerGeneric; - m_transferWriteHandlers[PSMCT24] = &CGSHandler::TransferWriteHandlerPSMCT24; - m_transferWriteHandlers[PSMCT16] = &CGSHandler::TransferWriteHandlerGeneric; + m_transferWriteHandlers[PSMCT32] = &CGSHandler::TransferWriteHandlerGeneric; + m_transferWriteHandlers[PSMCT24] = &CGSHandler::TransferWriteHandlerPSMCT24; + m_transferWriteHandlers[PSMCT16] = &CGSHandler::TransferWriteHandlerGeneric; m_transferWriteHandlers[PSMCT16S] = &CGSHandler::TransferWriteHandlerGeneric; - m_transferWriteHandlers[PSMT8] = &CGSHandler::TransferWriteHandlerGeneric; - m_transferWriteHandlers[PSMT4] = &CGSHandler::TransferWriteHandlerPSMT4; - m_transferWriteHandlers[PSMT8H] = &CGSHandler::TransferWriteHandlerPSMT8H; - m_transferWriteHandlers[PSMT4HL] = &CGSHandler::TransferWriteHandlerPSMT4H<24, 0x0F000000>; - m_transferWriteHandlers[PSMT4HH] = &CGSHandler::TransferWriteHandlerPSMT4H<28, 0xF0000000>; + m_transferWriteHandlers[PSMT8] = &CGSHandler::TransferWriteHandlerGeneric; + m_transferWriteHandlers[PSMT4] = &CGSHandler::TransferWriteHandlerPSMT4; + m_transferWriteHandlers[PSMT8H] = &CGSHandler::TransferWriteHandlerPSMT8H; + m_transferWriteHandlers[PSMT4HL] = &CGSHandler::TransferWriteHandlerPSMT4H<24, 0x0F000000>; + m_transferWriteHandlers[PSMT4HH] = &CGSHandler::TransferWriteHandlerPSMT4H<28, 0xF0000000>; m_transferReadHandlers[PSMCT32] = &CGSHandler::TransferReadHandlerGeneric; - m_transferReadHandlers[PSMT8] = &CGSHandler::TransferReadHandlerGeneric; + m_transferReadHandlers[PSMT8] = &CGSHandler::TransferReadHandlerGeneric; ResetBase(); - m_thread = std::thread([&] () { ThreadProc(); }); + m_thread = std::thread([&]() { ThreadProc(); }); } CGSHandler::~CGSHandler() { m_threadDone = true; m_thread.join(); - delete [] m_pRAM; - delete [] m_pCLUT; + delete[] m_pRAM; + delete[] m_pCLUT; } void CGSHandler::RegisterPreferences() @@ -115,7 +115,7 @@ void CGSHandler::RegisterPreferences() void CGSHandler::NotifyPreferencesChanged() { - m_mailBox.SendCall([this] () { NotifyPreferencesChangedImpl(); }); + m_mailBox.SendCall([this]() { NotifyPreferencesChangedImpl(); }); } void CGSHandler::Reset() @@ -151,12 +151,10 @@ void CGSHandler::ResetBase() void CGSHandler::ResetImpl() { - } void CGSHandler::NotifyPreferencesChangedImpl() { - } void CGSHandler::SetPresentationParams(const PRESENTATION_PARAMS& presentationParams) @@ -166,23 +164,23 @@ void CGSHandler::SetPresentationParams(const PRESENTATION_PARAMS& presentationPa void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive) { - archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_pRAM, RAMSIZE)); - archive.InsertFile(new CMemoryStateFile(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX)); - archive.InsertFile(new CMemoryStateFile(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT))); + archive.InsertFile(new CMemoryStateFile(STATE_RAM, m_pRAM, RAMSIZE)); + archive.InsertFile(new CMemoryStateFile(STATE_REGS, m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX)); + archive.InsertFile(new CMemoryStateFile(STATE_TRXCTX, &m_trxCtx, sizeof(TRXCONTEXT))); { CRegisterStateFile* registerFile = new CRegisterStateFile(STATE_PRIVREGS); - registerFile->SetRegister64(STATE_PRIVREGS_PMODE, m_nPMODE); - registerFile->SetRegister64(STATE_PRIVREGS_SMODE2, m_nSMODE2); - registerFile->SetRegister64(STATE_PRIVREGS_DISPFB1, m_nDISPFB1.value.q); - registerFile->SetRegister64(STATE_PRIVREGS_DISPLAY1, m_nDISPLAY1.value.q); - registerFile->SetRegister64(STATE_PRIVREGS_DISPFB2, m_nDISPFB2.value.q); - registerFile->SetRegister64(STATE_PRIVREGS_DISPLAY2, m_nDISPLAY2.value.q); - registerFile->SetRegister64(STATE_PRIVREGS_CSR, m_nCSR); - registerFile->SetRegister64(STATE_PRIVREGS_IMR, m_nIMR); - registerFile->SetRegister64(STATE_PRIVREGS_SIGLBLID, m_nSIGLBLID); - registerFile->SetRegister32(STATE_PRIVREGS_CRTMODE, m_nCrtMode); + registerFile->SetRegister64(STATE_PRIVREGS_PMODE, m_nPMODE); + registerFile->SetRegister64(STATE_PRIVREGS_SMODE2, m_nSMODE2); + registerFile->SetRegister64(STATE_PRIVREGS_DISPFB1, m_nDISPFB1.value.q); + registerFile->SetRegister64(STATE_PRIVREGS_DISPLAY1, m_nDISPLAY1.value.q); + registerFile->SetRegister64(STATE_PRIVREGS_DISPFB2, m_nDISPFB2.value.q); + registerFile->SetRegister64(STATE_PRIVREGS_DISPLAY2, m_nDISPLAY2.value.q); + registerFile->SetRegister64(STATE_PRIVREGS_CSR, m_nCSR); + registerFile->SetRegister64(STATE_PRIVREGS_IMR, m_nIMR); + registerFile->SetRegister64(STATE_PRIVREGS_SIGLBLID, m_nSIGLBLID); + registerFile->SetRegister32(STATE_PRIVREGS_CRTMODE, m_nCrtMode); archive.InsertFile(registerFile); } @@ -190,22 +188,22 @@ void CGSHandler::SaveState(Framework::CZipArchiveWriter& archive) void CGSHandler::LoadState(Framework::CZipArchiveReader& archive) { - archive.BeginReadFile(STATE_RAM )->Read(m_pRAM, RAMSIZE); - archive.BeginReadFile(STATE_REGS )->Read(m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX); - archive.BeginReadFile(STATE_TRXCTX )->Read(&m_trxCtx, sizeof(TRXCONTEXT)); + archive.BeginReadFile(STATE_RAM)->Read(m_pRAM, RAMSIZE); + archive.BeginReadFile(STATE_REGS)->Read(m_nReg, sizeof(uint64) * CGSHandler::REGISTER_MAX); + archive.BeginReadFile(STATE_TRXCTX)->Read(&m_trxCtx, sizeof(TRXCONTEXT)); { CRegisterStateFile registerFile(*archive.BeginReadFile(STATE_PRIVREGS)); - m_nPMODE = registerFile.GetRegister64(STATE_PRIVREGS_PMODE); - m_nSMODE2 = registerFile.GetRegister64(STATE_PRIVREGS_SMODE2); - m_nDISPFB1.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPFB1); - m_nDISPLAY1.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPLAY1); - m_nDISPFB2.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPFB2); - m_nDISPLAY2.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPLAY2); - m_nCSR = registerFile.GetRegister64(STATE_PRIVREGS_CSR); - m_nIMR = registerFile.GetRegister64(STATE_PRIVREGS_IMR); - m_nSIGLBLID = registerFile.GetRegister64(STATE_PRIVREGS_SIGLBLID); - m_nCrtMode = registerFile.GetRegister32(STATE_PRIVREGS_CRTMODE); + m_nPMODE = registerFile.GetRegister64(STATE_PRIVREGS_PMODE); + m_nSMODE2 = registerFile.GetRegister64(STATE_PRIVREGS_SMODE2); + m_nDISPFB1.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPFB1); + m_nDISPLAY1.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPLAY1); + m_nDISPFB2.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPFB2); + m_nDISPLAY2.value.q = registerFile.GetRegister64(STATE_PRIVREGS_DISPLAY2); + m_nCSR = registerFile.GetRegister64(STATE_PRIVREGS_CSR); + m_nIMR = registerFile.GetRegister64(STATE_PRIVREGS_IMR); + m_nSIGLBLID = registerFile.GetRegister64(STATE_PRIVREGS_SIGLBLID); + m_nCrtMode = registerFile.GetRegister32(STATE_PRIVREGS_CRTMODE); } } @@ -291,7 +289,7 @@ void CGSHandler::WritePrivRegister(uint32 nAddress, uint32 nData) if((m_nPMODE & 0x01) && (m_nPMODE & 0x02)) { CLog::GetInstance().Print(LOG_NAME, "Warning. Both read circuits were enabled. Using RC1 for display.\r\n"); -// m_nPMODE &= ~0x02; + // m_nPMODE &= ~0x02; } } break; @@ -311,29 +309,29 @@ void CGSHandler::WritePrivRegister(uint32 nAddress, uint32 nData) WriteToDelayedRegister(nAddress, nData, m_nDISPLAY2); break; case GS_CSR: + { + if(!(nAddress & 0x04)) { - if(!(nAddress & 0x04)) + std::lock_guard registerMutexLock(m_registerMutex); + if(nData & CSR_SIGNAL_EVENT) { - std::lock_guard registerMutexLock(m_registerMutex); - if(nData & CSR_SIGNAL_EVENT) - { - m_nCSR &= ~CSR_SIGNAL_EVENT; - } - if(nData & CSR_FINISH_EVENT) - { - m_nCSR &= ~CSR_FINISH_EVENT; - } - if(nData & CSR_VSYNC_INT) - { - m_nCSR &= ~CSR_VSYNC_INT; - } - if(nData & CSR_RESET) - { - m_nCSR |= CSR_RESET; - } + m_nCSR &= ~CSR_SIGNAL_EVENT; + } + if(nData & CSR_FINISH_EVENT) + { + m_nCSR &= ~CSR_FINISH_EVENT; + } + if(nData & CSR_VSYNC_INT) + { + m_nCSR &= ~CSR_VSYNC_INT; + } + if(nData & CSR_RESET) + { + m_nCSR |= CSR_RESET; } } - break; + } + break; case GS_IMR: W_REG(nAddress, nData, m_nIMR); break; @@ -418,7 +416,7 @@ void CGSHandler::FeedImageData(const void* data, uint32 length) //Allocate 0x10 more bytes to allow transfer handlers //to read beyond the actual length of the buffer (ie.: PSMCT24) - + uint8* buffer = new uint8[length + 0x10]; memcpy(buffer, data, length); m_mailBox.SendCall(std::bind(&CGSHandler::FeedImageDataImpl, this, buffer, length)); @@ -426,7 +424,7 @@ void CGSHandler::FeedImageData(const void* data, uint32 length) void CGSHandler::ReadImageData(void* data, uint32 length) { - m_mailBox.SendCall([this, data, length] () { ReadImageDataImpl(data, length); }, true); + m_mailBox.SendCall([this, data, length]() { ReadImageDataImpl(data, length); }, true); } void CGSHandler::WriteRegisterMassively(RegisterWriteList registerWrites, const CGsPacketMetadata* metadata) @@ -436,28 +434,28 @@ void CGSHandler::WriteRegisterMassively(RegisterWriteList registerWrites, const switch(write.first) { case GS_REG_SIGNAL: - { - auto signal = make_convertible(write.second); - auto siglblid = make_convertible(m_nSIGLBLID); - siglblid.sigid &= ~signal.idmsk; - siglblid.sigid |= signal.id; - m_nSIGLBLID = siglblid; - assert((m_nCSR & CSR_SIGNAL_EVENT) == 0); - m_nCSR |= CSR_SIGNAL_EVENT; - } - break; + { + auto signal = make_convertible(write.second); + auto siglblid = make_convertible(m_nSIGLBLID); + siglblid.sigid &= ~signal.idmsk; + siglblid.sigid |= signal.id; + m_nSIGLBLID = siglblid; + assert((m_nCSR & CSR_SIGNAL_EVENT) == 0); + m_nCSR |= CSR_SIGNAL_EVENT; + } + break; case GS_REG_FINISH: m_nCSR |= CSR_FINISH_EVENT; break; case GS_REG_LABEL: - { - auto label = make_convertible