From 7208cf6900c6505f27fd1d51b500976848b17c7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sat, 4 Jul 2020 20:30:33 +0200 Subject: [PATCH] Some code reformatting/renaming --- Core/MemMap.h | 46 ++++----------- Core/MemMapFunctions.cpp | 118 ++++++++++----------------------------- 2 files changed, 41 insertions(+), 123 deletions(-) diff --git a/Core/MemMap.h b/Core/MemMap.h index 28c635c181..4f598961f3 100644 --- a/Core/MemMap.h +++ b/Core/MemMap.h @@ -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 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 -inline bool operator==(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator==(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr == rhs.ptr; } template -inline bool operator!=(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator!=(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr != rhs.ptr; } template -inline bool operator<(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator<(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr < rhs.ptr; } template -inline bool operator>(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator>(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr > rhs.ptr; } template -inline bool operator<=(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator<=(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr <= rhs.ptr; } template -inline bool operator>=(const PSPPointer &lhs, const PSPPointer &rhs) -{ +inline bool operator>=(const PSPPointer &lhs, const PSPPointer &rhs) { return lhs.ptr >= rhs.ptr; } diff --git a/Core/MemMapFunctions.cpp b/Core/MemMapFunctions.cpp index 4c00281840..07f912b198 100644 --- a/Core/MemMapFunctions.cpp +++ b/Core/MemMapFunctions.cpp @@ -55,10 +55,6 @@ u8 *GetPointer(const u32 address) { template 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 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(_var, _Address); - return (u8)_var; +u8 Read_U8(const u32 address) { + u8 value = 0; + ReadFromHardware(value, address); + return (u8)value; } -u16 Read_U16(const u32 _Address) -{ - u16_le _var = 0; - ReadFromHardware(_var, _Address); - return (u16)_var; +u16 Read_U16(const u32 address) { + u16_le value = 0; + ReadFromHardware(value, address); + return (u16)value; } -u32 Read_U32(const u32 _Address) -{ - u32_le _var = 0; - ReadFromHardware(_var, _Address); - return _var; +u32 Read_U32(const u32 address) { + u32_le value = 0; + ReadFromHardware(value, address); + return value; } -u64 Read_U64(const u32 _Address) -{ - u64_le _var = 0; - ReadFromHardware(_var, _Address); - return _var; +u64 Read_U64(const u32 address) { + u64_le value = 0; + ReadFromHardware(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(_Address, _Data); +void Write_U8(const u8 _Data, const u32 address) { + WriteToHardware(address, _Data); } -void Write_U16(const u16 _Data, const u32 _Address) -{ - WriteToHardware(_Address, _Data); +void Write_U16(const u16 _Data, const u32 address) { + WriteToHardware(address, _Data); } -void Write_U32(const u32 _Data, const u32 _Address) -{ - WriteToHardware(_Address, _Data); +void Write_U32(const u32 _Data, const u32 address) { + WriteToHardware(address, _Data); } -void Write_U64(const u64 _Data, const u32 _Address) -{ - WriteToHardware(_Address, _Data); +void Write_U64(const u64 _Data, const u32 address) { + WriteToHardware(address, _Data); } -#ifdef SAFE_MEMORY - -u8 ReadUnchecked_U8(const u32 _Address) -{ - u8 _var = 0; - ReadFromHardware(_var, _Address); - return _var; -} - -u16 ReadUnchecked_U16(const u32 _Address) -{ - u16_le _var = 0; - ReadFromHardware(_var, _Address); - return _var; -} - -u32 ReadUnchecked_U32(const u32 _Address) -{ - u32_le _var = 0; - ReadFromHardware(_var, _Address); - return _var; -} - -void WriteUnchecked_U8(const u8 _iValue, const u32 _Address) -{ - WriteToHardware(_Address, _iValue); -} - -void WriteUnchecked_U16(const u16 _iValue, const u32 _Address) -{ - WriteToHardware(_Address, _iValue); -} - -void WriteUnchecked_U32(const u32 _iValue, const u32 _Address) -{ - WriteToHardware(_Address, _iValue); -} - -#endif - } // namespace Memory