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

[Project64] Update Recompiler Class.cpp to use standard types

This commit is contained in:
zilmar 2015-11-10 07:19:27 +11:00
parent 0c00b90334
commit d06eae9457
2 changed files with 972 additions and 918 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

417
Source/Project64/N64 System/Recompiler/Recompiler Class.cpp
View File

@ -10,7 +10,7 @@
****************************************************************************/
#include "stdafx.h"
CRecompiler::CRecompiler(CRegisters & Registers, CProfiling & Profile, bool & EndEmulation ) :
CRecompiler::CRecompiler(CRegisters & Registers, CProfiling & Profile, bool & EndEmulation) :
m_Registers(Registers),
m_Profile(Profile),
m_EndEmulation(EndEmulation),
@ -37,26 +37,29 @@ void CRecompiler::Run()
if (!CRecompMemory::AllocateMemory())
{
WriteTrace(TraceError,__FUNCTION__ ": AllocateMemory failed");
WriteTrace(TraceError, __FUNCTION__ ": AllocateMemory failed");
return;
}
if (!CFunctionMap::AllocateMemory())
{
WriteTrace(TraceError,__FUNCTION__ ": AllocateMemory failed");
WriteTrace(TraceError, __FUNCTION__ ": AllocateMemory failed");
return;
}
m_EndEmulation = false;
#ifdef tofix
*g_MemoryStack = (DWORD)(RDRAM+(_GPR[29].W[0] & 0x1FFFFFFF));
*g_MemoryStack = (uint32_t)(RDRAM+(_GPR[29].W[0] & 0x1FFFFFFF));
#endif
__try {
__try
{
if (g_System->LookUpMode() == FuncFind_VirtualLookup)
{
if (g_System->bSMM_ValidFunc())
{
RecompilerMain_VirtualTable_validate();
} else {
}
else
{
RecompilerMain_VirtualTable();
}
}
@ -71,20 +74,26 @@ void CRecompiler::Run()
if (g_System->bSMM_ValidFunc())
{
RecompilerMain_Lookup_validate_TLB();
} else {
}
else
{
RecompilerMain_Lookup_TLB();
}
} else {
}
else
{
if (g_System->bSMM_ValidFunc())
{
RecompilerMain_Lookup_validate();
} else {
}
else
{
RecompilerMain_Lookup();
}
}
}
}
__except( g_MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) )
__except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation()))
{
g_Notify->DisplayError(MSG_UNKNOWN_MEM_ACTION);
}
@ -95,21 +104,21 @@ void CRecompiler::RecompilerMain_VirtualTable()
bool & Done = m_EndEmulation;
uint32_t & PC = PROGRAM_COUNTER;
while(!Done)
while (!Done)
{
if (!g_TransVaddr->ValidVaddr(PC))
{
m_Registers.DoTLBReadMiss(false,PC);
m_Registers.DoTLBReadMiss(false, PC);
if (!g_TransVaddr->ValidVaddr(PC))
{
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PC).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).ToUTF16().c_str());
return;
}
continue;
}
PCCompiledFunc_TABLE & table = FunctionTable()[PC >> 0xC];
DWORD TableEntry = (PC & 0xFFF) >> 2;
uint32_t TableEntry = (PC & 0xFFF) >> 2;
if (table)
{
CCompiledFunc * info = table[TableEntry];
@ -130,14 +139,14 @@ void CRecompiler::RecompilerMain_VirtualTable()
table = new PCCompiledFunc[(0x1000 >> 2)];
if (table == NULL)
{
WriteTrace(TraceError,__FUNCTION__ ": failed to allocate PCCompiledFunc");
WriteTrace(TraceError, __FUNCTION__ ": failed to allocate PCCompiledFunc");
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())
{
WriteTraceF(TraceError,__FUNCTION__ ": Create Table (%X): Index = %d",table, PC >> 0xC);
g_MMU->ProtectMemory(PC & ~0xFFF,PC | 0xFFF);
WriteTraceF(TraceError, __FUNCTION__ ": Create Table (%X): Index = %d", table, PC >> 0xC);
g_MMU->ProtectMemory(PC & ~0xFFF, PC | 0xFFF);
}
}
@ -148,8 +157,8 @@ void CRecompiler::RecompilerMain_VirtualTable()
void CRecompiler::RecompilerMain_VirtualTable_validate()
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
/* PCCompiledFunc_TABLE * m_FunctionTable = m_Functions.GetFunctionTable();
g_Notify->BreakPoint(__FILEW__, __LINE__);
/* PCCompiledFunc_TABLE * m_FunctionTable = m_Functions.GetFunctionTable();
while(!m_EndEmulation)
{
@ -160,7 +169,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
if (Info == NULL)
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
#ifdef tofix
#ifdef tofix
if (!g_TLB->ValidVaddr(PROGRAM_COUNTER))
{
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
@ -172,7 +181,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
}
continue;
}
#endif
#endif
//Find Block on hash table
Info = CompileDelaySlot(PROGRAM_COUNTER);
@ -181,7 +190,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
break;
}
}
const BYTE * Block = Info->FunctionAddr();
const uint8_t * Block = Info->FunctionAddr();
if ((*Info->MemLocation[0] != Info->MemContents[0]) ||
(*Info->MemLocation[1] != Info->MemContents[1]))
{
@ -197,7 +206,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
}
continue;
}*/
/* PCCompiledFunc_TABLE table = m_FunctionTable[PROGRAM_COUNTER >> 0xC];
/* PCCompiledFunc_TABLE table = m_FunctionTable[PROGRAM_COUNTER >> 0xC];
if (table)
{
CCompiledFunc * info = table[(PROGRAM_COUNTER & 0xFFF) >> 2];
@ -210,7 +219,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
info = NULL;
continue;
}
const BYTE * Block = info->FunctionAddr();
const uint8_t * Block = info->FunctionAddr();
_asm {
pushad
call Block
@ -220,7 +229,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
}
}
g_Notify->BreakPoint(__FILEW__,__LINE__);
#ifdef tofix
#ifdef tofix
if (!g_TLB->ValidVaddr(PROGRAM_COUNTER))
{
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
@ -231,17 +240,16 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
return;
}
}
#endif
#endif
CCompiledFunc * info = CompilerCode();
if (info == NULL || EndEmulation())
{
break;
}
}
/*
/*
while(!m_EndEmulation)
{
if (!g_MMU->ValidVaddr(PROGRAM_COUNTER))
@ -279,7 +287,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
continue;
}
}
const BYTE * Block = Info->FunctionAddr();
const uint8_t * Block = Info->FunctionAddr();
_asm {
pushad
call Block
@ -310,7 +318,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
continue;
}
}
const BYTE * Block = Info->FunctionAddr();
const uint8_t * Block = Info->FunctionAddr();
_asm {
pushad
call Block
@ -322,9 +330,9 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
void CRecompiler::RecompilerMain_Lookup()
{
while(!m_EndEmulation)
while (!m_EndEmulation)
{
DWORD PhysicalAddr = PROGRAM_COUNTER & 0x1FFFFFFF;
uint32_t PhysicalAddr = PROGRAM_COUNTER & 0x1FFFFFFF;
if (PhysicalAddr < g_System->RdramSize())
{
CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2];
@ -337,15 +345,17 @@ void CRecompiler::RecompilerMain_Lookup()
}
if (g_System->bSMM_Protect())
{
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF,PROGRAM_COUNTER | 0xFFF);
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF);
}
JumpTable()[PhysicalAddr >> 2] = info;
}
(info->Function())();
} else {
DWORD opsExecuted = 0;
}
else
{
uint32_t opsExecuted = 0;
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
{
CInterpreterCPU::ExecuteOps(g_System->CountPerOp());
opsExecuted += g_System->CountPerOp();
@ -353,22 +363,22 @@ void CRecompiler::RecompilerMain_Lookup()
if (g_SyncSystem)
{
g_System->UpdateSyncCPU(g_SyncSystem,opsExecuted);
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted);
g_System->SyncCPU(g_SyncSystem);
}
}
}
/*
DWORD Addr;
uint32_t Addr;
CCompiledFunc * Info;
//const BYTE * Block;
//const uint8_t * Block;
while(!m_EndEmulation)
{
/*if (bUseTlb())
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
#ifdef tofix
#ifdef tofix
if (!g_TLB->TranslateVaddr(PROGRAM_COUNTER, Addr))
{
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
@ -378,7 +388,7 @@ void CRecompiler::RecompilerMain_Lookup()
return;
}
}
#endif
#endif
} else {
Addr = PROGRAM_COUNTER & 0x1FFFFFFF;
}*/
@ -407,7 +417,7 @@ void CRecompiler::RecompilerMain_Lookup()
continue;
}
}
const BYTE * Block = Info->FunctionAddr();
const uint8_t * Block = Info->FunctionAddr();
_asm {
pushad
call Block
@ -466,9 +476,9 @@ void CRecompiler::RecompilerMain_Lookup()
}
*(JumpTable + (Addr >> 2)) = (void *)Info;
// if (SelfModCheck == ModCode_ProtectedMemory) {
// VirtualProtect(RDRAM + Addr, 4, PAGE_READONLY, &OldProtect);
// }
// if (SelfModCheck == ModCode_ProtectedMemory) {
// VirtualProtect(RDRAM + Addr, 4, PAGE_READONLY, &OldProtect);
// }
}
if (bSMM_ValidFunc())
{
@ -481,27 +491,27 @@ void CRecompiler::RecompilerMain_Lookup()
}
}
g_Notify->BreakPoint(__FILEW__,__LINE__);
#ifdef tofix
#ifdef tofix
if (Profiling && IndvidualBlock) {
static DWORD ProfAddress = 0;
static uint32_t ProfAddress = 0;
if ((PROGRAM_COUNTER & ~0xFFF) != ProfAddress) {
char Label[100];
ProfAddress = PROGRAM_COUNTER & ~0xFFF;
sprintf(Label,"PC: %X to %X",ProfAddress,ProfAddress+ 0xFFC);
// StartTimer(Label);
// StartTimer(Label);
}
/*if (PROGRAM_COUNTER >= 0x800DD000 && PROGRAM_COUNTER <= 0x800DDFFC) {
char Label[100];
sprintf(Label,"PC: %X Block: %X",PROGRAM_COUNTER,Block);
StartTimer(Label);
}*/
// } else if ((Profiling || ShowCPUPer) && ProfilingLabel[0] == 0) {
// StartTimer("r4300i Running");
/* }
#endif
const BYTE * Block = Info->FunctionAddr();
// } else if ((Profiling || ShowCPUPer) && ProfilingLabel[0] == 0) {
// StartTimer("r4300i Running");
/* }
#endif
const uint8_t * Block = Info->FunctionAddr();
_asm {
pushad
call Block
@ -512,16 +522,16 @@ void CRecompiler::RecompilerMain_Lookup()
void CRecompiler::RecompilerMain_Lookup_TLB()
{
DWORD PhysicalAddr;
uint32_t PhysicalAddr;
while(!m_EndEmulation)
while (!m_EndEmulation)
{
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr))
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
m_Registers.DoTLBReadMiss(false,PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr))
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).ToUTF16().c_str());
m_EndEmulation = true;
}
continue;
@ -539,7 +549,7 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
}
if (g_System->bSMM_Protect())
{
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF,PROGRAM_COUNTER | 0xFFF);
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF);
}
JumpTable()[PhysicalAddr >> 2] = info;
}
@ -547,9 +557,9 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
}
else
{
DWORD opsExecuted = 0;
uint32_t opsExecuted = 0;
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
{
CInterpreterCPU::ExecuteOps(g_System->CountPerOp());
opsExecuted += g_System->CountPerOp();
@ -557,7 +567,7 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
if (g_SyncSystem)
{
g_System->UpdateSyncCPU(g_SyncSystem,opsExecuted);
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted);
g_System->SyncCPU(g_SyncSystem);
}
}
@ -566,9 +576,9 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
void CRecompiler::RecompilerMain_Lookup_validate()
{
while(!m_EndEmulation)
while (!m_EndEmulation)
{
DWORD PhysicalAddr = PROGRAM_COUNTER & 0x1FFFFFFF;
uint32_t PhysicalAddr = PROGRAM_COUNTER & 0x1FFFFFFF;
if (PhysicalAddr < g_System->RdramSize())
{
CCompiledFunc * info = JumpTable()[PhysicalAddr >> 2];
@ -581,23 +591,27 @@ void CRecompiler::RecompilerMain_Lookup_validate()
}
if (g_System->bSMM_Protect())
{
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF,PROGRAM_COUNTER | 0xFFF);
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF);
}
JumpTable()[PhysicalAddr >> 2] = info;
} else {
}
else
{
if (*(info->MemLocation(0)) != info->MemContents(0) ||
*(info->MemLocation(1)) != info->MemContents(1))
{
ClearRecompCode_Virt((info->EnterPC() - 0x1000) & ~0xFFF,0x3000,Remove_ValidateFunc);
ClearRecompCode_Virt((info->EnterPC() - 0x1000) & ~0xFFF, 0x3000, Remove_ValidateFunc);
info = NULL;
continue;
}
}
(info->Function())();
} else {
DWORD opsExecuted = 0;
}
else
{
uint32_t opsExecuted = 0;
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
{
CInterpreterCPU::ExecuteOps(g_System->CountPerOp());
opsExecuted += g_System->CountPerOp();
@ -605,7 +619,7 @@ void CRecompiler::RecompilerMain_Lookup_validate()
if (g_SyncSystem)
{
g_System->UpdateSyncCPU(g_SyncSystem,opsExecuted);
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted);
g_System->SyncCPU(g_SyncSystem);
}
}
@ -614,16 +628,16 @@ void CRecompiler::RecompilerMain_Lookup_validate()
void CRecompiler::RecompilerMain_Lookup_validate_TLB()
{
DWORD PhysicalAddr;
uint32_t PhysicalAddr;
while(!m_EndEmulation)
while (!m_EndEmulation)
{
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr))
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
m_Registers.DoTLBReadMiss(false,PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr))
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).ToUTF16().c_str());
m_EndEmulation = true;
}
continue;
@ -641,33 +655,39 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB()
}
if (g_System->bSMM_Protect())
{
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF,PROGRAM_COUNTER | 0xFFF);
g_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF, PROGRAM_COUNTER | 0xFFF);
}
JumpTable()[PhysicalAddr >> 2] = info;
} else {
}
else
{
if (*(info->MemLocation(0)) != info->MemContents(0) ||
*(info->MemLocation(1)) != info->MemContents(1))
{
if (PhysicalAddr > 0x1000)
{
ClearRecompCode_Phys((PhysicalAddr - 0x1000) & ~0xFFF,0x3000,Remove_ValidateFunc);
} else {
ClearRecompCode_Phys(0,0x2000,Remove_ValidateFunc);
ClearRecompCode_Phys((PhysicalAddr - 0x1000) & ~0xFFF, 0x3000, Remove_ValidateFunc);
}
else
{
ClearRecompCode_Phys(0, 0x2000, Remove_ValidateFunc);
}
info = JumpTable()[PhysicalAddr >> 2];
if (info != NULL)
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
info = NULL;
}
continue;
}
}
(info->Function())();
} else {
DWORD opsExecuted = 0;
}
else
{
uint32_t opsExecuted = 0;
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, (uint32_t &)PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
while (g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr) && PhysicalAddr >= g_System->RdramSize())
{
CInterpreterCPU::ExecuteOps(g_System->CountPerOp());
opsExecuted += g_System->CountPerOp();
@ -675,7 +695,7 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB()
if (g_SyncSystem)
{
g_System->UpdateSyncCPU(g_SyncSystem,opsExecuted);
g_System->UpdateSyncCPU(g_SyncSystem, opsExecuted);
g_System->SyncCPU(g_SyncSystem);
}
}
@ -688,7 +708,7 @@ void CRecompiler::Reset()
ResetMemoryStackPos();
}
void CRecompiler::ResetRecompCode( bool bAllocate )
void CRecompiler::ResetRecompCode(bool bAllocate)
{
CRecompMemory::Reset();
CFunctionMap::Reset(bAllocate);
@ -709,17 +729,21 @@ void CRecompiler::ResetRecompCode( bool bAllocate )
void CRecompiler::RecompilerMain_ChangeMemory()
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
#ifdef tofix
DWORD Value, Addr;
BYTE * Block;
uint32_t Value, Addr;
uint8_t * Block;
while(!EndEmulation()) {
if (UseTlb) {
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) {
while(!EndEmulation())
{
if (UseTlb)
{
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr))
{
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
NextInstruction = NORMAL;
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) {
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr))
{
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
ExitThread(0);
}
@ -728,41 +752,51 @@ void CRecompiler::RecompilerMain_ChangeMemory()
Addr = PROGRAM_COUNTER & 0x1FFFFFFF;
}
if (NextInstruction == DELAY_SLOT) {
__try {
Value = (DWORD)(*(DelaySlotTable + (Addr >> 12)));
} __except(EXCEPTION_EXECUTE_HANDLER) {
if (NextInstruction == DELAY_SLOT)
{
__try
{
Value = (uint32_t)(*(DelaySlotTable + (Addr >> 12)));
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
g_Notify->DisplayError(L"Executing Delay Slot from non maped space\nPROGRAM_COUNTER = 0x%X",PROGRAM_COUNTER);
ExitThread(0);
}
if ( (Value >> 16) == 0x7C7C) {
DWORD Index = (Value & 0xFFFF);
Block = (BYTE *)OrigMem[Index].CompiledLocation;
if ( (Value >> 16) == 0x7C7C)
{
uint32_t Index = (Value & 0xFFFF);
Block = (uint8_t *)OrigMem[Index].CompiledLocation;
if (OrigMem[Index].PAddr != Addr) { Block = NULL; }
if (OrigMem[Index].VAddr != PROGRAM_COUNTER) { Block = NULL; }
if (Index >= TargetIndex) { Block = NULL; }
} else {
}
else
{
Block = NULL;
}
if (Block == NULL) {
DWORD MemValue;
if (Block == NULL)
{
uint32_t MemValue;
Block = CompileDelaySlot();
Value = 0x7C7C0000;
Value += (WORD)(TargetIndex);
MemValue = *(DWORD *)(RDRAM + Addr);
if ( (MemValue >> 16) == 0x7C7C) {
Value += (uint16_t)(TargetIndex);
MemValue = *(uint32_t *)(RDRAM + Addr);
if ( (MemValue >> 16) == 0x7C7C)
{
MemValue = OrigMem[(MemValue & 0xFFFF)].OriginalValue;
}
OrigMem[(WORD)(TargetIndex)].OriginalValue = MemValue;
OrigMem[(WORD)(TargetIndex)].CompiledLocation = Block;
OrigMem[(WORD)(TargetIndex)].PAddr = Addr;
OrigMem[(WORD)(TargetIndex)].VAddr = PROGRAM_COUNTER;
OrigMem[(uint16_t)(TargetIndex)].OriginalValue = MemValue;
OrigMem[(uint16_t)(TargetIndex)].CompiledLocation = Block;
OrigMem[(uint16_t)(TargetIndex)].PAddr = Addr;
OrigMem[(uint16_t)(TargetIndex)].VAddr = PROGRAM_COUNTER;
TargetIndex += 1;
*(DelaySlotTable + (Addr >> 12)) = (void *)Value;
NextInstruction = NORMAL;
}
_asm {
_asm
{
pushad
call Block
popad
@ -770,28 +804,38 @@ void CRecompiler::RecompilerMain_ChangeMemory()
continue;
}
__try {
Value = *(DWORD *)(RDRAM + Addr);
if ( (Value >> 16) == 0x7C7C) {
DWORD Index = (Value & 0xFFFF);
Block = (BYTE *)OrigMem[Index].CompiledLocation;
__try
{
Value = *(uint32_t *)(RDRAM + Addr);
if ( (Value >> 16) == 0x7C7C)
{
uint32_t Index = (Value & 0xFFFF);
Block = (uint8_t *)OrigMem[Index].CompiledLocation;
if (OrigMem[Index].PAddr != Addr) { Block = NULL; }
if (OrigMem[Index].VAddr != PROGRAM_COUNTER) { Block = NULL; }
if (Index >= TargetIndex) { Block = NULL; }
} else {
}
else
{
Block = NULL;
}
} __except(EXCEPTION_EXECUTE_HANDLER) {
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
g_Notify->DisplayError(GS(MSG_NONMAPPED_SPACE));
ExitThread(0);
}
if (Block == NULL) {
DWORD MemValue;
if (Block == NULL)
{
uint32_t MemValue;
__try {
__try
{
Block = Compiler4300iBlock();
} __except(EXCEPTION_EXECUTE_HANDLER) {
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
ResetRecompCode();
Block = Compiler4300iBlock();
}
@ -799,43 +843,49 @@ void CRecompiler::RecompilerMain_ChangeMemory()
{
continue;
}
if (TargetIndex == MaxOrigMem) {
if (TargetIndex == MaxOrigMem)
{
ResetRecompCode();
continue;
}
Value = 0x7C7C0000;
Value += (WORD)(TargetIndex);
MemValue = *(DWORD *)(RDRAM + Addr);
if ( (MemValue >> 16) == 0x7C7C) {
Value += (uint16_t)(TargetIndex);
MemValue = *(uint32_t *)(RDRAM + Addr);
if ( (MemValue >> 16) == 0x7C7C)
{
MemValue = OrigMem[(MemValue & 0xFFFF)].OriginalValue;
}
OrigMem[(WORD)(TargetIndex)].OriginalValue = MemValue;
OrigMem[(WORD)(TargetIndex)].CompiledLocation = Block;
OrigMem[(WORD)(TargetIndex)].PAddr = Addr;
OrigMem[(WORD)(TargetIndex)].VAddr = PROGRAM_COUNTER;
OrigMem[(uint16_t)(TargetIndex)].OriginalValue = MemValue;
OrigMem[(uint16_t)(TargetIndex)].CompiledLocation = Block;
OrigMem[(uint16_t)(TargetIndex)].PAddr = Addr;
OrigMem[(uint16_t)(TargetIndex)].VAddr = PROGRAM_COUNTER;
TargetIndex += 1;
*(DWORD *)(RDRAM + Addr) = Value;
*(uint32_t *)(RDRAM + Addr) = Value;
NextInstruction = NORMAL;
}
if (Profiling && IndvidualBlock) {
static DWORD ProfAddress = 0;
if (Profiling && IndvidualBlock)
{
static uint32_t ProfAddress = 0;
/*if ((PROGRAM_COUNTER & ~0xFFF) != ProfAddress) {
/*if ((PROGRAM_COUNTER & ~0xFFF) != ProfAddress)
{
char Label[100];
ProfAddress = PROGRAM_COUNTER & ~0xFFF;
sprintf(Label,"PC: %X to %X",ProfAddress,ProfAddress+ 0xFFC);
StartTimer(Label);
}*/
/*if (PROGRAM_COUNTER >= 0x800DD000 && PROGRAM_COUNTER <= 0x800DDFFC) {
/*if (PROGRAM_COUNTER >= 0x800DD000 && PROGRAM_COUNTER <= 0x800DDFFC)
{
char Label[100];
sprintf(Label,"PC: %X Block: %X",PROGRAM_COUNTER,Block);
StartTimer(Label);
}*/
// } else if ((Profiling || ShowCPUPer) && ProfilingLabel[0] == 0) {
// StartTimer("r4300i Running");
// } else if ((Profiling || ShowCPUPer) && ProfilingLabel[0] == 0) {
// StartTimer("r4300i Running");
}
_asm {
_asm
{
pushad
call Block
popad
@ -846,10 +896,10 @@ void CRecompiler::RecompilerMain_ChangeMemory()
CCompiledFunc * CRecompiler::CompilerCode()
{
DWORD pAddr = 0;
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER,(uint32_t &)pAddr))
uint32_t pAddr = 0;
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, pAddr))
{
WriteTraceF(TraceError,__FUNCTION__ ": Failed to translate %X",PROGRAM_COUNTER);
WriteTraceF(TraceError, __FUNCTION__ ": Failed to translate %X", PROGRAM_COUNTER);
return NULL;
}
@ -858,12 +908,12 @@ CCompiledFunc * CRecompiler::CompilerCode()
{
for (CCompiledFunc * Func = iter->second; Func != NULL; Func = Func->Next())
{
DWORD PAddr;
if (g_TransVaddr->TranslateVaddr(Func->MinPC(),(uint32_t &)PAddr))
uint32_t PAddr;
if (g_TransVaddr->TranslateVaddr(Func->MinPC(), PAddr))
{
MD5Digest Hash;
MD5(g_MMU->Rdram() + PAddr,(Func->MaxPC() - Func->MinPC())+ 4).get_digest(Hash);
if (memcmp(Hash.digest,Func->Hash().digest,sizeof(Hash.digest)) == 0)
MD5(g_MMU->Rdram() + PAddr, (Func->MaxPC() - Func->MinPC()) + 4).get_digest(Hash);
if (memcmp(Hash.digest, Func->Hash().digest, sizeof(Hash.digest)) == 0)
{
return Func;
}
@ -873,8 +923,8 @@ CCompiledFunc * CRecompiler::CompilerCode()
CheckRecompMem();
//DWORD StartTime = timeGetTime();
WriteTraceF(TraceRecompiler,__FUNCTION__ ": Compile Block-Start: Program Counter: %X pAddr: %X",PROGRAM_COUNTER,pAddr);
//uint32_t StartTime = timeGetTime();
WriteTraceF(TraceRecompiler, __FUNCTION__ ": Compile Block-Start: Program Counter: %X pAddr: %X", PROGRAM_COUNTER, pAddr);
CCodeBlock CodeBlock(PROGRAM_COUNTER, RecompPos());
if (!CodeBlock.Compile())
@ -888,7 +938,7 @@ CCompiledFunc * CRecompiler::CompilerCode()
}
CCompiledFunc * Func = new CCompiledFunc(CodeBlock);
CCompiledFuncList::_Pairib ret = m_Functions.insert(CCompiledFuncList::value_type(Func->EnterPC(),Func));
CCompiledFuncList::_Pairib ret = m_Functions.insert(CCompiledFuncList::value_type(Func->EnterPC(), Func));
if (ret.second == false)
{
Func->SetNext(ret.first->second->Next());
@ -898,21 +948,20 @@ CCompiledFunc * CRecompiler::CompilerCode()
return Func;
}
void CRecompiler::ClearRecompCode_Phys(DWORD Address, int length, REMOVE_REASON Reason )
void CRecompiler::ClearRecompCode_Phys(uint32_t Address, int length, REMOVE_REASON Reason)
{
if (g_System->LookUpMode() == FuncFind_VirtualLookup)
{
ClearRecompCode_Virt(Address + 0x80000000,length,Reason);
ClearRecompCode_Virt(Address + 0xA0000000,length,Reason);
ClearRecompCode_Virt(Address + 0x80000000, length, Reason);
ClearRecompCode_Virt(Address + 0xA0000000, length, Reason);
if (g_System->bUseTlb())
{
uint32_t VAddr, Index = 0;
while (g_TLB->PAddrToVAddr(Address,VAddr,Index))
while (g_TLB->PAddrToVAddr(Address, VAddr, Index))
{
WriteTraceF(TraceRecompiler,__FUNCTION__ ": ClearRecompCode Vaddr %X len: %d",VAddr,length);
ClearRecompCode_Virt(VAddr,length,Reason);
WriteTraceF(TraceRecompiler, __FUNCTION__ ": ClearRecompCode Vaddr %X len: %d", VAddr, length);
ClearRecompCode_Virt(VAddr, length, Reason);
}
}
}
@ -923,29 +972,31 @@ void CRecompiler::ClearRecompCode_Phys(DWORD Address, int length, REMOVE_REASON
int ClearLen = ((length + 3) & ~3);
if (Address + ClearLen > g_System->RdramSize())
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
ClearLen = g_System->RdramSize() - Address;
}
WriteTraceF(TraceRecompiler,__FUNCTION__ ": Reseting Jump Table, Addr: %X len: %d",Address,ClearLen);
memset((BYTE *)JumpTable() + Address,0,ClearLen);
WriteTraceF(TraceRecompiler, __FUNCTION__ ": Reseting Jump Table, Addr: %X len: %d", Address, ClearLen);
memset((uint8_t *)JumpTable() + Address, 0, ClearLen);
if (g_System->bSMM_Protect())
{
g_MMU->UnProtectMemory(Address + 0x80000000,Address + 0x80000004);
g_MMU->UnProtectMemory(Address + 0x80000000, Address + 0x80000004);
}
} else{
WriteTraceF(TraceRecompiler,__FUNCTION__ ": Ignoring reset of Jump Table, Addr: %X len: %d",Address,((length + 3) & ~3));
}
else
{
WriteTraceF(TraceRecompiler, __FUNCTION__ ": Ignoring reset of Jump Table, Addr: %X len: %d", Address, ((length + 3) & ~3));
}
}
}
void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON Reason )
void CRecompiler::ClearRecompCode_Virt(uint32_t Address, int length, REMOVE_REASON Reason)
{
switch (g_System->LookUpMode())
{
case FuncFind_VirtualLookup:
{
DWORD AddressIndex = Address >> 0xC;
DWORD WriteStart = (Address & 0xFFC);
uint32_t AddressIndex = Address >> 0xC;
uint32_t WriteStart = (Address & 0xFFC);
length = ((length + 3) & ~0x3);
int DataInBlock = 0x1000 - WriteStart;
@ -955,29 +1006,29 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
PCCompiledFunc_TABLE & table = FunctionTable()[AddressIndex];
if (table)
{
WriteTraceF(TraceError,__FUNCTION__ ": Delete Table (%X): Index = %d",table, AddressIndex);
WriteTraceF(TraceError, __FUNCTION__ ": Delete Table (%X): Index = %d", table, AddressIndex);
delete table;
table = NULL;
g_MMU->UnProtectMemory(Address,Address + length);
g_MMU->UnProtectMemory(Address, Address + length);
}
if (DataLeft > 0)
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
}
}
break;
case FuncFind_PhysicalLookup:
{
DWORD pAddr = 0;
if (g_TransVaddr->TranslateVaddr(Address,(uint32_t &)pAddr))
uint32_t pAddr = 0;
if (g_TransVaddr->TranslateVaddr(Address, pAddr))
{
ClearRecompCode_Phys(pAddr,length,Reason);
ClearRecompCode_Phys(pAddr, length, Reason);
}
}
break;
default:
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
}
}
@ -985,7 +1036,7 @@ void CRecompiler::ResetMemoryStackPos()
{
if (g_MMU == NULL)
{
g_Notify->BreakPoint(__FILEW__,__LINE__);
g_Notify->BreakPoint(__FILEW__, __LINE__);
return;
}
if (m_Registers.m_GPR[29].UW[0] == 0)
@ -994,12 +1045,14 @@ void CRecompiler::ResetMemoryStackPos()
return;
}
DWORD pAddr = 0;
if (g_TransVaddr->TranslateVaddr(m_Registers.m_GPR[29].UW[0],(uint32_t &)pAddr))
uint32_t pAddr = 0;
if (g_TransVaddr->TranslateVaddr(m_Registers.m_GPR[29].UW[0], pAddr))
{
m_MemoryStack = (DWORD)(g_MMU->Rdram() + pAddr);
} else {
WriteTraceF(TraceError,__FUNCTION__ ": Failed to translate SP address (%s)",m_Registers.m_GPR[29].UW[0]);
g_Notify->BreakPoint(__FILEW__,__LINE__);
m_MemoryStack = (uint32_t)(g_MMU->Rdram() + pAddr);
}
else
{
WriteTraceF(TraceError, __FUNCTION__ ": Failed to translate SP address (%s)", m_Registers.m_GPR[29].UW[0]);
g_Notify->BreakPoint(__FILEW__, __LINE__);
}
}

