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

Core: Some code clean up for load/store non memory

This commit is contained in:
zilmar 2022-05-30 20:20:25 +09:30
parent 535de2ad49
commit 603ed853bc
8 changed files with 294 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Source/Project64-core/N64System/Interpreter/InterpreterCPU.cpp
View File

@ -248,6 +248,7 @@ void CInterpreterCPU::InPermLoop()
{ {
if (*g_NextTimer > 0) if (*g_NextTimer > 0)
{ {
g_SystemTimer->UpdateTimers();
*g_NextTimer = 0 - g_System->CountPerOp(); *g_NextTimer = 0 - g_System->CountPerOp();
g_SystemTimer->UpdateTimers(); g_SystemTimer->UpdateTimers();
} }

81
Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp
View File

@ -743,7 +743,7 @@ bool CMipsMemoryVM::SW_NonMemory(uint32_t VAddr, uint32_t Value)
return true; return true;
} }
bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t /*Value*/) bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t Value)
{ {
uint32_t BaseAddress = m_TLB_ReadMap[VAddr >> 12]; uint32_t BaseAddress = m_TLB_ReadMap[VAddr >> 12];
if (BaseAddress == -1) if (BaseAddress == -1)
@ -751,7 +751,29 @@ bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t /*Value*/)
GenerateTLBWriteException(VAddr, __FUNCTION__); GenerateTLBWriteException(VAddr, __FUNCTION__);
return false; return false;
} }
g_Notify->BreakPoint(__FILE__, __LINE__); uint32_t PAddr = BaseAddress + VAddr;
switch (PAddr & 0xFFF00000)
{
case 0x00000000:
case 0x00100000:
case 0x00200000:
case 0x00300000:
case 0x00400000:
case 0x00500000:
case 0x00600000:
case 0x00700000:
if (PAddr < RdramSize())
{
g_Recompiler->ClearRecompCode_Phys(PAddr & ~0xFFF, 0xFFC, CRecompiler::Remove_ProtectedMem);
::ProtectMemory(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, MEM_READWRITE);
*(uint64_t *)(m_RDRAM + PAddr) = Value;
}
break;
default:
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
}
return true; return true;
} }
@ -759,61 +781,50 @@ bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t /*Value*/)
void CMipsMemoryVM::ProtectMemory(uint32_t StartVaddr, uint32_t EndVaddr) void CMipsMemoryVM::ProtectMemory(uint32_t StartVaddr, uint32_t EndVaddr)
{ {
WriteTrace(TraceProtectedMem, TraceDebug, "StartVaddr: %08X EndVaddr: %08X", StartVaddr, EndVaddr); WriteTrace(TraceProtectedMem, TraceDebug, "StartVaddr: %08X EndVaddr: %08X", StartVaddr, EndVaddr);
if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr))
if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr) || EndVaddr < StartVaddr)
{ {
return; return;
} }
// Get physical addresses passed int32_t Length = ((EndVaddr + 3) - StartVaddr) & ~3;
uint32_t StartPAddr, EndPAddr;
if (!VAddrToPAddr(StartVaddr, StartPAddr))
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
if (!VAddrToPAddr(EndVaddr, EndPAddr))
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
// Get length of memory being protected
int32_t Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) if (Length < 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
return;
} }
uint8_t * MemLoc = MemoryPtr(StartVaddr, Length, true);
// Protect that memory address space if (MemLoc == nullptr)
uint8_t * MemLoc = Rdram() + StartPAddr; {
WriteTrace(TraceProtectedMem, TraceDebug, "Paddr: %08X Length: %X", StartPAddr, Length); g_Notify->BreakPoint(__FILE__, __LINE__);
return;
}
WriteTrace(TraceProtectedMem, TraceDebug, "Length: 0x%X", Length);
::ProtectMemory(MemLoc, Length, MEM_READONLY); ::ProtectMemory(MemLoc, Length, MEM_READONLY);
} }
void CMipsMemoryVM::UnProtectMemory(uint32_t StartVaddr, uint32_t EndVaddr) void CMipsMemoryVM::UnProtectMemory(uint32_t StartVaddr, uint32_t EndVaddr)
{ {
WriteTrace(TraceProtectedMem, TraceDebug, "StartVaddr: %08X EndVaddr: %08X", StartVaddr, EndVaddr); WriteTrace(TraceProtectedMem, TraceDebug, "StartVaddr: %08X EndVaddr: %08X", StartVaddr, EndVaddr);
if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr)) { return; } if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr) || EndVaddr < StartVaddr)
// Get physical addresses passed
uint32_t StartPAddr, EndPAddr;
if (!VAddrToPAddr(StartVaddr, StartPAddr))
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); return;
}
if (!VAddrToPAddr(EndVaddr, EndPAddr))
{
g_Notify->BreakPoint(__FILE__, __LINE__);
} }
// Get length of memory being protected int32_t Length = ((EndVaddr + 3) - StartVaddr) & ~3;
int32_t Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) if (Length < 0)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
return;
}
uint8_t * MemLoc = MemoryPtr(StartVaddr, Length, true);
if (MemLoc == nullptr)
{
g_Notify->BreakPoint(__FILE__, __LINE__);
return;
} }
//Protect that memory address space WriteTrace(TraceProtectedMem, TraceDebug, "Length: 0x%X", Length);
uint8_t * MemLoc = Rdram() + StartPAddr;
::ProtectMemory(MemLoc, Length, MEM_READWRITE); ::ProtectMemory(MemLoc, Length, MEM_READWRITE);
} }

11
Source/Project64-core/N64System/Recompiler/CodeBlock.cpp
View File

