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

Core: make memory reads/write to go through new CMipsMemoryVM::MemoryPtr

This commit is contained in:
zilmar 2022-05-16 15:26:20 +09:30
parent 7fb67450a1
commit 1617e63b84
4 changed files with 66 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Source/Project64-core/N64System/Enhancement/Enhancements.cpp
View File

@ -468,29 +468,25 @@ void CEnhancements::ApplyGameSharkCodes(CMipsMemoryVM & MMU, CODES & CodeEntry,
ModifyMemory16(MMU, 0xA0000000 | (Code.Command() & 0xFFFFFF), Code.Value(), Code.HasDisableValue(), Code.DisableValue());
break;
case 0xD0000000:
MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory);
if (bMemory == Code.Value())
if (MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory) && bMemory == Code.Value())
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
break;
case 0xD1000000:
MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory);
if (wMemory == Code.Value())
if (MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory) && wMemory == Code.Value())
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
break;
case 0xD2000000:
MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory);
if (bMemory != Code.Value())
if (MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory) && bMemory != Code.Value())
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
break;
case 0xD3000000:
MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory);
if (wMemory != Code.Value())
if (MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory) && wMemory != Code.Value())
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
@ -514,16 +510,14 @@ void CEnhancements::ApplyGameSharkCodes(CMipsMemoryVM & MMU, CODES & CodeEntry,
break;
case 0xB8000000:
case 0xBA000000:
MMU.MemoryValue8(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), bMemory);
if (bMemory == ConvertXP64Value(Code.Value()))
if (MMU.MemoryValue8(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), bMemory) && bMemory == ConvertXP64Value(Code.Value()))
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
break;
case 0xB9000000:
case 0xBB000000:
MMU.MemoryValue16(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), wMemory);
if (wMemory == ConvertXP64Value(Code.Value()))
if (MMU.MemoryValue16(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), wMemory) && wMemory == ConvertXP64Value(Code.Value()))
{
ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
}
@ -585,12 +579,9 @@ void CEnhancements::ModifyMemory8(CMipsMemoryVM & MMU, uint32_t Address, uint8_t
{
OriginalValue.Original = DisableValue;
}
else
else if (!MMU.MemoryValue8(Address, OriginalValue.Original))
{
if (!MMU.MemoryValue8(Address, OriginalValue.Original))
{
return;
}
return;
}
if (OriginalValue.Original == Value)
{
@ -612,12 +603,9 @@ void CEnhancements::ModifyMemory16(CMipsMemoryVM & MMU, uint32_t Address, uint16
{
OriginalValue.Original = DisableValue;
}
else
else if (!MMU.MemoryValue16(Address, OriginalValue.Original))
{
if (!MMU.MemoryValue16(Address, OriginalValue.Original))
{
return;
}
return;
}
if (OriginalValue.Original == Value)
{

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

@ -267,178 +267,100 @@ void CMipsMemoryVM::FreeMemory()
CPifRam::Reset();
}
bool CMipsMemoryVM::MemoryValue8(uint32_t VAddr, uint8_t& Value)
uint8_t * CMipsMemoryVM::MemoryPtr(uint32_t VAddr, uint32_t size, bool Read)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
{
return false;
return nullptr;
}
uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 3;
if (PAddr < m_AllocatedRdramSize)
uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
if ((PAddr + size) < m_AllocatedRdramSize)
{
Value = *(uint8_t*)(m_RDRAM + PAddr);
return true;
return (uint8_t*)(m_RDRAM + PAddr);
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
if (PAddr >= 0x04000000 && (PAddr + size) < 0x04001000)
{
Value = *(uint8_t*)(m_DMEM + (PAddr - 0x04000000));
return true;
return (uint8_t*)(m_DMEM + (PAddr - 0x04000000));
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
if (PAddr >= 0x04001000 && (PAddr + size) < 0x04002000)
{
Value = *(uint8_t*)(m_IMEM + (PAddr - 0x04001000));
return true;
return (uint8_t*)(m_IMEM + (PAddr - 0x04001000));
}
if (Read && PAddr >= 0x10000000 && (PAddr + size) < (0x10000000 + m_Rom.GetRomSize()))
{
return (uint8_t *)&m_Rom.GetRomAddress()[PAddr - 0x10000000];
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
return nullptr;
}
bool CMipsMemoryVM::MemoryValue8(uint32_t VAddr, uint8_t & Value)
{
uint8_t * ptr = MemoryPtr(VAddr ^ 3, 1, true);
if (ptr == nullptr)
{
return false;
}
Value = *ptr;
return true;
}
bool CMipsMemoryVM::MemoryValue16(uint32_t VAddr, uint16_t& Value)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
uint8_t * ptr = MemoryPtr(VAddr ^ 2, 2, true);
if (ptr == nullptr)
{
return false;
}
uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 2;
if (PAddr < m_AllocatedRdramSize)
{
Value = *(uint16_t*)(m_RDRAM + PAddr);
return true;
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
{
Value = *(uint16_t*)(m_DMEM + (PAddr - 0x04000000));
return true;
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
{
Value = *(uint16_t*)(m_IMEM + (PAddr - 0x04001000));
return true;
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
Value = *(uint16_t*)(ptr);
return true;
}
bool CMipsMemoryVM::MemoryValue32(uint32_t VAddr, uint32_t& Value)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
uint8_t * ptr = MemoryPtr(VAddr, 4, true);
if (ptr == nullptr)
{
return false;
}
uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
if (PAddr < m_AllocatedRdramSize)
{
Value = *(uint32_t*)(m_RDRAM + PAddr);
return true;
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
{
Value = *(uint32_t*)(m_DMEM + (PAddr - 0x04000000));
return true;
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
{
Value = *(uint32_t*)(m_IMEM + (PAddr - 0x04001000));
return true;
}
if (PAddr >= 0x10000000 && PAddr < 0x16000000)
{
if ((PAddr & 0xFFFFFFF) < m_Rom.GetRomSize())
{
Value = *(uint32_t *)&m_Rom.GetRomAddress()[(PAddr & 0xFFFFFFF)];
}
else
{
Value = (PAddr << 16) | (PAddr & 0xFFFF);
}
return true;
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
Value = *(uint32_t*)(ptr);
return true;
}
bool CMipsMemoryVM::UpdateMemoryValue8(uint32_t VAddr, uint8_t Value)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
uint8_t * ptr = MemoryPtr(VAddr ^ 3, 1, false);
if (ptr == nullptr)
{
return false;
}
uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 3;
if (PAddr < m_AllocatedRdramSize)
{
*(uint8_t*)(m_RDRAM + PAddr) = Value;
return true;
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
{
*(uint8_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
return true;
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
{
*(uint8_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
return true;
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
*ptr = Value;
return true;
}
bool CMipsMemoryVM::UpdateMemoryValue16(uint32_t VAddr, uint16_t Value)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
uint8_t * ptr = MemoryPtr(VAddr ^ 2, 2, false);
if (ptr == nullptr)
{
return false;
}
uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 2;
if (PAddr < m_AllocatedRdramSize)
{
*(uint16_t*)(m_RDRAM + PAddr) = Value;
return true;
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
{
*(uint16_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
return true;
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
{
*(uint16_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
return true;
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
*(uint16_t*)(ptr) = Value;
return true;
}
bool CMipsMemoryVM::UpdateMemoryValue32(uint32_t VAddr, uint32_t Value)
{
if (m_TLB_ReadMap[VAddr >> 12] == -1)
uint8_t * ptr = MemoryPtr(VAddr, 4, false);
if (ptr == nullptr)
{
return false;
}
uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
if (PAddr < m_AllocatedRdramSize)
{
*(uint32_t*)(m_RDRAM + PAddr) = Value;
return true;
}
if (PAddr >= 0x04000000 && PAddr < 0x04001000)
{
*(uint32_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
return true;
}
if (PAddr >= 0x04001000 && PAddr < 0x04002000)
{
*(uint32_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
return true;
}
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
*(uint32_t*)(ptr) = Value;
return true;
}
bool CMipsMemoryVM::LB_Memory(uint32_t VAddr, uint8_t& Value)
@ -822,7 +744,7 @@ bool CMipsMemoryVM::SW_NonMemory(uint32_t VAddr, uint32_t Value)
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];
if (BaseAddress == -1)

2
Source/Project64-core/N64System/Mips/MemoryVirtualMem.h
View File

@ -73,6 +73,8 @@ public:
CSram & GetSram() { return m_CartridgeDomain2Address2Handler.Sram(); }
CFlashRam & GetFlashRam() { return m_CartridgeDomain2Address2Handler.FlashRam(); }
uint8_t * MemoryPtr(uint32_t VAddr, uint32_t size, bool Read);
bool MemoryValue8(uint32_t VAddr, uint8_t & Value);
bool MemoryValue16(uint32_t VAddr, uint16_t & Value);
bool MemoryValue32(uint32_t VAddr, uint32_t & Value);

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

@ -66,26 +66,17 @@ CCodeBlock::CCodeBlock(CMipsMemoryVM & MMU, uint32_t VAddrEnter, uint8_t * Compi
m_SectionMap.insert(SectionMap::value_type(VAddrEnter, m_EnterSection));
uint32_t PAddr;
if (!MMU.VAddrToPAddr(VAddrEnter, PAddr))
memset(m_MemLocation, 0, sizeof(m_MemLocation));
memset(m_MemContents, 0, sizeof(m_MemContents));
m_MemLocation[0] = (uint64_t *)MMU.MemoryPtr(VAddrEnter, 16, true);
if (m_MemLocation[0] != 0)
{
memset(m_MemLocation, 0, sizeof(m_MemLocation));
memset(m_MemContents, 0, sizeof(m_MemContents));
return;
}
if (PAddr + 16 < MMU.RdramSize())
{
m_MemLocation[0] = (uint64_t *)(MMU.Rdram() + PAddr);
m_MemLocation[1] = m_MemLocation[0] + 1;
m_MemContents[0] = *m_MemLocation[0];
m_MemContents[1] = *m_MemLocation[1];
AnalyseBlock();
}
else
{
memset(m_MemLocation, 0, sizeof(m_MemLocation));
memset(m_MemContents, 0, sizeof(m_MemContents));
return;
}
AnalyseBlock();
}
CCodeBlock::~CCodeBlock()