11
Source/Project64/N64 System/Recompiler/Recompiler Class.h
View File

@ -19,7 +19,8 @@ class CRecompiler :
{
public:
enum REMOVE_REASON {
enum REMOVE_REASON
{
Remove_InitialCode,
Remove_Cache,
Remove_ProtectedMem,
@ -40,12 +41,12 @@ public:
void ResetRecompCode(bool bAllocate);
//Self modifying code methods
void ClearRecompCode_Virt ( DWORD VirtualAddress, int length, REMOVE_REASON Reason );
void ClearRecompCode_Phys ( DWORD PhysicalAddress, int length, REMOVE_REASON Reason );
void ClearRecompCode_Virt ( uint32_t VirtualAddress, int32_t length, REMOVE_REASON Reason );
void ClearRecompCode_Phys ( uint32_t PhysicalAddress, int32_t length, REMOVE_REASON Reason );
void ResetMemoryStackPos();
DWORD& MemoryStackPos() { return m_MemoryStack; }
uint32_t& MemoryStackPos() { return m_MemoryStack; }
private:
CRecompiler(); // Disable default constructor
@ -67,7 +68,7 @@ private:
CRegisters & m_Registers;
CProfiling & m_Profile;
bool & m_EndEmulation;
DWORD m_MemoryStack;
uint32_t m_MemoryStack;
//Quick access to registers
uint32_t & PROGRAM_COUNTER;