@ -764,9 +764,14 @@ bool CCodeBlock::Compile()
m_RecompilerOps->CompileExitCode(); m_RecompilerOps->CompileExitCode();
m_CompiledLocationEnd = *g_RecompPos; m_CompiledLocationEnd = *g_RecompPos;
uint32_t PAddr; uint32_t BlockSize = (VAddrLast() - VAddrFirst()) + 4;
m_MMU.VAddrToPAddr(VAddrFirst(), PAddr); uint8_t * BlockPtr = m_MMU.MemoryPtr(VAddrFirst(), BlockSize, true);
MD5(g_MMU->Rdram() + PAddr, (VAddrLast() - VAddrFirst()) + 4).get_digest(m_Hash); if (BlockPtr == nullptr)
{
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
}
MD5(BlockPtr, BlockSize).get_digest(m_Hash);
#if defined(ANDROID) && (defined(__arm__) || defined(_M_ARM)) #if defined(ANDROID) && (defined(__arm__) || defined(_M_ARM))
__clear_cache((uint8_t *)((uint32_t)m_CompiledLocation & ~1), m_CompiledLocationEnd); __clear_cache((uint8_t *)((uint32_t)m_CompiledLocation & ~1), m_CompiledLocationEnd);
#endif #endif

1
Source/Project64-core/N64System/Recompiler/ExitInfo.h
View File

@ -18,6 +18,7 @@ struct CExitInfo
ExitResetRecompCode = 8, ExitResetRecompCode = 8,
}; };
std::string Name;
uint32_t ID; uint32_t ID;
uint32_t TargetPC; uint32_t TargetPC;
CRegInfo ExitRegSet; CRegInfo ExitRegSet;

2
Source/Project64-core/N64System/Recompiler/FunctionMap.h
View File

