Core/MemMapFunctions.cpp

   1 // Copyright (C) 2003 Dolphin Project / 2012 PPSSPP Project
   2
   3 // This program is free software: you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation, version 2.0 or later versions.
   6
   7 // This program is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 // GNU General Public License 2.0 for more details.
  11
  12 // A copy of the GPL 2.0 should have been included with the program.
  13 // If not, see http://www.gnu.org/licenses/
  14
  15 // Official git repository and contact information can be found at
  16 // https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
  17
  18 #include "Common/Common.h"
  19 #include "Common/Atomics.h"
  20
  21 #include "Core/Core.h"
  22 #include "Core/MemMap.h"
  23 #include "Core/Config.h"
  24 #include "Core/Host.h"
  25 #include "Core/Reporting.h"
  26
  27 #include "Core/MIPS/MIPS.h"
  28
  29 namespace Memory
  30 {
  31
  32 // =================================
  33 // From Memmap.cpp
  34 // ----------------
  35
  36 // Read and write shortcuts
  37
  38 // GetPointer must always return an address in the bottom 32 bits of address space, so that 64-bit
  39 // programs don't have problems directly addressing any part of memory.
  40
  41 u8 *GetPointer(const u32 address)
  42 {
  43         if ((address & 0x3E000000) == 0x08000000) {
  44                 // RAM
  45                 return GetPointerUnchecked(address);
  46         } else if ((address & 0x3F800000) == 0x04000000) {
  47                 // VRAM
  48                 return GetPointerUnchecked(address);
  49         } else if ((address & 0xBFFF0000) == 0x00010000) {
  50                 // Scratchpad
  51                 return GetPointerUnchecked(address);
  52         } else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
  53                 // More RAM (remasters, etc.)
  54                 return GetPointerUnchecked(address);
  55         } else {
  56                 ERROR_LOG(MEMMAP, "Unknown GetPointer %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
  57                 static bool reported = false;
  58                 if (!reported) {
  59                         Reporting::ReportMessage("Unknown GetPointer %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
  60                         reported = true;
  61                 }
  62                 if (!g_Config.bIgnoreBadMemAccess) {
  63                         Core_EnableStepping(true);
  64                         host->SetDebugMode(true);
  65                 }
  66                 return 0;
  67         }
  68 }
  69
  70 template <typename T>
  71 inline void ReadFromHardware(T &var, const u32 address)
  72 {
  73         // TODO: Figure out the fastest order of tests for both read and write (they are probably different).
  74         // TODO: Make sure this represents the mirrors in a correct way.
  75
  76         // Could just do a base-relative read, too.... TODO
  77
  78         if ((address & 0x3E000000) == 0x08000000) {
  79                 // RAM
  80                 var = *((const T*)GetPointerUnchecked(address));
  81         } else if ((address & 0x3F800000) == 0x04000000) {
  82                 // VRAM
  83                 var = *((const T*)GetPointerUnchecked(address));
  84         } else if ((address & 0xBFFF0000) == 0x00010000) {
  85                 // Scratchpad
  86                 var = *((const T*)GetPointerUnchecked(address));
  87         } else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
  88                 // More RAM (remasters, etc.)
  89                 var = *((const T*)GetPointerUnchecked(address));
  90         } else {
  91                 // In jit, we only flush PC when bIgnoreBadMemAccess is off.
  92                 if (g_Config.bJit && g_Config.bIgnoreBadMemAccess) {
  93                         WARN_LOG(MEMMAP, "ReadFromHardware: Invalid address %08x", address);
  94                 } else {
  95                         WARN_LOG(MEMMAP, "ReadFromHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
  96                 }
  97                 static bool reported = false;
  98                 if (!reported) {
  99                         Reporting::ReportMessage("ReadFromHardware: Invalid address %08x near PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
 100                         reported = true;
 101                 }
 102                 if (!g_Config.bIgnoreBadMemAccess) {
 103                         Core_EnableStepping(true);
 104                         host->SetDebugMode(true);
 105                 }
 106                 var = 0;
 107         }
 108 }
 109
 110 template <typename T>
 111 inline void WriteToHardware(u32 address, const T data)
 112 {
 113         // Could just do a base-relative write, too.... TODO
 114
 115         if ((address & 0x3E000000) == 0x08000000) {
 116                 // RAM
 117                 *(T*)GetPointerUnchecked(address) = data;
 118         } else if ((address & 0x3F800000) == 0x04000000) {
 119                 // VRAM
 120                 *(T*)GetPointerUnchecked(address) = data;
 121         } else if ((address & 0xBFFF0000) == 0x00010000) {
 122                 // Scratchpad
 123                 *(T*)GetPointerUnchecked(address) = data;
 124         } else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
 125                 // More RAM (remasters, etc.)
 126                 *(T*)GetPointerUnchecked(address) = data;
 127         } else {
 128                 // In jit, we only flush PC when bIgnoreBadMemAccess is off.
 129                 if (g_Config.bJit && g_Config.bIgnoreBadMemAccess) {
 130                         WARN_LOG(MEMMAP, "WriteToHardware: Invalid address %08x", address);
 131                 } else {
 132                         WARN_LOG(MEMMAP, "WriteToHardware: Invalid address %08x PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
 133                 }
 134                 static bool reported = false;
 135                 if (!reported) {
 136                         Reporting::ReportMessage("WriteToHardware: Invalid address %08x near PC %08x LR %08x", address, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
 137                         reported = true;
 138                 }
 139                 if (!g_Config.bIgnoreBadMemAccess) {
 140                         Core_EnableStepping(true);
 141                         host->SetDebugMode(true);
 142                 }
 143         }
 144 }
 145
 146 // =====================
 147
 148 bool IsRAMAddress(const u32 address) {
 149         if ((address & 0x3E000000) == 0x08000000) {
 150                 return true;
 151         }       else if ((address & 0x3F000000) >= 0x08000000 && (address & 0x3F000000) < 0x08000000 + g_MemorySize) {
 152                 return true;
 153         }       else {
 154                 return false;
 155         }
 156 }
 157
 158 bool IsVRAMAddress(const u32 address) {
 159         return ((address & 0x3F800000) == 0x04000000);
 160 }
 161
 162 bool IsScratchpadAddress(const u32 address) {
 163         return (address & 0xBFFF0000) == 0x00010000;
 164 }
 165
 166 u8 Read_U8(const u32 _Address)
 167 {
 168         u8 _var = 0;
 169         ReadFromHardware<u8>(_var, _Address);
 170         return (u8)_var;
 171 }
 172
 173 u16 Read_U16(const u32 _Address)
 174 {
 175         u16_le _var = 0;
 176         ReadFromHardware<u16_le>(_var, _Address);
 177         return (u16)_var;
 178 }
 179
 180 u32 Read_U32(const u32 _Address)
 181 {
 182         u32_le _var = 0;
 183         ReadFromHardware<u32_le>(_var, _Address);
 184         return _var;
 185 }
 186
 187 u64 Read_U64(const u32 _Address)
 188 {
 189         u64_le _var = 0;
 190         ReadFromHardware<u64_le>(_var, _Address);
 191         return _var;
 192 }
 193
 194 u32 Read_U8_ZX(const u32 _Address)
 195 {
 196         return (u32)Read_U8(_Address);
 197 }
 198
 199 u32 Read_U16_ZX(const u32 _Address)
 200 {
 201         return (u32)Read_U16(_Address);
 202 }
 203
 204 void Write_U8(const u8 _Data, const u32 _Address)
 205 {
 206         WriteToHardware<u8>(_Address, _Data);
 207 }
 208
 209 void Write_U16(const u16 _Data, const u32 _Address)
 210 {
 211         WriteToHardware<u16_le>(_Address, _Data);
 212 }
 213
 214 void Write_U32(const u32 _Data, const u32 _Address)
 215 {
 216         WriteToHardware<u32_le>(_Address, _Data);
 217 }
 218
 219 void Write_U64(const u64 _Data, const u32 _Address)
 220 {
 221         WriteToHardware<u64_le>(_Address, _Data);
 222 }
 223
 224 #ifdef SAFE_MEMORY
 225
 226 u8 ReadUnchecked_U8(const u32 _Address)
 227 {
 228         u8 _var = 0;
 229         ReadFromHardware<u8>(_var, _Address);
 230         return _var;
 231 }
 232
 233 u16 ReadUnchecked_U16(const u32 _Address)
 234 {
 235         u16_le _var = 0;
 236         ReadFromHardware<u16_le>(_var, _Address);
 237         return _var;
 238 }
 239
 240 u32 ReadUnchecked_U32(const u32 _Address)
 241 {
 242         u32_le _var = 0;
 243         ReadFromHardware<u32_le>(_var, _Address);
 244         return _var;
 245 }
 246
 247 void WriteUnchecked_U8(const u8 _iValue, const u32 _Address)
 248 {
 249         WriteToHardware<u8>(_Address, _iValue);
 250 }
 251
 252 void WriteUnchecked_U16(const u16 _iValue, const u32 _Address)
 253 {
 254         WriteToHardware<u16_le>(_Address, _iValue);
 255 }
 256
 257 void WriteUnchecked_U32(const u32 _iValue, const u32 _Address)
 258 {
 259         WriteToHardware<u32_le>(_Address, _iValue);
 260 }
 261
 262 #endif
 263
 264 }       // namespace Memory