thirdparty/ppsspp
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Some code reformatting/renaming

Browse source
This commit is contained in:
Henrik Rydgård 2020-07-04 20:30:33 +02:00
parent 8461ea19b1
commit 7208cf6900
2 changed files with 41 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

118
Core/MemMapFunctions.cpp
View file

@ -55,10 +55,6 @@ u8 *GetPointer(const u32 address) {
template <typename T>
inline void ReadFromHardware(T &var, const u32 address) {
// TODO: Figure out the fastest order of tests for both read and write (they are probably different).
// TODO: Make sure this represents the mirrors in a correct way.
// Could just do a base-relative read, too.... TODO
if ((address & 0x3E000000) == 0x08000000) {
// RAM
var = *((const T*)GetPointerUnchecked(address));
@ -84,8 +80,6 @@ inline void ReadFromHardware(T &var, const u32 address) {
template <typename T>
inline void WriteToHardware(u32 address, const T data) {
// Could just do a base-relative write, too.... TODO
if ((address & 0x3E000000) == 0x08000000) {
// RAM
*(T*)GetPointerUnchecked(address) = data;
@ -108,14 +102,12 @@ inline void WriteToHardware(u32 address, const T data) {
}
}
// =====================
bool IsRAMAddress(const u32 address) {
if ((address & 0x3E000000) == 0x08000000) {
return true;
} else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
} else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
return true;
} else {
} else {
return false;
}
}
@ -128,102 +120,52 @@ bool IsScratchpadAddress(const u32 address) {
return (address & 0xBFFF0000) == 0x00010000 && (address & 0x0000FFFF) < SCRATCHPAD_SIZE;
}
u8 Read_U8(const u32 _Address)
{
u8 _var = 0;
ReadFromHardware<u8>(_var, _Address);
return (u8)_var;
u8 Read_U8(const u32 address) {
u8 value = 0;
ReadFromHardware<u8>(value, address);
return (u8)value;
}
u16 Read_U16(const u32 _Address)
{
u16_le _var = 0;
ReadFromHardware<u16_le>(_var, _Address);
return (u16)_var;
u16 Read_U16(const u32 address) {
u16_le value = 0;
ReadFromHardware<u16_le>(value, address);
return (u16)value;
}
u32 Read_U32(const u32 _Address)
{
u32_le _var = 0;
ReadFromHardware<u32_le>(_var, _Address);
return _var;
u32 Read_U32(const u32 address) {
u32_le value = 0;
ReadFromHardware<u32_le>(value, address);
return value;
}
u64 Read_U64(const u32 _Address)
{
u64_le _var = 0;
ReadFromHardware<u64_le>(_var, _Address);
return _var;
u64 Read_U64(const u32 address) {
u64_le value = 0;
ReadFromHardware<u64_le>(value, address);
return value;
}
u32 Read_U8_ZX(const u32 _Address)
{
return (u32)Read_U8(_Address);
u32 Read_U8_ZX(const u32 address) {
return (u32)Read_U8(address);
}
u32 Read_U16_ZX(const u32 _Address)
{
return (u32)Read_U16(_Address);
u32 Read_U16_ZX(const u32 address) {
return (u32)Read_U16(address);
}
void Write_U8(const u8 _Data, const u32 _Address)
{
WriteToHardware<u8>(_Address, _Data);
void Write_U8(const u8 _Data, const u32 address) {
WriteToHardware<u8>(address, _Data);
}
void Write_U16(const u16 _Data, const u32 _Address)
{
WriteToHardware<u16_le>(_Address, _Data);
void Write_U16(const u16 _Data, const u32 address) {
WriteToHardware<u16_le>(address, _Data);
}
void Write_U32(const u32 _Data, const u32 _Address)
{
WriteToHardware<u32_le>(_Address, _Data);
void Write_U32(const u32 _Data, const u32 address) {
WriteToHardware<u32_le>(address, _Data);
}
void Write_U64(const u64 _Data, const u32 _Address)
{
WriteToHardware<u64_le>(_Address, _Data);
void Write_U64(const u64 _Data, const u32 address) {
WriteToHardware<u64_le>(address, _Data);
}
#ifdef SAFE_MEMORY
u8 ReadUnchecked_U8(const u32 _Address)
{
u8 _var = 0;
ReadFromHardware<u8>(_var, _Address);
return _var;
}
u16 ReadUnchecked_U16(const u32 _Address)
{
u16_le _var = 0;
ReadFromHardware<u16_le>(_var, _Address);
return _var;
}
u32 ReadUnchecked_U32(const u32 _Address)
{
u32_le _var = 0;
ReadFromHardware<u32_le>(_var, _Address);
return _var;
}
void WriteUnchecked_U8(const u8 _iValue, const u32 _Address)
{
WriteToHardware<u8>(_Address, _iValue);
}
void WriteUnchecked_U16(const u16 _iValue, const u32 _Address)
{
WriteToHardware<u16_le>(_Address, _iValue);
}
void WriteUnchecked_U32(const u32 _iValue, const u32 _Address)
{
WriteToHardware<u32_le>(_Address, _iValue);
}
#endif
} // namespace Memory