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

Core: Have UpdateSyncCPU use its Sync cpu instead of passing a cpu to it

This commit is contained in:
zilmar 2023-12-14 11:18:07 +10:30
parent 236d618c20
commit c67f3f0e97
4 changed files with 134 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
Source/Project64-core/N64System/N64System.cpp
View File

@ -1092,8 +1092,12 @@ void CN64System::CpuStopped()
WriteTrace(TraceN64System, TraceDebug, "Done"); WriteTrace(TraceN64System, TraceDebug, "Done");
} }
void CN64System::UpdateSyncCPU(CN64System * const SecondCPU, uint32_t const Cycles) void CN64System::UpdateSyncCPU(uint32_t const Cycles)
{ {
if (m_SyncCPU == nullptr)
{
return;
}
int CyclesToExecute = Cycles - m_CyclesToSkip; int CyclesToExecute = Cycles - m_CyclesToSkip;
// Update the number of cycles to skip // Update the number of cycles to skip
@ -1109,37 +1113,41 @@ void CN64System::UpdateSyncCPU(CN64System * const SecondCPU, uint32_t const Cycl
return; return;
} }
SecondCPU->SetActiveSystem(true); m_SyncCPU->SetActiveSystem(true);
m_OpCodes.ExecuteOps(Cycles); m_SyncCPU->m_OpCodes.ExecuteOps(Cycles);
SetActiveSystem(true); SetActiveSystem(true);
} }
void CN64System::SyncCPUPC(CN64System * const SecondCPU) void CN64System::SyncSystemPC(void)
{ {
if (m_SyncCPU == nullptr)
{
return;
}
bool ErrorFound = false; bool ErrorFound = false;
g_SystemTimer->UpdateTimers(); g_SystemTimer->UpdateTimers();
if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) if (m_Reg.m_PROGRAM_COUNTER != m_SyncCPU->m_Reg.m_PROGRAM_COUNTER)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_TLB != SecondCPU->m_TLB) if (m_TLB != m_SyncCPU->m_TLB)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_SystemTimer != SecondCPU->m_SystemTimer) if (m_SystemTimer != m_SyncCPU->m_SystemTimer)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_NextTimer != SecondCPU->m_NextTimer) if (m_NextTimer != m_SyncCPU->m_NextTimer)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (ErrorFound) if (ErrorFound)
{ {
DumpSyncErrors(SecondCPU); DumpSyncErrors();
} }
for (int i = (sizeof(m_LastSuccessSyncPC) / sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--) for (int i = (sizeof(m_LastSuccessSyncPC) / sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--)
@ -1149,8 +1157,12 @@ void CN64System::SyncCPUPC(CN64System * const SecondCPU)
m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER; m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER;
} }
void CN64System::SyncCPU(CN64System * const SecondCPU) void CN64System::SyncSystem()
{ {
if (m_SyncCPU == nullptr)
{
return;
}
bool ErrorFound = false; bool ErrorFound = false;
m_SyncCount += 1; m_SyncCount += 1;
@ -1162,7 +1174,7 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
ErrorFound = true; ErrorFound = true;
} }
#endif #endif
if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) if (m_Reg.m_PROGRAM_COUNTER != m_SyncCPU->m_Reg.m_PROGRAM_COUNTER)
{ {
ErrorFound = true; ErrorFound = true;
} }
@ -1170,15 +1182,15 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
{ {
for (int count = 0; count < 32; count++) for (int count = 0; count < 32; count++)
{ {
if (m_Reg.m_GPR[count].W[0] != SecondCPU->m_Reg.m_GPR[count].W[0]) if (m_Reg.m_GPR[count].W[0] != m_SyncCPU->m_Reg.m_GPR[count].W[0])
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW) if (m_Reg.m_FPR[count].DW != m_SyncCPU->m_Reg.m_FPR[count].DW)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count]) if (m_Reg.m_CP0[count] != m_SyncCPU->m_Reg.m_CP0[count])
{ {
ErrorFound = true; ErrorFound = true;
} }
@ -1188,64 +1200,64 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
{ {
for (int count = 0; count < 32; count++) for (int count = 0; count < 32; count++)
{ {
if (m_Reg.m_GPR[count].DW != SecondCPU->m_Reg.m_GPR[count].DW) if (m_Reg.m_GPR[count].DW != m_SyncCPU->m_Reg.m_GPR[count].DW)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW) if (m_Reg.m_FPR[count].DW != m_SyncCPU->m_Reg.m_FPR[count].DW)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count]) if (m_Reg.m_CP0[count] != m_SyncCPU->m_Reg.m_CP0[count])
{ {
ErrorFound = true; ErrorFound = true;
} }
} }
} }
if (m_Random.get_state() != SecondCPU->m_Random.get_state()) if (m_Random.get_state() != m_SyncCPU->m_Random.get_state())
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_TLB != SecondCPU->m_TLB) if (m_TLB != m_SyncCPU->m_TLB)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_FPCR[0] != SecondCPU->m_Reg.m_FPCR[0]) if (m_Reg.m_FPCR[0] != m_SyncCPU->m_Reg.m_FPCR[0])
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_FPCR[31] != SecondCPU->m_Reg.m_FPCR[31]) if (m_Reg.m_FPCR[31] != m_SyncCPU->m_Reg.m_FPCR[31])
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) if (m_Reg.m_HI.DW != m_SyncCPU->m_Reg.m_HI.DW)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW) if (m_Reg.m_LO.DW != m_SyncCPU->m_Reg.m_LO.DW)
{ {
ErrorFound = true; ErrorFound = true;
} }
/*if (m_SyncCount > 4788000) /*if (m_SyncCount > 4788000)
{ {
if (memcmp(m_MMU_VM.Rdram(),SecondCPU->m_MMU_VM.Rdram(),RdramSize()) != 0) if (memcmp(m_MMU_VM.Rdram(),m_SyncCPU->m_MMU_VM.Rdram(),RdramSize()) != 0)
{ {
ErrorFound = true; ErrorFound = true;
} }
} }
if (memcmp(m_MMU_VM.Imem(),SecondCPU->m_MMU_VM.Imem(),0x1000) != 0) if (memcmp(m_MMU_VM.Imem(),m_SyncCPU->m_MMU_VM.Imem(),0x1000) != 0)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (memcmp(m_MMU_VM.Dmem(),SecondCPU->m_MMU_VM.Dmem(),0x1000) != 0) if (memcmp(m_MMU_VM.Dmem(),m_SyncCPU->m_MMU_VM.Dmem(),0x1000) != 0)
{ {
ErrorFound = true; ErrorFound = true;
}*/ }*/
/*for (int z = 0; z < 0x100; z++) /*for (int z = 0; z < 0x100; z++)
{ {
if (m_MMU_VM.Rdram()[0x00206970 + z] != SecondCPU->m_MMU_VM.Rdram()[0x00206970 + z]) if (m_MMU_VM.Rdram()[0x00206970 + z] != m_SyncCPU->m_MMU_VM.Rdram()[0x00206970 + z])
{ {
ErrorFound = true; ErrorFound = true;
break; break;
@ -1275,22 +1287,22 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
} }
} }
if (m_SystemTimer != SecondCPU->m_SystemTimer) if (m_SystemTimer != m_SyncCPU->m_SystemTimer)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_NextTimer != SecondCPU->m_NextTimer) if (m_NextTimer != m_SyncCPU->m_NextTimer)
{ {
ErrorFound = true; ErrorFound = true;
} }
if (m_PipelineStage != SecondCPU->m_PipelineStage) if (m_PipelineStage != m_SyncCPU->m_PipelineStage)
{ {
ErrorFound = true; ErrorFound = true;
} }
for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i++)
{ {
if (m_Reg.m_Mips_Interface[i] != SecondCPU->m_Reg.m_Mips_Interface[i]) if (m_Reg.m_Mips_Interface[i] != m_SyncCPU->m_Reg.m_Mips_Interface[i])
{ {
ErrorFound = true; ErrorFound = true;
} }
@ -1298,7 +1310,7 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i++)
{ {
if (m_Reg.m_SigProcessor_Interface[i] != SecondCPU->m_Reg.m_SigProcessor_Interface[i]) if (m_Reg.m_SigProcessor_Interface[i] != m_SyncCPU->m_Reg.m_SigProcessor_Interface[i])
{ {
ErrorFound = true; ErrorFound = true;
} }
@ -1306,7 +1318,7 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i++)
{ {
if (m_Reg.m_Display_ControlReg[i] != SecondCPU->m_Reg.m_Display_ControlReg[i]) if (m_Reg.m_Display_ControlReg[i] != m_SyncCPU->m_Reg.m_Display_ControlReg[i])
{ {
ErrorFound = true; ErrorFound = true;
} }
@ -1314,7 +1326,7 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
if (ErrorFound) if (ErrorFound)
{ {
DumpSyncErrors(SecondCPU); DumpSyncErrors();
} }
for (int i = (sizeof(m_LastSuccessSyncPC) / sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--) for (int i = (sizeof(m_LastSuccessSyncPC) / sizeof(m_LastSuccessSyncPC[0])) - 1; i > 0; i--)
@ -1324,17 +1336,7 @@ void CN64System::SyncCPU(CN64System * const SecondCPU)
m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER; m_LastSuccessSyncPC[0] = m_Reg.m_PROGRAM_COUNTER;
} }
void CN64System::SyncSystem() void CN64System::DumpSyncErrors()
{
SyncCPU(g_SyncSystem);
}
void CN64System::SyncSystemPC()
{
SyncCPUPC(g_SyncSystem);
}
void CN64System::DumpSyncErrors(CN64System * SecondCPU)
{ {
int count; int count;
@ -1351,19 +1353,19 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
Error.Log("m_CurrentSP,%X,%X\r\n", m_CurrentSP, GPR[29].UW[0]); Error.Log("m_CurrentSP,%X,%X\r\n", m_CurrentSP, GPR[29].UW[0]);
} }
#endif #endif
if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) if (m_Reg.m_PROGRAM_COUNTER != m_SyncCPU->m_Reg.m_PROGRAM_COUNTER)
{ {
Error.LogF("PROGRAM_COUNTER 0x%X, 0x%X\r\n", m_Reg.m_PROGRAM_COUNTER, SecondCPU->m_Reg.m_PROGRAM_COUNTER); Error.LogF("PROGRAM_COUNTER 0x%X, 0x%X\r\n", m_Reg.m_PROGRAM_COUNTER, m_SyncCPU->m_Reg.m_PROGRAM_COUNTER);
} }
if (b32BitCore()) if (b32BitCore())
{ {
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
if (m_Reg.m_GPR[count].UW[0] != SecondCPU->m_Reg.m_GPR[count].UW[0]) if (m_Reg.m_GPR[count].UW[0] != m_SyncCPU->m_Reg.m_GPR[count].UW[0])
{ {
Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count], Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count],
m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0], m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0],
SecondCPU->m_Reg.m_GPR[count].W[1], SecondCPU->m_Reg.m_GPR[count].W[0]); m_SyncCPU->m_Reg.m_GPR[count].W[1], m_SyncCPU->m_Reg.m_GPR[count].W[0]);
} }
} }
} }
@ -1371,80 +1373,80 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
{ {
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
if (m_Reg.m_GPR[count].DW != SecondCPU->m_Reg.m_GPR[count].DW) if (m_Reg.m_GPR[count].DW != m_SyncCPU->m_Reg.m_GPR[count].DW)
{ {
Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count], Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count],
m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0], m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0],
SecondCPU->m_Reg.m_GPR[count].W[1], SecondCPU->m_Reg.m_GPR[count].W[0]); m_SyncCPU->m_Reg.m_GPR[count].W[1], m_SyncCPU->m_Reg.m_GPR[count].W[0]);
} }
} }
} }
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW) if (m_Reg.m_FPR[count].DW != m_SyncCPU->m_Reg.m_FPR[count].DW)
{ {
Error.LogF("FPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::FPR[count], Error.LogF("FPR[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::FPR[count],
m_Reg.m_FPR[count].W[1], m_Reg.m_FPR[count].W[0], m_Reg.m_FPR[count].W[1], m_Reg.m_FPR[count].W[0],
SecondCPU->m_Reg.m_FPR[count].W[1], SecondCPU->m_Reg.m_FPR[count].W[0]); m_SyncCPU->m_Reg.m_FPR[count].W[1], m_SyncCPU->m_Reg.m_FPR[count].W[0]);
} }
} }
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
if (m_Reg.m_FPCR[count] != SecondCPU->m_Reg.m_FPCR[count]) if (m_Reg.m_FPCR[count] != m_SyncCPU->m_Reg.m_FPCR[count])
{ {
Error.LogF("FPCR[%s] 0x%08X, 0x%08X\r\n", CRegName::FPR_Ctrl[count], Error.LogF("FPCR[%s] 0x%08X, 0x%08X\r\n", CRegName::FPR_Ctrl[count],
m_Reg.m_FPCR[count], SecondCPU->m_Reg.m_FPCR[count]); m_Reg.m_FPCR[count], m_SyncCPU->m_Reg.m_FPCR[count]);
} }
} }
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count]) if (m_Reg.m_CP0[count] != m_SyncCPU->m_Reg.m_CP0[count])
{ {
Error.LogF("CP0[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::Cop0[count], Error.LogF("CP0[%s] 0x%08X%08X, 0x%08X%08X\r\n", CRegName::Cop0[count],
(uint32_t)(m_Reg.m_CP0[count] >> 32), (uint32_t)m_Reg.m_CP0[count], (uint32_t)(SecondCPU->m_Reg.m_CP0[count] >> 32), (uint32_t)(SecondCPU->m_Reg.m_CP0[count])); (uint32_t)(m_Reg.m_CP0[count] >> 32), (uint32_t)m_Reg.m_CP0[count], (uint32_t)(m_SyncCPU->m_Reg.m_CP0[count] >> 32), (uint32_t)(m_SyncCPU->m_Reg.m_CP0[count]));
} }
} }
if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) if (m_Reg.m_HI.DW != m_SyncCPU->m_Reg.m_HI.DW)
{ {
Error.LogF("HI Reg 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_HI.UW[1], m_Reg.m_HI.UW[0], SecondCPU->m_Reg.m_HI.UW[1], SecondCPU->m_Reg.m_HI.UW[0]); Error.LogF("HI Reg 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_HI.UW[1], m_Reg.m_HI.UW[0], m_SyncCPU->m_Reg.m_HI.UW[1], m_SyncCPU->m_Reg.m_HI.UW[0]);
} }
if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW) if (m_Reg.m_LO.DW != m_SyncCPU->m_Reg.m_LO.DW)
{ {
Error.LogF("LO Reg 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_LO.UW[1], m_Reg.m_LO.UW[0], SecondCPU->m_Reg.m_LO.UW[1], SecondCPU->m_Reg.m_LO.UW[0]); Error.LogF("LO Reg 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_LO.UW[1], m_Reg.m_LO.UW[0], m_SyncCPU->m_Reg.m_LO.UW[1], m_SyncCPU->m_Reg.m_LO.UW[0]);
} }
for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_Mips_Interface) / sizeof(m_Reg.m_Mips_Interface[0]); i < n; i++)
{ {
if (m_Reg.m_Mips_Interface[i] != SecondCPU->m_Reg.m_Mips_Interface[i]) if (m_Reg.m_Mips_Interface[i] != m_SyncCPU->m_Reg.m_Mips_Interface[i])
{ {
Error.LogF("Mips_Interface[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_Mips_Interface[i], SecondCPU->m_Reg.m_Mips_Interface[i]); Error.LogF("Mips_Interface[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_Mips_Interface[i], m_SyncCPU->m_Reg.m_Mips_Interface[i]);
} }
} }
for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_SigProcessor_Interface) / sizeof(m_Reg.m_SigProcessor_Interface[0]); i < n; i++)
{ {
if (m_Reg.m_SigProcessor_Interface[i] != SecondCPU->m_Reg.m_SigProcessor_Interface[i]) if (m_Reg.m_SigProcessor_Interface[i] != m_SyncCPU->m_Reg.m_SigProcessor_Interface[i])
{ {
Error.LogF("SigProcessor_Interface[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_SigProcessor_Interface[i], SecondCPU->m_Reg.m_SigProcessor_Interface[i]); Error.LogF("SigProcessor_Interface[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_SigProcessor_Interface[i], m_SyncCPU->m_Reg.m_SigProcessor_Interface[i]);
} }
} }
for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i++) for (int i = 0, n = sizeof(m_Reg.m_Display_ControlReg) / sizeof(m_Reg.m_Display_ControlReg[0]); i < n; i++)
{ {
if (m_Reg.m_Display_ControlReg[i] != SecondCPU->m_Reg.m_Display_ControlReg[i]) if (m_Reg.m_Display_ControlReg[i] != m_SyncCPU->m_Reg.m_Display_ControlReg[i])
{ {
Error.LogF("Display_ControlReg[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_Display_ControlReg[i], SecondCPU->m_Reg.m_Display_ControlReg[i]); Error.LogF("Display_ControlReg[%d] 0x%08X, 0x%08X\r\n", i, m_Reg.m_Display_ControlReg[i], m_SyncCPU->m_Reg.m_Display_ControlReg[i]);
} }
} }
if (m_NextTimer != SecondCPU->m_NextTimer) if (m_NextTimer != m_SyncCPU->m_NextTimer)
{ {
Error.LogF("Current Time: %X %X\r\n", (uint32_t)m_NextTimer, (uint32_t)SecondCPU->m_NextTimer); Error.LogF("Current Time: %X %X\r\n", (uint32_t)m_NextTimer, (uint32_t)m_SyncCPU->m_NextTimer);
} }
if (m_PipelineStage != SecondCPU->m_PipelineStage) if (m_PipelineStage != m_SyncCPU->m_PipelineStage)
{ {
Error.LogF("Pipeline Stage: %X %X\r\n", (uint32_t)m_PipelineStage, (uint32_t)SecondCPU->m_PipelineStage); Error.LogF("Pipeline Stage: %X %X\r\n", (uint32_t)m_PipelineStage, (uint32_t)m_SyncCPU->m_PipelineStage);
} }
m_TLB.RecordDifference(Error, SecondCPU->m_TLB); m_TLB.RecordDifference(Error, m_SyncCPU->m_TLB);
m_SystemTimer.RecordDifference(Error, SecondCPU->m_SystemTimer); m_SystemTimer.RecordDifference(Error, m_SyncCPU->m_SystemTimer);
if (bFastSP() && m_Recomp) if (bFastSP() && m_Recomp)
{ {
uint32_t StackPointer = (m_Reg.m_GPR[29].W[0] & 0x1FFFFFFF); uint32_t StackPointer = (m_Reg.m_GPR[29].W[0] & 0x1FFFFFFF);
@ -1468,7 +1470,7 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
} }
} }
uint32_t *Rdram = (uint32_t *)m_MMU_VM.Rdram(), *Rdram2 = (uint32_t *)SecondCPU->m_MMU_VM.Rdram(); uint32_t *Rdram = (uint32_t *)m_MMU_VM.Rdram(), *Rdram2 = (uint32_t *)m_SyncCPU->m_MMU_VM.Rdram();
for (int z = 0, n = (RdramSize() >> 2); z < n; z++) for (int z = 0, n = (RdramSize() >> 2); z < n; z++)
{ {
if (Rdram[z] != Rdram2[z]) if (Rdram[z] != Rdram2[z])
@ -1477,7 +1479,7 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
} }
} }
uint32_t *Imem = (uint32_t *)m_MMU_VM.Imem(), *Imem2 = (uint32_t *)SecondCPU->m_MMU_VM.Imem(); uint32_t *Imem = (uint32_t *)m_MMU_VM.Imem(), *Imem2 = (uint32_t *)m_SyncCPU->m_MMU_VM.Imem();
for (int z = 0; z < (0x1000 >> 2); z++) for (int z = 0; z < (0x1000 >> 2); z++)
{ {
if (Imem[z] != Imem2[z]) if (Imem[z] != Imem2[z])
@ -1485,7 +1487,7 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
Error.LogF("IMEM[%X]: %X %X\r\n", z << 2, Imem[z], Imem2[z]); Error.LogF("IMEM[%X]: %X %X\r\n", z << 2, Imem[z], Imem2[z]);
} }
} }
uint32_t *Dmem = (uint32_t *)m_MMU_VM.Dmem(), *Dmem2 = (uint32_t *)SecondCPU->m_MMU_VM.Dmem(); uint32_t *Dmem = (uint32_t *)m_MMU_VM.Dmem(), *Dmem2 = (uint32_t *)m_SyncCPU->m_MMU_VM.Dmem();
for (int z = 0; z < (0x1000 >> 2); z++) for (int z = 0; z < (0x1000 >> 2); z++)
{ {
if (Dmem[z] != Dmem2[z]) if (Dmem[z] != Dmem2[z])
@ -1509,49 +1511,49 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
{ {
Error.LogF("GPR[%s], 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count], Error.LogF("GPR[%s], 0x%08X%08X, 0x%08X%08X\r\n", CRegName::GPR[count],
m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0], m_Reg.m_GPR[count].W[1], m_Reg.m_GPR[count].W[0],
SecondCPU->m_Reg.m_GPR[count].W[1], SecondCPU->m_Reg.m_GPR[count].W[0]); m_SyncCPU->m_Reg.m_GPR[count].W[1], m_SyncCPU->m_Reg.m_GPR[count].W[0]);
} }
Error.Log("\r\n"); Error.Log("\r\n");
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
Error.LogF("FPR[%s],%*s0x%08X%08X, 0x%08X%08X\r\n", CRegName::FPR[count], Error.LogF("FPR[%s],%*s0x%08X%08X, 0x%08X%08X\r\n", CRegName::FPR[count],
count < 10 ? 9 : 8, " ", m_Reg.m_FPR[count].W[1], m_Reg.m_FPR[count].W[0], count < 10 ? 9 : 8, " ", m_Reg.m_FPR[count].W[1], m_Reg.m_FPR[count].W[0],
SecondCPU->m_Reg.m_FPR[count].W[1], SecondCPU->m_Reg.m_FPR[count].W[0]); m_SyncCPU->m_Reg.m_FPR[count].W[1], m_SyncCPU->m_Reg.m_FPR[count].W[0]);
} }
Error.Log("\r\n"); Error.Log("\r\n");
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
Error.LogF("FPR_S[%s],%*s%f, %f\r\n", CRegName::FPR[count], Error.LogF("FPR_S[%s],%*s%f, %f\r\n", CRegName::FPR[count],
count < 10 ? 7 : 6, " ", *(m_Reg.m_FPR_S[count]), *(SecondCPU->m_Reg.m_FPR_S[count])); count < 10 ? 7 : 6, " ", *(m_Reg.m_FPR_S[count]), *(m_SyncCPU->m_Reg.m_FPR_S[count]));
} }
Error.Log("\r\n"); Error.Log("\r\n");
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
Error.LogF("FPR_D[%s],%*s%f, %f\r\n", CRegName::FPR[count], Error.LogF("FPR_D[%s],%*s%f, %f\r\n", CRegName::FPR[count],
count < 10 ? 7 : 6, " ", *(m_Reg.m_FPR_D[count]), *(SecondCPU->m_Reg.m_FPR_D[count])); count < 10 ? 7 : 6, " ", *(m_Reg.m_FPR_D[count]), *(m_SyncCPU->m_Reg.m_FPR_D[count]));
} }
Error.Log("\r\n"); Error.Log("\r\n");
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
Error.LogF("CP0[%s] %*s0x%08X%08X, 0x%08X%08X\r\n", CRegName::Cop0[count], 12 - strlen(CRegName::Cop0[count]), "", Error.LogF("CP0[%s] %*s0x%08X%08X, 0x%08X%08X\r\n", CRegName::Cop0[count], 12 - strlen(CRegName::Cop0[count]), "",
(uint32_t)(m_Reg.m_CP0[count] >> 32), (uint32_t)m_Reg.m_CP0[count], (uint32_t)(SecondCPU->m_Reg.m_CP0[count] >> 32), (uint32_t)(SecondCPU->m_Reg.m_CP0[count])); (uint32_t)(m_Reg.m_CP0[count] >> 32), (uint32_t)m_Reg.m_CP0[count], (uint32_t)(m_SyncCPU->m_Reg.m_CP0[count] >> 32), (uint32_t)(m_SyncCPU->m_Reg.m_CP0[count]));
} }
Error.Log("\r\n"); Error.Log("\r\n");
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
{ {
Error.LogF("FPR_Ctrl[%s],%*s0x%08X, 0x%08X\r\n", CRegName::FPR_Ctrl[count], Error.LogF("FPR_Ctrl[%s],%*s0x%08X, 0x%08X\r\n", CRegName::FPR_Ctrl[count],
12 - strlen(CRegName::FPR_Ctrl[count]), "", 12 - strlen(CRegName::FPR_Ctrl[count]), "",
m_Reg.m_FPCR[count], SecondCPU->m_Reg.m_FPCR[count]); m_Reg.m_FPCR[count], m_SyncCPU->m_Reg.m_FPCR[count]);
} }
Error.Log("\r\n"); Error.Log("\r\n");
Error.LogF("HI 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_HI.UW[1], m_Reg.m_HI.UW[0], Error.LogF("HI 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_HI.UW[1], m_Reg.m_HI.UW[0],
SecondCPU->m_Reg.m_HI.UW[1], SecondCPU->m_Reg.m_HI.UW[0]); m_SyncCPU->m_Reg.m_HI.UW[1], m_SyncCPU->m_Reg.m_HI.UW[0]);
Error.LogF("LO 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_LO.UW[1], m_Reg.m_LO.UW[0], Error.LogF("LO 0x%08X%08X, 0x%08X%08X\r\n", m_Reg.m_LO.UW[1], m_Reg.m_LO.UW[0],
SecondCPU->m_Reg.m_LO.UW[1], SecondCPU->m_Reg.m_LO.UW[0]); m_SyncCPU->m_Reg.m_LO.UW[1], m_SyncCPU->m_Reg.m_LO.UW[0]);
Error.LogF("CP0[%s],%*s0x%08X, 0x%08X\r\n", CRegName::Cop0[count], Error.LogF("CP0[%s],%*s0x%08X, 0x%08X\r\n", CRegName::Cop0[count],
12 - strlen(CRegName::Cop0[count]), "", 12 - strlen(CRegName::Cop0[count]), "",
m_Reg.m_CP0[count], SecondCPU->m_Reg.m_CP0[count]); m_Reg.m_CP0[count], m_SyncCPU->m_Reg.m_CP0[count]);
bool bHasTlb = false; bool bHasTlb = false;
for (count = 0; count < 32; count++) for (count = 0; count < 32; count++)
@ -1568,7 +1570,7 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
} }
Error.LogF("TLB[%2d], %08X, %08X, %08X, %08X\r\n", count, Error.LogF("TLB[%2d], %08X, %08X, %08X, %08X\r\n", count,
m_TLB.TlbEntry(count).EntryHi.Value, m_TLB.TlbEntry(count).PageMask.Value, m_TLB.TlbEntry(count).EntryHi.Value, m_TLB.TlbEntry(count).PageMask.Value,
SecondCPU->m_TLB.TlbEntry(count).EntryHi.Value, SecondCPU->m_TLB.TlbEntry(count).PageMask.Value); m_SyncCPU->m_TLB.TlbEntry(count).EntryHi.Value, m_SyncCPU->m_TLB.TlbEntry(count).PageMask.Value);
} }
Error.Log("\r\n"); Error.Log("\r\n");
Error.Log("Code at PC:\r\n"); Error.Log("Code at PC:\r\n");
@ -2242,7 +2244,7 @@ bool CN64System::LoadState(const char * FileName)
m_SyncCPU->SetActiveSystem(true); m_SyncCPU->SetActiveSystem(true);
m_SyncCPU->LoadState(FileName); m_SyncCPU->LoadState(FileName);
SetActiveSystem(true); SetActiveSystem(true);
SyncCPU(m_SyncCPU); SyncSystem();
} }
} }
NotifyCallback(CN64SystemCB_LoadedGameState); NotifyCallback(CN64SystemCB_LoadedGameState);

6
Source/Project64-core/N64System/N64System.h
View File

@ -104,9 +104,7 @@ public:
uint32_t m_CurrentSP; uint32_t m_CurrentSP;
#endif #endif
// For sync CPU // For sync CPU
void UpdateSyncCPU(CN64System * const SecondCPU, uint32_t const Cycles); void UpdateSyncCPU(uint32_t const Cycles);
void SyncCPU(CN64System * const SecondCPU);
void SyncCPUPC(CN64System * const SecondCPU);
void SyncSystem(); void SyncSystem();
void SyncSystemPC(); void SyncSystemPC();
@ -158,7 +156,7 @@ private:
void ExecuteCPU(); void ExecuteCPU();
void RefreshScreen(); void RefreshScreen();
void DumpSyncErrors(CN64System * SecondCPU); void DumpSyncErrors();
void StartEmulation2(bool NewThread); void StartEmulation2(bool NewThread);
bool SetActiveSystem(bool bActive = true); bool SetActiveSystem(bool bActive = true);
void NotifyCallback(CN64SystemCB Type); void NotifyCallback(CN64SystemCB Type);

68
Source/Project64-core/N64System/Recompiler/Recompiler.cpp
View File

@ -43,9 +43,9 @@ void CRecompiler::Run()
__except_try() __except_try()
{ {
if (g_System->LookUpMode() == FuncFind_VirtualLookup) if (m_System.LookUpMode() == FuncFind_VirtualLookup)
{ {
if (g_System->bSMM_ValidFunc()) if (m_System.bSMM_ValidFunc())
{ {
RecompilerMain_VirtualTable_validate(); RecompilerMain_VirtualTable_validate();
} }
@ -54,13 +54,13 @@ void CRecompiler::Run()
RecompilerMain_VirtualTable(); RecompilerMain_VirtualTable();
} }
} }
else if (g_System->LookUpMode() == FuncFind_ChangeMemory) else if (m_System.LookUpMode() == FuncFind_ChangeMemory)
{ {
RecompilerMain_ChangeMemory(); RecompilerMain_ChangeMemory();
} }
else else
{ {
if (g_System->bSMM_ValidFunc()) if (m_System.bSMM_ValidFunc())
{ {
RecompilerMain_Lookup_validate(); RecompilerMain_Lookup_validate();
} }
@ -88,8 +88,8 @@ void CRecompiler::RecompilerMain_VirtualTable()
if (!m_MMU.ValidVaddr(PC)) if (!m_MMU.ValidVaddr(PC))
{ {
m_Reg.TriggerAddressException(PC, EXC_RMISS); m_Reg.TriggerAddressException(PC, EXC_RMISS);
PC = g_System->m_JumpToLocation; PC = m_System.m_JumpToLocation;
g_System->m_PipelineStage = PIPELINE_STAGE_NORMAL; m_System.m_PipelineStage = PIPELINE_STAGE_NORMAL;
if (!m_MMU.ValidVaddr(PC)) if (!m_MMU.ValidVaddr(PC))
{ {
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).c_str());
@ -124,7 +124,7 @@ void CRecompiler::RecompilerMain_VirtualTable()
g_Notify->FatalError(MSG_MEM_ALLOC_ERROR); g_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
} }
memset(table, 0, sizeof(PCCompiledFunc) * (0x1000 >> 2)); memset(table, 0, sizeof(PCCompiledFunc) * (0x1000 >> 2));
if (g_System->bSMM_Protect()) if (m_System.bSMM_Protect())
{ {
WriteTrace(TraceRecompiler, TraceError, "Create Table (%X): Index = %d", table, PC >> 0xC); WriteTrace(TraceRecompiler, TraceError, "Create Table (%X): Index = %d", table, PC >> 0xC);
m_MMU.ProtectMemory(PC & ~0xFFF, PC | 0xFFF); m_MMU.ProtectMemory(PC & ~0xFFF, PC | 0xFFF);
@ -155,11 +155,11 @@ void CRecompiler::RecompilerMain_Lookup()
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).c_str());
m_EndEmulation = true; m_EndEmulation = true;
} }
PROGRAM_COUNTER = g_System->m_JumpToLocation; PROGRAM_COUNTER = m_System.m_JumpToLocation;
g_System->m_PipelineStage = PIPELINE_STAGE_NORMAL; m_System.m_PipelineStage = PIPELINE_STAGE_NORMAL;
continue; continue;
} }
if (PhysicalAddr < g_System->RdramSize()) if (PhysicalAddr < m_System.RdramSize())
{ {
CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2]; CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2];
@ -170,7 +170,7 @@ void CRecompiler::RecompilerMain_Lookup()
{ {
break; break;
} }
if (g_System->bSMM_Protect()) if (m_System.bSMM_Protect())
{ {
m_MMU.ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF); m_MMU.ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF);
} }
@ -182,16 +182,16 @@ void CRecompiler::RecompilerMain_Lookup()
{ {
uint32_t opsExecuted = 0; uint32_t opsExecuted = 0;
while (m_MMU.VAddrToPAddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize()) while (m_MMU.VAddrToPAddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= m_System.RdramSize())
{ {
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); m_System.m_OpCodes.ExecuteOps(m_System.CountPerOp());
opsExecuted += g_System->CountPerOp(); opsExecuted += m_System.CountPerOp();
} }
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted); m_System.UpdateSyncCPU(opsExecuted);
g_System->SyncCPU(g_SyncSystem); m_System.SyncSystem();
} }
} }
} }
@ -214,11 +214,11 @@ void CRecompiler::RecompilerMain_Lookup_validate()
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).c_str());
Done = true; Done = true;
} }
PROGRAM_COUNTER = g_System->m_JumpToLocation; PROGRAM_COUNTER = m_System.m_JumpToLocation;
g_System->m_PipelineStage = PIPELINE_STAGE_NORMAL; m_System.m_PipelineStage = PIPELINE_STAGE_NORMAL;
continue; continue;
} }
if (PhysicalAddr < g_System->RdramSize()) if (PhysicalAddr < m_System.RdramSize())
{ {
CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2]; CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2];
@ -229,7 +229,7 @@ void CRecompiler::RecompilerMain_Lookup_validate()
{ {
break; break;
} }
if (g_System->bSMM_Protect()) if (m_System.bSMM_Protect())
{ {
m_MMU.ProtectMemory(PC & ~0xFFF, PC | 0xFFF); m_MMU.ProtectMemory(PC & ~0xFFF, PC | 0xFFF);
} }
@ -260,12 +260,12 @@ void CRecompiler::RecompilerMain_Lookup_validate()
if (bRecordExecutionTimes()) if (bRecordExecutionTimes())
{ {
uint64_t PreNonCPUTime = g_System->m_CPU_Usage.NonCPUTime(); uint64_t PreNonCPUTime = m_System.m_CPU_Usage.NonCPUTime();
HighResTimeStamp StartTime, EndTime; HighResTimeStamp StartTime, EndTime;
StartTime.SetToNow(); StartTime.SetToNow();
(info->Function())(); (info->Function())();
EndTime.SetToNow(); EndTime.SetToNow();
uint64_t PostNonCPUTime = g_System->m_CPU_Usage.NonCPUTime(); uint64_t PostNonCPUTime = m_System.m_CPU_Usage.NonCPUTime();
uint64_t TimeTaken = EndTime.GetMicroSeconds() - StartTime.GetMicroSeconds(); uint64_t TimeTaken = EndTime.GetMicroSeconds() - StartTime.GetMicroSeconds();
if (PostNonCPUTime >= PreNonCPUTime) if (PostNonCPUTime >= PreNonCPUTime)
{ {
@ -295,16 +295,16 @@ void CRecompiler::RecompilerMain_Lookup_validate()
{ {
uint32_t opsExecuted = 0; uint32_t opsExecuted = 0;
while (m_MMU.VAddrToPAddr(PC, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize()) while (m_MMU.VAddrToPAddr(PC, PhysicalAddr) && PhysicalAddr >= m_System.RdramSize())
{ {
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); m_System.m_OpCodes.ExecuteOps(m_System.CountPerOp());
opsExecuted += g_System->CountPerOp(); opsExecuted += m_System.CountPerOp();
} }
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted); m_System.UpdateSyncCPU(opsExecuted);
g_System->SyncCPU(g_SyncSystem); m_System.SyncSystem();
} }
} }
} }
@ -441,7 +441,7 @@ CCompiledFunc * CRecompiler::CompileCode()
void CRecompiler::ClearRecompCode_Phys(uint32_t Address, int length, REMOVE_REASON Reason) void CRecompiler::ClearRecompCode_Phys(uint32_t Address, int length, REMOVE_REASON Reason)
{ {
if (g_System->LookUpMode() == FuncFind_VirtualLookup) if (m_System.LookUpMode() == FuncFind_VirtualLookup)
{ {
ClearRecompCode_Virt(Address + 0x80000000, length, Reason); ClearRecompCode_Virt(Address + 0x80000000, length, Reason);
ClearRecompCode_Virt(Address + 0xA0000000, length, Reason); ClearRecompCode_Virt(Address + 0xA0000000, length, Reason);
@ -453,19 +453,19 @@ void CRecompiler::ClearRecompCode_Phys(uint32_t Address, int length, REMOVE_REAS
ClearRecompCode_Virt(VAddr, length, Reason); ClearRecompCode_Virt(VAddr, length, Reason);
} }
} }
else if (g_System->LookUpMode() == FuncFind_PhysicalLookup) else if (m_System.LookUpMode() == FuncFind_PhysicalLookup)
{ {
if (Address < g_System->RdramSize()) if (Address < m_System.RdramSize())
{ {
int ClearLen = ((length + 3) & ~3); int ClearLen = ((length + 3) & ~3);
if (Address + ClearLen > g_System->RdramSize()) if (Address + ClearLen > m_System.RdramSize())
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
ClearLen = g_System->RdramSize() - Address; ClearLen = m_System.RdramSize() - Address;
} }
WriteTrace(TraceRecompiler, TraceInfo, "Resetting jump table, Addr: %X len: %d", Address, ClearLen); WriteTrace(TraceRecompiler, TraceInfo, "Resetting jump table, Addr: %X len: %d", Address, ClearLen);
memset((uint8_t *)JumpTable() + Address, 0, ClearLen); memset((uint8_t *)JumpTable() + Address, 0, ClearLen);
if (g_System->bSMM_Protect()) if (m_System.bSMM_Protect())
{ {
m_MMU.UnProtectMemory(Address + 0x80000000, Address + 0x80000004); m_MMU.UnProtectMemory(Address + 0x80000000, Address + 0x80000004);
} }
@ -482,7 +482,7 @@ void CRecompiler::ClearRecompCode_Virt(uint32_t Address, int length, REMOVE_REAS
uint32_t AddressIndex, WriteStart; uint32_t AddressIndex, WriteStart;
int DataInBlock, DataToWrite, DataLeft; int DataInBlock, DataToWrite, DataLeft;
switch (g_System->LookUpMode()) switch (m_System.LookUpMode())
{ {
case FuncFind_VirtualLookup: case FuncFind_VirtualLookup:
AddressIndex = Address >> 0xC; AddressIndex = Address >> 0xC;

19
Source/Project64-core/N64System/Recompiler/x86/x86RecompilerOps.cpp
View File

@ -59,8 +59,8 @@ void CX86RecompilerOps::x86CompilerBreakPoint()
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp());
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, g_System->CountPerOp()); g_System->UpdateSyncCPU(g_System->CountPerOp());
g_System->SyncCPU(g_SyncSystem); g_System->SyncSystem();
} }
} while (CDebugSettings::isStepping()); } while (CDebugSettings::isStepping());
@ -70,8 +70,8 @@ void CX86RecompilerOps::x86CompilerBreakPoint()
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp());
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, g_System->CountPerOp()); g_System->UpdateSyncCPU(g_System->CountPerOp());
g_System->SyncCPU(g_SyncSystem); g_System->SyncSystem();
} }
} }
} }
@ -81,8 +81,8 @@ void CX86RecompilerOps::x86BreakPointDelaySlot()
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp());
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, g_System->CountPerOp()); g_System->UpdateSyncCPU(g_System->CountPerOp());
g_System->SyncCPU(g_SyncSystem); g_System->SyncSystem();
} }
if (g_Debugger->ExecutionBP(g_Reg->m_PROGRAM_COUNTER)) if (g_Debugger->ExecutionBP(g_Reg->m_PROGRAM_COUNTER))
{ {
@ -93,8 +93,8 @@ void CX86RecompilerOps::x86BreakPointDelaySlot()
g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp()); g_System->m_OpCodes.ExecuteOps(g_System->CountPerOp());
if (g_SyncSystem) if (g_SyncSystem)
{ {
g_System->UpdateSyncCPU(g_SyncSystem, g_System->CountPerOp()); g_System->UpdateSyncCPU(g_System->CountPerOp());
g_System->SyncCPU(g_SyncSystem); g_System->SyncSystem();
} }
} }
} }
@ -9448,8 +9448,7 @@ void CX86RecompilerOps::UpdateSyncCPU(CRegInfo & RegSet, uint32_t Cycles)
m_CodeBlock.Log(" // Updating sync CPU"); m_CodeBlock.Log(" // Updating sync CPU");
RegSet.BeforeCallDirect(); RegSet.BeforeCallDirect();
m_Assembler.PushImm32(stdstr_f("%d", Cycles).c_str(), Cycles); m_Assembler.PushImm32(stdstr_f("%d", Cycles).c_str(), Cycles);
m_Assembler.PushImm32("g_SyncSystem", (uint32_t)g_SyncSystem); m_Assembler.CallThis((uint32_t)g_System, AddressOf(&CN64System::UpdateSyncCPU), "CN64System::UpdateSyncCPU", 8);
m_Assembler.CallThis((uint32_t)g_System, AddressOf(&CN64System::UpdateSyncCPU), "CN64System::UpdateSyncCPU", 12);
RegSet.AfterCallDirect(); RegSet.AfterCallDirect();
} }