Emulator-Archive/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-02-05 13:06:52 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
Core/MemMap.h
View File

@ -52,8 +52,7 @@ typedef void (*readFn16)(u16&, const u32);
typedef void (*readFn32)(u32&, const u32);
typedef void (*readFn64)(u64&, const u32);
namespace Memory
{
namespace Memory {
// Base is a pointer to the base of the memory map. Yes, some MMU tricks
// are used to set up a full GC or Wii memory map in process memory. on
// 32-bit, you have to mask your offsets with 0x3FFFFFFF. This means that
@ -165,16 +164,6 @@ inline u8* GetPointerUnchecked(const u32 address) {
#endif
}
#ifdef SAFE_MEMORY
u32 ReadUnchecked_U32(const u32 _Address);
// ONLY for use by GUI and fast interpreter
u8 ReadUnchecked_U8(const u32 _Address);
u16 ReadUnchecked_U16(const u32 _Address);
void WriteUnchecked_U8(const u8 _Data, const u32 _Address);
void WriteUnchecked_U16(const u16 _Data, const u32 _Address);
void WriteUnchecked_U32(const u32 _Data, const u32 _Address);
#else
inline u32 ReadUnchecked_U32(const u32 address) {
#ifdef MASKED_PSP_MEMORY
return *(u32_le *)(base + (address & MEMVIEW32_MASK));
@ -239,8 +228,6 @@ inline void WriteUnchecked_U8(u8 data, u32 address) {
#endif
}
#endif
inline float Read_Float(u32 address)
{
u32 ifloat = Read_U32(address);
@ -274,18 +261,15 @@ inline const char* GetCharPointer(const u32 address) {
return (const char *)GetPointer(address);
}
inline void MemcpyUnchecked(void *to_data, const u32 from_address, const u32 len)
{
inline void MemcpyUnchecked(void *to_data, const u32 from_address, const u32 len) {
memcpy(to_data, GetPointerUnchecked(from_address), len);
}
inline void MemcpyUnchecked(const u32 to_address, const void *from_data, const u32 len)
{
inline void MemcpyUnchecked(const u32 to_address, const void *from_data, const u32 len) {
memcpy(GetPointerUnchecked(to_address), from_data, len);
}
inline void MemcpyUnchecked(const u32 to_address, const u32 from_address, const u32 len)
{
inline void MemcpyUnchecked(const u32 to_address, const u32 from_address, const u32 len) {
MemcpyUnchecked(GetPointer(to_address), from_address, len);
}
@ -327,7 +311,7 @@ inline bool IsValidRange(const u32 address, const u32 size) {
return IsValidAddress(address) && ValidSize(address, size) == size;
}
};
} // namespace Memory
template <typename T>
struct PSPPointer
@ -462,44 +446,36 @@ inline u32 PSP_GetKernelMemoryEnd() { return 0x08400000;}
// game through sceKernelVolatileMemTryLock.
inline u32 PSP_GetUserMemoryBase() { return 0x08800000;}
inline u32 PSP_GetDefaultLoadAddress() { return 0;}
//inline u32 PSP_GetDefaultLoadAddress() { return 0x0898dab0;}
inline u32 PSP_GetVidMemBase() { return 0x04000000;}
inline u32 PSP_GetVidMemEnd() { return 0x04800000;}
template <typename T>
inline bool operator==(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator==(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr == rhs.ptr;
}
template <typename T>
inline bool operator!=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator!=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr != rhs.ptr;
}
template <typename T>
inline bool operator<(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator<(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr < rhs.ptr;
}
template <typename T>
inline bool operator>(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator>(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr > rhs.ptr;
}
template <typename T>
inline bool operator<=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator<=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr <= rhs.ptr;
}
template <typename T>
inline bool operator>=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs)
{
inline bool operator>=(const PSPPointer<T> &lhs, const PSPPointer<T> &rhs) {
return lhs.ptr >= rhs.ptr;
}

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