@ -3,7 +3,7 @@
#include <Project64-core/Settings/GameSettings.h> #include <Project64-core/Settings/GameSettings.h>
class CFunctionMap : class CFunctionMap :
private CGameSettings public CGameSettings
{ {
protected: protected:
typedef CCompiledFunc * PCCompiledFunc; typedef CCompiledFunc * PCCompiledFunc;

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

@ -662,7 +662,7 @@ void CX86RecompilerOps::Compile_Branch(BRANCH_COMPARE CompareType, BRANCH_TYPE B
} }
if (FallInfo->TargetPC <= m_CompilePC) if (FallInfo->TargetPC <= m_CompilePC)
{ {
UpdateCounters(m_Section->m_Jump.RegSet, true, true); UpdateCounters(m_Section->m_Jump.RegSet, true, true, true);
CPU_Message("CompileSystemCheck 12"); CPU_Message("CompileSystemCheck 12");
CompileSystemCheck(FallInfo->TargetPC, m_Section->m_Jump.RegSet); CompileSystemCheck(FallInfo->TargetPC, m_Section->m_Jump.RegSet);
ResetX86Protection(); ResetX86Protection();
@ -2745,9 +2745,6 @@ void CX86RecompilerOps::LDR()
void CX86RecompilerOps::LB_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExtend) void CX86RecompilerOps::LB_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExtend)
{ {
uint32_t PAddr;
char VarName[100];
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
x86Reg AddressReg = Map_TempReg(x86_Any, -1, false); x86Reg AddressReg = Map_TempReg(x86_Any, -1, false);
@ -2756,6 +2753,7 @@ void CX86RecompilerOps::LB_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExt
return; return;
} }
uint32_t PAddr;
if (!m_MMU.VAddrToPAddr(VAddr, PAddr)) if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
@ -2777,15 +2775,37 @@ void CX86RecompilerOps::LB_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExt
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
case 0x10000000: if (PAddr < g_MMU->RdramSize())
sprintf(VarName, "RDRAM + %X", PAddr);
if (SignExtend)
{ {
MoveSxVariableToX86regByte(PAddr + g_MMU->Rdram(), VarName, Reg); if (SignExtend)
{
MoveSxVariableToX86regByte((PAddr ^ 3) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 3)", PAddr).c_str(), Reg);
}
else
{
MoveZxVariableToX86regByte((PAddr ^ 3) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 3)", PAddr).c_str(), Reg);
}
} }
else else
{ {
MoveZxVariableToX86regByte(PAddr + g_MMU->Rdram(), VarName, Reg); MoveConstToX86reg(0, Reg);
}
break;
case 0x10000000:
if ((PAddr - 0x10000000) < g_Rom->GetRomSize())
{
if (SignExtend)
{
MoveSxVariableToX86regByte(((PAddr ^ 3) - 0x10000000) + g_Rom->GetRomAddress(), stdstr_f("Rom + (%X ^ 3)", (PAddr - 0x10000000)).c_str(), Reg);
}
else
{
MoveZxVariableToX86regByte(((PAddr ^ 3) - 0x10000000) + g_Rom->GetRomAddress(), stdstr_f("Rom + (%X ^ 3)", (PAddr - 0x10000000)).c_str(), Reg);
}
}
else
{
MoveConstToX86reg(0, Reg);
} }
break; break;
default: default:
@ -2799,7 +2819,6 @@ void CX86RecompilerOps::LB_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExt
void CX86RecompilerOps::LH_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExtend) void CX86RecompilerOps::LH_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExtend)
{ {
char VarName[100];
uint32_t PAddr; uint32_t PAddr;
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
@ -2830,15 +2849,37 @@ void CX86RecompilerOps::LH_KnownAddress(x86Reg Reg, uint32_t VAddr, bool SignExt
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
case 0x10000000: if (PAddr < g_MMU->RdramSize())
sprintf(VarName, "RDRAM + %X", PAddr);
if (SignExtend)
{ {
MoveSxVariableToX86regHalf(PAddr + g_MMU->Rdram(), VarName, Reg); if (SignExtend)
{
MoveSxVariableToX86regHalf((PAddr ^ 2) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 2)", PAddr).c_str(), Reg);
}
else
{
MoveZxVariableToX86regHalf((PAddr ^ 2) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 2)", PAddr).c_str(), Reg);
}
} }
else else
{ {
MoveZxVariableToX86regHalf(PAddr + g_MMU->Rdram(), VarName, Reg); MoveConstToX86reg(0, Reg);
}
break;
case 0x10000000:
if ((PAddr - 0x10000000) < g_Rom->GetRomSize())
{
if (SignExtend)
{
MoveSxVariableToX86regHalf(((PAddr ^ 2) - 0x10000000) + g_Rom->GetRomAddress(), stdstr_f("Rom + (%X ^ 2)", (PAddr - 0x10000000)).c_str(), Reg);
}
else
{
MoveZxVariableToX86regHalf(((PAddr ^ 2) - 0x10000000) + g_Rom->GetRomAddress(), stdstr_f("Rom + (%X ^ 2)", (PAddr - 0x10000000)).c_str(), Reg);
}
}
else
{
MoveConstToX86reg(0, Reg);
} }
break; break;
default: default:
@ -2859,7 +2900,7 @@ void CX86RecompilerOps::LB()
if (IsConst(m_Opcode.base)) if (IsConst(m_Opcode.base))
{ {
uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset) ^ 3; uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset);
if (HaveReadBP() && g_Debugger->ReadBP8(Address)) if (HaveReadBP() && g_Debugger->ReadBP8(Address))
{ {
FoundMemoryBreakpoint(); FoundMemoryBreakpoint();
@ -2880,7 +2921,7 @@ void CX86RecompilerOps::LH()
if (IsConst(m_Opcode.base)) if (IsConst(m_Opcode.base))
{ {
uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset) ^ 2; uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset);
if (HaveReadBP() && g_Debugger->ReadBP16(Address)) if (HaveReadBP() && g_Debugger->ReadBP16(Address))
{ {
FoundMemoryBreakpoint(); FoundMemoryBreakpoint();
@ -2999,9 +3040,6 @@ void CX86RecompilerOps::LW(bool ResultSigned, bool bRecordLLBit)
void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr) void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr)
{ {
char VarName[100];
uint32_t PAddr;
m_RegWorkingSet.SetX86Protected(Reg, true); m_RegWorkingSet.SetX86Protected(Reg, true);
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
@ -3011,6 +3049,7 @@ void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr)
} }
else else
{ {
uint32_t PAddr;
if (!m_MMU.VAddrToPAddr(VAddr, PAddr)) if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
@ -3026,31 +3065,42 @@ void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
sprintf(VarName, "RDRAM + %X", PAddr); if (PAddr < g_MMU->RdramSize())
MoveVariableToX86reg(PAddr + g_MMU->Rdram(), VarName, Reg); {
MoveVariableToX86reg(PAddr + g_MMU->Rdram(), stdstr_f("RDRAM + 0x%X", PAddr).c_str(), Reg);
}
else
{
MoveConstToX86reg(0, Reg);
}
break; break;
case 0x04000000: case 0x04000000:
if (PAddr < 0x04002000) if (PAddr < 0x04001000)
{ {
sprintf(VarName, "RDRAM + %X", PAddr); MoveVariableToX86reg((PAddr - 0x04000000) + g_MMU->Dmem(), stdstr_f("Dmem + 0x%X", (PAddr - 0x04000000)).c_str(), Reg);
MoveVariableToX86reg(PAddr + g_MMU->Rdram(), VarName, Reg);
break;
} }
switch (PAddr) else if (PAddr < 0x04002000)
{ {
case 0x04040010: MoveVariableToX86reg(&g_Reg->SP_STATUS_REG, "SP_STATUS_REG", Reg); break; MoveVariableToX86reg((PAddr - 0x04001000) + g_MMU->Imem(), stdstr_f("Imem + 0x%X", (PAddr - 0x04001000)).c_str(), Reg);
case 0x04040014: MoveVariableToX86reg(&g_Reg->SP_DMA_FULL_REG, "SP_DMA_FULL_REG", Reg); break; }
case 0x04040018: MoveVariableToX86reg(&g_Reg->SP_DMA_BUSY_REG, "SP_DMA_BUSY_REG", Reg); break; else
case 0x0404001C: {
MoveVariableToX86reg(&g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG", Reg); switch (PAddr)
MoveConstToVariable(1, &g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG");
break;
case 0x04080000: MoveVariableToX86reg(&g_Reg->SP_PC_REG, "SP_PC_REG", Reg); break;
default:
MoveConstToX86reg(0, Reg);
if (ShowUnhandledMemory())
{ {
g_Notify->DisplayError(stdstr_f("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr).c_str()); case 0x04040010: MoveVariableToX86reg(&g_Reg->SP_STATUS_REG, "SP_STATUS_REG", Reg); break;
case 0x04040014: MoveVariableToX86reg(&g_Reg->SP_DMA_FULL_REG, "SP_DMA_FULL_REG", Reg); break;
case 0x04040018: MoveVariableToX86reg(&g_Reg->SP_DMA_BUSY_REG, "SP_DMA_BUSY_REG", Reg); break;
case 0x0404001C:
MoveVariableToX86reg(&g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG", Reg);
MoveConstToVariable(1, &g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG");
break;
case 0x04080000: MoveVariableToX86reg(&g_Reg->SP_PC_REG, "SP_PC_REG", Reg); break;
default:
MoveConstToX86reg(0, Reg);
if (ShowUnhandledMemory())
{
g_Notify->DisplayError(stdstr_f("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr).c_str());
}
} }
} }
break; break;
@ -3107,7 +3157,7 @@ void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr)
case 0x04500000: case 0x04500000:
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -3218,21 +3268,17 @@ void CX86RecompilerOps::LW_KnownAddress(x86Reg Reg, uint32_t VAddr)
} }
break; break;
case 0x1FC00000: case 0x1FC00000:
sprintf(VarName, "RDRAM + %X", PAddr); MoveVariableToX86reg(PAddr + g_MMU->Rdram(), stdstr_f("RDRAM + %X").c_str(), Reg);
MoveVariableToX86reg(PAddr + g_MMU->Rdram(), VarName, Reg);
break; break;
default: default:
if ((PAddr & 0xF0000000) == 0x10000000 && (PAddr - 0x10000000) < g_Rom->GetRomSize()) if ((PAddr & 0xF0000000) == 0x10000000 && (PAddr - 0x10000000) < g_Rom->GetRomSize())
{ {
// Read from ROM MoveVariableToX86reg((PAddr - 0x10000000) + g_Rom->GetRomAddress(), stdstr_f("Rom + %X", (PAddr - 0x10000000)).c_str(), Reg);
sprintf(VarName, "Rom + %X", (PAddr - 0x10000000));
MoveVariableToX86reg((PAddr - 0x10000000) + g_Rom->GetRomAddress(), VarName, Reg);
} }
else if (g_DDRom != nullptr && ((PAddr & 0xFF000000) == 0x06000000 && (PAddr - 0x06000000) < g_DDRom->GetRomSize())) else if (g_DDRom != nullptr && ((PAddr & 0xFF000000) == 0x06000000 && (PAddr - 0x06000000) < g_DDRom->GetRomSize()))
{ {
// Read from DDROM (TODO: Is DDROM a disk image or the IPL?) // Read from DDROM (TODO: Is DDROM a disk image or the IPL?)
sprintf(VarName, "RDRAM + %X", PAddr); MoveVariableToX86reg(PAddr + g_MMU->Rdram(), stdstr_f("RDRAM + %X", PAddr).c_str(), Reg);
MoveVariableToX86reg(PAddr + g_MMU->Rdram(), VarName, Reg);
} }
else else
{ {
@ -3256,7 +3302,7 @@ void CX86RecompilerOps::LBU()
if (IsConst(m_Opcode.base)) if (IsConst(m_Opcode.base))
{ {
uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset) ^ 3; uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset);
if (HaveReadBP() && g_Debugger->ReadBP8(Address)) if (HaveReadBP() && g_Debugger->ReadBP8(Address))
{ {
FoundMemoryBreakpoint(); FoundMemoryBreakpoint();
@ -3280,7 +3326,7 @@ void CX86RecompilerOps::LHU()
if (IsConst(m_Opcode.base)) if (IsConst(m_Opcode.base))
{ {
uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset) ^ 2; uint32_t Address = (GetMipsRegLo(m_Opcode.base) + (int16_t)m_Opcode.offset);
if (HaveReadBP() && g_Debugger->ReadBP16(Address)) if (HaveReadBP() && g_Debugger->ReadBP16(Address))
{ {
FoundMemoryBreakpoint(); FoundMemoryBreakpoint();
@ -3556,6 +3602,7 @@ void CX86RecompilerOps::SW(bool bCheckLLbit)
} }
else if (IsMapped(m_Opcode.rt)) else if (IsMapped(m_Opcode.rt))
{ {
ProtectGPR(m_Opcode.rt);
SW_Register(GetMipsRegMapLo(m_Opcode.rt), Address); SW_Register(GetMipsRegMapLo(m_Opcode.rt), Address);
} }
else else
@ -3980,7 +4027,7 @@ void CX86RecompilerOps::SD()
{ {
ValueRegHi = Map_TempReg(x86_Any, m_Opcode.rt, true); ValueRegHi = Map_TempReg(x86_Any, m_Opcode.rt, true);
ValueRegLo = Map_TempReg(x86_Any, m_Opcode.rt, false); ValueRegLo = Map_TempReg(x86_Any, m_Opcode.rt, false);
} }
CompileStoreMemoryValue(x86_Unknown, ValueReg, ValueRegHi, RtValue, 64); CompileStoreMemoryValue(x86_Unknown, ValueReg, ValueRegHi, RtValue, 64);
} }
} }
@ -8287,7 +8334,7 @@ void CX86RecompilerOps::CompileExitCode()
for (EXIT_LIST::iterator ExitIter = m_ExitInfo.begin(); ExitIter != m_ExitInfo.end(); ExitIter++) for (EXIT_LIST::iterator ExitIter = m_ExitInfo.begin(); ExitIter != m_ExitInfo.end(); ExitIter++)
{ {
CPU_Message(""); CPU_Message("");
CPU_Message(" $Exit_%d", ExitIter->ID); CPU_Message(" $%s", ExitIter->Name.c_str());
SetJump32(ExitIter->JumpLoc, (uint32_t *)*g_RecompPos); SetJump32(ExitIter->JumpLoc, (uint32_t *)*g_RecompPos);
m_PipelineStage = ExitIter->PipelineStage; m_PipelineStage = ExitIter->PipelineStage;
CompileExit((uint32_t)-1, ExitIter->TargetPC, ExitIter->ExitRegSet, ExitIter->reason, true, nullptr); CompileExit((uint32_t)-1, ExitIter->TargetPC, ExitIter->ExitRegSet, ExitIter->reason, true, nullptr);
@ -8302,7 +8349,8 @@ void CX86RecompilerOps::CompileCop1Test()
} }
TestVariable(STATUS_CU1, &g_Reg->STATUS_REGISTER, "STATUS_REGISTER"); TestVariable(STATUS_CU1, &g_Reg->STATUS_REGISTER, "STATUS_REGISTER");
CompileExit(m_CompilePC, m_CompilePC, m_RegWorkingSet, CExitInfo::COP1_Unuseable, false, JeLabel32); CRegInfo ExitRegSet = m_RegWorkingSet;
CompileExit(m_CompilePC, m_CompilePC, ExitRegSet, CExitInfo::COP1_Unuseable, false, JeLabel32);
m_RegWorkingSet.SetFpuBeenUsed(true); m_RegWorkingSet.SetFpuBeenUsed(true);
} }
@ -9129,7 +9177,7 @@ void CX86RecompilerOps::UpdateCounters(CRegInfo & RegSet, bool CheckTimer, bool
SetJump8(Jump, *g_RecompPos); SetJump8(Jump, *g_RecompPos);
} }
if (UpdateTimer && g_SyncSystem) if ((UpdateTimer || CGameSettings::OverClockModifier() != 1) && g_SyncSystem)
{ {
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
#ifdef _MSC_VER #ifdef _MSC_VER
@ -9283,17 +9331,16 @@ void CX86RecompilerOps::CompileExit(uint32_t JumpPC, uint32_t TargetPC, CRegInfo
{ {
if (!CompileNow) if (!CompileNow)
{ {
char String[100];
sprintf(String, "Exit_%d", m_ExitInfo.size());
if (x86Jmp == nullptr) if (x86Jmp == nullptr)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
return; return;
} }
x86Jmp(String, 0); stdstr_f ExitName("Exit_%08X_%d", JumpPC, m_ExitInfo.size());
x86Jmp(ExitName.c_str(), 0);
CExitInfo ExitInfo; CExitInfo ExitInfo;
ExitInfo.ID = m_ExitInfo.size(); ExitInfo.ID = m_ExitInfo.size();
ExitInfo.Name = ExitName;
ExitInfo.TargetPC = TargetPC; ExitInfo.TargetPC = TargetPC;
ExitInfo.ExitRegSet = ExitRegSet; ExitInfo.ExitRegSet = ExitRegSet;
ExitInfo.reason = reason; ExitInfo.reason = reason;
@ -9719,7 +9766,7 @@ void CX86RecompilerOps::CompileStoreMemoryValue(CX86Ops::x86Reg AddressReg, CX86
MoveConstByteToX86regPointer((uint8_t)(Value & 0xFF), AddressReg, TempReg); MoveConstByteToX86regPointer((uint8_t)(Value & 0xFF), AddressReg, TempReg);
} }
else if (Is8BitReg(ValueReg)) else if (Is8BitReg(ValueReg))
{ {
MoveX86regByteToX86regPointer(ValueReg, AddressReg, TempReg); MoveX86regByteToX86regPointer(ValueReg, AddressReg, TempReg);
} }
else else
@ -9764,7 +9811,7 @@ void CX86RecompilerOps::CompileStoreMemoryValue(CX86Ops::x86Reg AddressReg, CX86
AddConstToX86Reg(AddressReg, 4); AddConstToX86Reg(AddressReg, 4);
MoveX86regToX86regPointer(ValueReg, AddressReg, TempReg); MoveX86regToX86regPointer(ValueReg, AddressReg, TempReg);
} }
} }
else else
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
@ -9799,7 +9846,10 @@ void CX86RecompilerOps::SB_Const(uint8_t Value, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
MoveConstByteToVariable(Value, (PAddr ^ 3) + g_MMU->Rdram(), stdstr_f("RDRAM + %X", (PAddr ^ 3)).c_str()); if (PAddr < g_MMU->RdramSize())
{
MoveConstByteToVariable(Value, (PAddr ^ 3) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 3)", PAddr).c_str());
}
break; break;
default: default:
if (ShowUnhandledMemory()) if (ShowUnhandledMemory())
@ -9811,9 +9861,6 @@ void CX86RecompilerOps::SB_Const(uint8_t Value, uint32_t VAddr)
void CX86RecompilerOps::SB_Register(x86Reg Reg, uint32_t VAddr) void CX86RecompilerOps::SB_Register(x86Reg Reg, uint32_t VAddr)
{ {
char VarName[100];
uint32_t PAddr;
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
m_RegWorkingSet.SetX86Protected(Reg, true); m_RegWorkingSet.SetX86Protected(Reg, true);
@ -9823,6 +9870,7 @@ void CX86RecompilerOps::SB_Register(x86Reg Reg, uint32_t VAddr)
return; return;
} }
uint32_t PAddr;
if (!m_MMU.VAddrToPAddr(VAddr, PAddr)) if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr); CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr);
@ -9843,8 +9891,10 @@ void CX86RecompilerOps::SB_Register(x86Reg Reg, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
sprintf(VarName, "RDRAM + %X", (PAddr ^ 3)); if (PAddr < g_MMU->RdramSize())
MoveX86regByteToVariable(Reg, (PAddr ^ 3) + g_MMU->Rdram(), VarName); {
MoveX86regByteToVariable(Reg, (PAddr ^ 3) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 3)", PAddr).c_str());
}
break; break;
default: default:
if (ShowUnhandledMemory()) if (ShowUnhandledMemory())
@ -9856,9 +9906,6 @@ void CX86RecompilerOps::SB_Register(x86Reg Reg, uint32_t VAddr)
void CX86RecompilerOps::SH_Const(uint16_t Value, uint32_t VAddr) void CX86RecompilerOps::SH_Const(uint16_t Value, uint32_t VAddr)
{ {
char VarName[100];
uint32_t PAddr;
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
x86Reg AddressReg = Map_TempReg(x86_Any, -1, false); x86Reg AddressReg = Map_TempReg(x86_Any, -1, false);
@ -9867,6 +9914,7 @@ void CX86RecompilerOps::SH_Const(uint16_t Value, uint32_t VAddr)
return; return;
} }
uint32_t PAddr;
if (!m_MMU.VAddrToPAddr(VAddr, PAddr)) if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr); CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr);
@ -9887,8 +9935,10 @@ void CX86RecompilerOps::SH_Const(uint16_t Value, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
sprintf(VarName, "RDRAM + %X", (PAddr ^ 2)); if (PAddr < g_MMU->RdramSize())
MoveConstHalfToVariable(Value, (PAddr ^ 2) + g_MMU->Rdram(), VarName); {
MoveConstHalfToVariable(Value, (PAddr ^ 2) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 2)", PAddr).c_str());
}
break; break;
default: default:
if (ShowUnhandledMemory()) if (ShowUnhandledMemory())
@ -9900,9 +9950,6 @@ void CX86RecompilerOps::SH_Const(uint16_t Value, uint32_t VAddr)
void CX86RecompilerOps::SH_Register(x86Reg Reg, uint32_t VAddr) void CX86RecompilerOps::SH_Register(x86Reg Reg, uint32_t VAddr)
{ {
char VarName[100];
uint32_t PAddr;
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
m_RegWorkingSet.SetX86Protected(Reg, true); m_RegWorkingSet.SetX86Protected(Reg, true);
@ -9910,45 +9957,48 @@ void CX86RecompilerOps::SH_Register(x86Reg Reg, uint32_t VAddr)
x86Reg AddressReg = Map_TempReg(x86_Any, -1, false); x86Reg AddressReg = Map_TempReg(x86_Any, -1, false);
MoveConstToX86reg(VAddr, AddressReg); MoveConstToX86reg(VAddr, AddressReg);
CompileStoreMemoryValue(AddressReg, Reg, x86_Unknown, 0, 16); CompileStoreMemoryValue(AddressReg, Reg, x86_Unknown, 0, 16);
return;
} }
else
if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr); uint32_t PAddr;
if (ShowUnhandledMemory()) if (m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
g_Notify->DisplayError(stdstr_f("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr).c_str()); switch (PAddr & 0xFFF00000)
{
case 0x00000000:
case 0x00100000:
case 0x00200000:
case 0x00300000:
case 0x00400000:
case 0x00500000:
case 0x00600000:
case 0x00700000:
if (PAddr < g_MMU->RdramSize())
{
MoveX86regHalfToVariable(Reg, (PAddr ^ 2) + g_MMU->Rdram(), stdstr_f("RDRAM + (%X ^ 2)", PAddr).c_str());
}
break;
default:
if (ShowUnhandledMemory())
{
g_Notify->DisplayError(stdstr_f("%s\nTrying to store in %08X?", __FUNCTION__, PAddr).c_str());
}
}
} }
return; else
}
switch (PAddr & 0xFFF00000)
{
case 0x00000000:
case 0x00100000:
case 0x00200000:
case 0x00300000:
case 0x00400000:
case 0x00500000:
case 0x00600000:
case 0x00700000:
sprintf(VarName, "RDRAM + %X", (PAddr ^ 2));
MoveX86regHalfToVariable(Reg, (PAddr ^ 2) + g_MMU->Rdram(), VarName);
break;
default:
if (ShowUnhandledMemory())
{ {
g_Notify->DisplayError(stdstr_f("%s\nTrying to store in %08X?", __FUNCTION__, PAddr).c_str()); CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr);
if (ShowUnhandledMemory())
{
g_Notify->DisplayError(stdstr_f("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr).c_str());
}
} }
} }
} }
void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr) void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
{ {
char VarName[100];
uint8_t * Jump; uint8_t * Jump;
uint32_t PAddr;
if (VAddr < 0x80000000 || VAddr >= 0xC0000000) if (VAddr < 0x80000000 || VAddr >= 0xC0000000)
{ {
@ -9958,6 +10008,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
return; return;
} }
uint32_t PAddr;
if (!m_MMU.VAddrToPAddr(VAddr, PAddr)) if (!m_MMU.VAddrToPAddr(VAddr, PAddr))
{ {
CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr); CPU_Message("%s\nFailed to translate address: %08X", __FUNCTION__, VAddr);
@ -9978,8 +10029,10 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
sprintf(VarName, "RDRAM + %X", PAddr); if (PAddr < g_MMU->RdramSize())
MoveConstToVariable(Value, PAddr + g_MMU->Rdram(), VarName); {
MoveConstToVariable(Value, PAddr + g_MMU->Rdram(), stdstr_f("RDRAM + %X", PAddr).c_str());
}
break; break;
case 0x03F00000: case 0x03F00000:
switch (PAddr) switch (PAddr)
@ -10008,57 +10061,62 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
} }
break; break;
case 0x04000000: case 0x04000000:
if (PAddr < 0x04002000) if (PAddr < 0x04001000)
{ {
sprintf(VarName, "RDRAM + %X", PAddr); MoveConstToVariable(Value, (PAddr - 0x04000000) + g_MMU->Dmem(), stdstr_f("DMem + %X", (PAddr - 0x04000000)).c_str());
MoveConstToVariable(Value, PAddr + g_MMU->Rdram(), VarName);
break;
} }
switch (PAddr) else if (PAddr < 0x04002000)
{ {
case 0x04040000: MoveConstToVariable(Value, &g_Reg->SP_MEM_ADDR_REG, "SP_MEM_ADDR_REG"); break; MoveConstToVariable(Value, (PAddr - 0x04001000) + g_MMU->Imem(), stdstr_f("Imem + %X", (PAddr - 0x04001000)).c_str());
case 0x04040004: MoveConstToVariable(Value, &g_Reg->SP_DRAM_ADDR_REG, "SP_DRAM_ADDR_REG"); break; }
case 0x04040008: else
m_RegWorkingSet.BeforeCallDirect(); {
PushImm32(0xFFFFFFFF); switch (PAddr)
PushImm32(Value);
PushImm32(PAddr & 0x1FFFFFFF);
#ifdef _MSC_VER
MoveConstToX86reg((uint32_t)(MemoryHandler *)&g_MMU->m_SPRegistersHandler, x86_ECX);
Call_Direct((void *)((long**)(MemoryHandler *)&g_MMU->m_SPRegistersHandler)[0][1], "SPRegistersHandler::Write32");
#else
PushImm32((uint32_t)&g_MMU->m_SPRegistersHandler);
Call_Direct(AddressOf(&SPRegistersHandler::Write32), "SPRegistersHandler::Write32");
AddConstToX86Reg(x86_ESP, 16);
#endif
m_RegWorkingSet.AfterCallDirect();
break;
case 0x04040010:
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); case 0x04040000: MoveConstToVariable(Value, &g_Reg->SP_MEM_ADDR_REG, "SP_MEM_ADDR_REG"); break;
UpdateCounters(m_RegWorkingSet, false, true); case 0x04040004: MoveConstToVariable(Value, &g_Reg->SP_DRAM_ADDR_REG, "SP_DRAM_ADDR_REG"); break;
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); case 0x04040008:
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
PushImm32(0xFFFFFFFF);
PushImm32(Value); PushImm32(Value);
PushImm32(PAddr | 0xA0000000); PushImm32(PAddr & 0x1FFFFFFF);
#ifdef _MSC_VER #ifdef _MSC_VER
MoveConstToX86reg((uint32_t)(g_MMU), x86_ECX); MoveConstToX86reg((uint32_t)(MemoryHandler *)&g_MMU->m_SPRegistersHandler, x86_ECX);
Call_Direct(AddressOf(&CMipsMemoryVM::SW_NonMemory), "CMipsMemoryVM::SW_NonMemory"); Call_Direct((void *)((long**)(MemoryHandler *)&g_MMU->m_SPRegistersHandler)[0][1], "SPRegistersHandler::Write32");
#else #else
PushImm32((uint32_t)(g_MMU)); PushImm32((uint32_t)&g_MMU->m_SPRegistersHandler);
Call_Direct(AddressOf(&CMipsMemoryVM::SW_NonMemory), "CMipsMemoryVM::SW_NonMemory"); Call_Direct(AddressOf(&SPRegistersHandler::Write32), "SPRegistersHandler::Write32");
AddConstToX86Reg(x86_ESP, 12); AddConstToX86Reg(x86_ESP, 16);
#endif #endif
m_RegWorkingSet.AfterCallDirect(); m_RegWorkingSet.AfterCallDirect();
} break;
break; case 0x04040010:
case 0x0404001C: MoveConstToVariable(0, &g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG"); break; {
case 0x04080000: MoveConstToVariable(Value & 0xFFC, &g_Reg->SP_PC_REG, "SP_PC_REG"); break; m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
default: UpdateCounters(m_RegWorkingSet, false, true, false);
if (ShowUnhandledMemory()) m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
{
g_Notify->DisplayError(stdstr_f("%s\nTrying to store %08X in %08X?", __FUNCTION__, Value, VAddr).c_str()); m_RegWorkingSet.BeforeCallDirect();
PushImm32(Value);
PushImm32(PAddr | 0xA0000000);
#ifdef _MSC_VER
MoveConstToX86reg((uint32_t)(g_MMU), x86_ECX);
Call_Direct(AddressOf(&CMipsMemoryVM::SW_NonMemory), "CMipsMemoryVM::SW_NonMemory");
#else
PushImm32((uint32_t)(g_MMU));
Call_Direct(AddressOf(&CMipsMemoryVM::SW_NonMemory), "CMipsMemoryVM::SW_NonMemory");
AddConstToX86Reg(x86_ESP, 12);
#endif
m_RegWorkingSet.AfterCallDirect();
}
break;
case 0x0404001C: MoveConstToVariable(0, &g_Reg->SP_SEMAPHORE_REG, "SP_SEMAPHORE_REG"); break;
case 0x04080000: MoveConstToVariable(Value & 0xFFC, &g_Reg->SP_PC_REG, "SP_PC_REG"); break;
default:
if (ShowUnhandledMemory())
{
g_Notify->DisplayError(stdstr_f("%s\nTrying to store %08X in %08X?", __FUNCTION__, Value, VAddr).c_str());
}
} }
} }
break; break;
@ -10208,7 +10266,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
if (GenerateLog() && LogVideoInterface()) if (GenerateLog() && LogVideoInterface())
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10293,7 +10351,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
break; break;
case 0x04500000: case 0x04500000:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10330,7 +10388,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
break; break;
case 0x0460000C: case 0x0460000C:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
MoveConstToVariable(Value, &g_Reg->PI_WR_LEN_REG, "PI_WR_LEN_REG"); MoveConstToVariable(Value, &g_Reg->PI_WR_LEN_REG, "PI_WR_LEN_REG");
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10395,7 +10453,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
case 0x04800000: MoveConstToVariable(Value, &g_Reg->SI_DRAM_ADDR_REG, "SI_DRAM_ADDR_REG"); break; case 0x04800000: MoveConstToVariable(Value, &g_Reg->SI_DRAM_ADDR_REG, "SI_DRAM_ADDR_REG"); break;
case 0x04800004: case 0x04800004:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
MoveConstToVariable(Value, &g_Reg->SI_PIF_ADDR_RD64B_REG, "SI_PIF_ADDR_RD64B_REG"); MoveConstToVariable(Value, &g_Reg->SI_PIF_ADDR_RD64B_REG, "SI_PIF_ADDR_RD64B_REG");
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10411,7 +10469,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
break; break;
case 0x04800010: case 0x04800010:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
MoveConstToVariable(Value, &g_Reg->SI_PIF_ADDR_WR64B_REG, "SI_PIF_ADDR_WR64B_REG"); MoveConstToVariable(Value, &g_Reg->SI_PIF_ADDR_WR64B_REG, "SI_PIF_ADDR_WR64B_REG");
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10468,7 +10526,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
case 0x1fc00000: case 0x1fc00000:
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10491,7 +10549,7 @@ void CX86RecompilerOps::SW_Const(uint32_t Value, uint32_t VAddr)
g_Notify->DisplayError(stdstr_f("%s\nTrying to store %08X in %08X?", __FUNCTION__, Value, VAddr).c_str()); g_Notify->DisplayError(stdstr_f("%s\nTrying to store %08X in %08X?", __FUNCTION__, Value, VAddr).c_str());
} }
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, true);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10543,8 +10601,11 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
case 0x00500000: case 0x00500000:
case 0x00600000: case 0x00600000:
case 0x00700000: case 0x00700000:
sprintf(VarName, "RDRAM + %X", PAddr); if (PAddr < g_MMU->RdramSize())
MoveX86regToVariable(Reg, PAddr + g_MMU->Rdram(), VarName); {
sprintf(VarName, "RDRAM + %X", PAddr);
MoveX86regToVariable(Reg, PAddr + g_MMU->Rdram(), VarName);
}
break; break;
case 0x04000000: case 0x04000000:
switch (PAddr) switch (PAddr)
@ -10569,7 +10630,7 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
break; break;
case 0x04040010: case 0x04040010:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
MoveX86regToVariable(Reg, &CMipsMemoryVM::RegModValue, "CMipsMemoryVM::RegModValue"); MoveX86regToVariable(Reg, &CMipsMemoryVM::RegModValue, "CMipsMemoryVM::RegModValue");
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10582,10 +10643,13 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
AndConstToVariable(0xFFC, &g_Reg->SP_PC_REG, "SP_PC_REG"); AndConstToVariable(0xFFC, &g_Reg->SP_PC_REG, "SP_PC_REG");
break; break;
default: default:
if (PAddr < 0x04002000) if (PAddr < 0x04001000)
{ {
sprintf(VarName, "RDRAM + %X", PAddr); MoveX86regToVariable(Reg, g_MMU->Dmem() + (PAddr - 0x04000000), stdstr_f("DMEM + 0x%X", (PAddr - 0x04000000)).c_str());
MoveX86regToVariable(Reg, PAddr + g_MMU->Rdram(), VarName); }
else if (PAddr < 0x04002000)
{
MoveX86regToVariable(Reg, g_MMU->Imem() + (PAddr - 0x04001000), stdstr_f("IMEM + 0x%X", (PAddr - 0x04001000)).c_str());
} }
else else
{ {
@ -10601,7 +10665,7 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
if (PAddr == 0x0410000C) if (PAddr == 0x0410000C)
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
} }
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10653,7 +10717,7 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
if (GenerateLog() && LogVideoInterface()) if (GenerateLog() && LogVideoInterface())
{ {
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();
@ -10789,7 +10853,7 @@ void CX86RecompilerOps::SW_Register(x86Reg Reg, uint32_t VAddr)
break; break;
case 0x0460000C: case 0x0460000C:
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true, false);
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() + g_System->CountPerOp());
MoveX86regToVariable(Reg, &g_Reg->PI_WR_LEN_REG, "PI_WR_LEN_REG"); MoveX86regToVariable(Reg, &g_Reg->PI_WR_LEN_REG, "PI_WR_LEN_REG");
m_RegWorkingSet.BeforeCallDirect(); m_RegWorkingSet.BeforeCallDirect();

14
Source/Project64-core/N64System/Recompiler/x86/x86RegInfo.cpp
View File

@ -16,7 +16,8 @@ uint32_t CX86RegInfo::m_fpuControl = 0;
const char *Format_Name[] = { "Unknown", "dword", "qword", "float", "double" }; const char *Format_Name[] = { "Unknown", "dword", "qword", "float", "double" };
CX86RegInfo::CX86RegInfo() : CX86RegInfo::CX86RegInfo() :
m_Stack_TopPos(0) m_Stack_TopPos(0),
m_InBeforeCallDirect(false)
{ {
for (int32_t i = 0; i < 32; i++) for (int32_t i = 0; i < 32; i++)
{ {
@ -51,6 +52,7 @@ CX86RegInfo& CX86RegInfo::operator=(const CX86RegInfo& right)
{ {
CRegBase::operator=(right); CRegBase::operator=(right);
m_Stack_TopPos = right.m_Stack_TopPos; m_Stack_TopPos = right.m_Stack_TopPos;
m_InBeforeCallDirect = right.m_InBeforeCallDirect;
memcpy(&m_RegMapLo, &right.m_RegMapLo, sizeof(m_RegMapLo)); memcpy(&m_RegMapLo, &right.m_RegMapLo, sizeof(m_RegMapLo));
memcpy(&m_RegMapHi, &right.m_RegMapHi, sizeof(m_RegMapHi)); memcpy(&m_RegMapHi, &right.m_RegMapHi, sizeof(m_RegMapHi));
@ -112,12 +114,22 @@ CX86RegInfo::REG_STATE CX86RegInfo::ConstantsType(int64_t Value)
void CX86RegInfo::BeforeCallDirect(void) void CX86RegInfo::BeforeCallDirect(void)
{ {
if (m_InBeforeCallDirect)
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
m_InBeforeCallDirect = true;
UnMap_AllFPRs(); UnMap_AllFPRs();
Pushad(); Pushad();
} }
void CX86RegInfo::AfterCallDirect(void) void CX86RegInfo::AfterCallDirect(void)
{ {
if (!m_InBeforeCallDirect)
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
m_InBeforeCallDirect = false;
Popad(); Popad();
SetRoundingModel(CRegInfo::RoundUnknown); SetRoundingModel(CRegInfo::RoundUnknown);
} }

1
Source/Project64-core/N64System/Recompiler/x86/x86RegInfo.h
View File

@ -108,5 +108,6 @@ private:
FPU_ROUND m_x86fpu_RoundingModel[8]; FPU_ROUND m_x86fpu_RoundingModel[8];
static uint32_t m_fpuControl; static uint32_t m_fpuControl;
bool m_InBeforeCallDirect;
}; };
#endif #endif