-converted tabs to spaces

-moved scratchpad memory out of MemArena

2 files changed, 145 insertions, 149 deletions

diff --git a/src/core/src/mem_map.cpp b/src/core/src/mem_map.cpp
index 975a0cf08..6477499d5 100644
--- a/src/core/src/mem_map.cpp
+++ b/src/core/src/mem_map.cpp
@@ -32,75 +32,72 @@
 
 namespace Memory {
 
-        
-u8*     g_base                  = NULL;         ///< The base pointer to the auto-mirrored arena.
-
-MemArena g_arena;                               ///< The MemArena class
+    
+u8*    g_base                   = NULL;         ///< The base pointer to the auto-mirrored arena.
 
-u8* g_bootrom                       = NULL;     ///< Bootrom memory (super secret code/data @ 0x8000) pointer
-u8* g_fcram                                 = NULL;         ///< Main memory (FCRAM) pointer
-u8* g_vram                                  = NULL;         ///< Video memory (VRAM) pointer
-u8* g_scratchpad            = NULL;     ///< [Hack] Seperate mem for stack space because I don't know where this goes
+MemArena g_arena;                               ///< The MemArena class
 
-u8* g_physical_bootrom      = NULL;         ///< Bootrom physical memory (super secret code/data @ 0x8000)
-u8* g_uncached_bootrom      = NULL;
+u8* g_bootrom                   = NULL;         ///< Bootrom physical memory
+u8* g_fcram                     = NULL;         ///< Main memory (FCRAM) pointer
+u8* g_vram                      = NULL;         ///< Video memory (VRAM) pointer
+u8* g_scratchpad                = NULL;         ///< Scratchpad memory - Used for main thread stack
 
-u8* g_physical_fcram        = NULL;         ///< Main physical memory (FCRAM)
-u8* g_physical_vram                 = NULL;         ///< Video physical memory (VRAM)
-u8* g_physical_scratchpad   = NULL;     ///< Scratchpad memory used for main thread stack
+u8* g_physical_bootrom          = NULL;         ///< Bootrom physical memory
+u8* g_uncached_bootrom          = NULL;
 
+u8* g_physical_fcram            = NULL;         ///< Main physical memory (FCRAM)
+u8* g_physical_vram             = NULL;         ///< Video physical memory (VRAM)
+u8* g_physical_scratchpad       = NULL;         ///< Scratchpad memory used for main thread stack
 
 // We don't declare the IO region in here since its handled by other means.
-static MemoryView g_views[] =
-{
-    {&g_scratchpad, &g_physical_scratchpad, 0x00000000,             MEM_SCRATCHPAD_SIZE,    0 },
-//  {&g_bootrom,        &g_physical_bootrom,    0x00000000,             MEM_BOOTROM_SIZE,               0},
-//  {NULL,                      &g_uncached_bootrom,    0x00010000,             MEM_BOOTROM_SIZE,               MV_MIRROR_PREVIOUS},
-//      {NULL,                          NULL,                                   0x17E00000, MEM_MPCORE_PRIV_SIZE,       0},
-        {&g_vram,               &g_physical_vram,               MEM_VRAM_VADDR,          MEM_VRAM_SIZE,                 MV_IS_PRIMARY_RAM},
-//      {NULL,                          NULL,                                   0x1FF00000, MEM_DSP_SIZE,                       0},
-//      {NULL,                          NULL,                                   0x1FF80000, MEM_AXI_WRAM_SIZE,          0},
-   
-        {&g_fcram,              &g_physical_fcram,              MEM_FCRAM_VADDR,        MEM_FCRAM_SIZE,                 MV_IS_PRIMARY_RAM},
-    
+static MemoryView g_views[] = {
+    { &g_vram,  &g_physical_vram,   MEM_VRAM_VADDR,     MEM_VRAM_SIZE,  0 },
+    { &g_fcram, &g_physical_fcram,  MEM_FCRAM_VADDR,    MEM_FCRAM_SIZE, MV_IS_PRIMARY_RAM },
 };
 
 /*static MemoryView views[] =
 {
-        {&m_pScratchPad, &m_pPhysicalScratchPad,  0x00010000, SCRATCHPAD_SIZE, 0},
-        {NULL,           &m_pUncachedScratchPad,  0x40010000, SCRATCHPAD_SIZE, MV_MIRROR_PREVIOUS},
-        {&m_pVRAM,       &m_pPhysicalVRAM,        0x04000000, 0x00800000, 0},
-        {NULL,           &m_pUncachedVRAM,        0x44000000, 0x00800000, MV_MIRROR_PREVIOUS},
-        {&m_pRAM,        &m_pPhysicalRAM,         0x08000000, g_MemorySize, MV_IS_PRIMARY_RAM}, // only from 0x08800000 is it usable (last 24 megs)
-        {NULL,           &m_pUncachedRAM,         0x48000000, g_MemorySize, MV_MIRROR_PREVIOUS | MV_IS_PRIMARY_RAM},
-        {NULL,           &m_pKernelRAM,           0x88000000, g_MemorySize, MV_MIRROR_PREVIOUS | MV_IS_PRIMARY_RAM},
-
-        // TODO: There are a few swizzled mirrors of VRAM, not sure about the best way to
-        // implement those.
+    {&m_pScratchPad, &m_pPhysicalScratchPad,  0x00010000, SCRATCHPAD_SIZE, 0},
+    {NULL,           &m_pUncachedScratchPad,  0x40010000, SCRATCHPAD_SIZE, MV_MIRROR_PREVIOUS},
+    {&m_pVRAM,       &m_pPhysicalVRAM,        0x04000000, 0x00800000, 0},
+    {NULL,           &m_pUncachedVRAM,        0x44000000, 0x00800000, MV_MIRROR_PREVIOUS},
+    {&m_pRAM,        &m_pPhysicalRAM,         0x08000000, g_MemorySize, MV_IS_PRIMARY_RAM},    // only from 0x08800000 is it usable (last 24 megs)
+    {NULL,           &m_pUncachedRAM,         0x48000000, g_MemorySize, MV_MIRROR_PREVIOUS | MV_IS_PRIMARY_RAM},
+    {NULL,           &m_pKernelRAM,           0x88000000, g_MemorySize, MV_MIRROR_PREVIOUS | MV_IS_PRIMARY_RAM},
+
+    // TODO: There are a few swizzled mirrors of VRAM, not sure about the best way to
+    // implement those.
 };*/
 
-static const int kNumMemViews = sizeof(g_views) / sizeof(MemoryView);   ///< Number of mem views
+static const int kNumMemViews = sizeof(g_views) / sizeof(MemoryView);    ///< Number of mem views
 
 void Init() {
-        int flags = 0;
+    int flags = 0;
 
-        for (size_t i = 0; i < ARRAY_SIZE(g_views); i++) {
-                if (g_views[i].flags & MV_IS_PRIMARY_RAM)
-                        g_views[i].size = MEM_FCRAM_SIZE;
-        }
+    for (size_t i = 0; i < ARRAY_SIZE(g_views); i++) {
+        if (g_views[i].flags & MV_IS_PRIMARY_RAM)
+            g_views[i].size = MEM_FCRAM_SIZE;
+    }
 
-        g_base = MemoryMap_Setup(g_views, kNumMemViews, flags, &g_arena);
+    g_base = MemoryMap_Setup(g_views, kNumMemViews, flags, &g_arena);
 
-        NOTICE_LOG(MEMMAP, "Memory system initialized. RAM at %p (mirror at 0 @ %p)", g_fcram, 
-                g_physical_fcram);
+    g_scratchpad = new u8[MEM_SCRATCHPAD_SIZE];
+
+    NOTICE_LOG(MEMMAP, "Memory system initialized. RAM at %p (mirror at 0 @ %p)", g_fcram, 
+        g_physical_fcram);
 }
 
 void Shutdown() {
-        u32 flags = 0;
-        MemoryMap_Shutdown(g_views, kNumMemViews, flags, &g_arena);
-        g_arena.ReleaseSpace();
-        g_base = NULL;
-        NOTICE_LOG(MEMMAP, "Memory system shut down.");
+    u32 flags = 0;
+    MemoryMap_Shutdown(g_views, kNumMemViews, flags, &g_arena);
+    
+    g_arena.ReleaseSpace();
+    delete[] g_scratchpad;
+    
+    g_base          = NULL;
+    g_scratchpad    = NULL;
+
+    NOTICE_LOG(MEMMAP, "Memory system shut down.");
 }
 
 
diff --git a/src/core/src/mem_map_funcs.cpp b/src/core/src/mem_map_funcs.cpp
index c8436b2a4..0d22d9193 100644
--- a/src/core/src/mem_map_funcs.cpp
+++ b/src/core/src/mem_map_funcs.cpp
@@ -29,157 +29,156 @@
 namespace Memory {
 
 template <typename T>
-inline void ReadFromHardware(T &var, const u32 addr)
-{
-        // 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.
+inline void ReadFromHardware(T &var, const u32 addr) {
+    // 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
+    // Could just do a base-relative read, too.... TODO
 
-        if ((addr & 0x3E000000) == 0x08000000) {
-                var = *((const T*)&g_fcram[addr & MEM_FCRAM_MASK]);
+    if ((addr & 0x3E000000) == 0x08000000) {
+        var = *((const T*)&g_fcram[addr & MEM_FCRAM_MASK]);
 
-        // Scratchpad memory
+    // Scratchpad memory
     } else if (addr > MEM_SCRATCHPAD_VADDR && addr <= (MEM_SCRATCHPAD_VADDR + MEM_SCRATCHPAD_SIZE)) {
         var = *((const T*)&g_scratchpad[addr & MEM_SCRATCHPAD_MASK]);
     }
-        /*else if ((addr & 0x3F800000) == 0x04000000) {
-                var = *((const T*)&m_pVRAM[addr & VRAM_MASK]);
-        }*/
-        else {
-                _assert_msg_(MEMMAP, false, "unknown hardware read");
-                // WARN_LOG(MEMMAP, "ReadFromHardware: Invalid addr %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
-        }
+    /*else if ((addr & 0x3F800000) == 0x04000000) {
+        var = *((const T*)&m_pVRAM[addr & VRAM_MASK]);
+    }*/
+    else {
+        _assert_msg_(MEMMAP, false, "unknown hardware read");
+        // WARN_LOG(MEMMAP, "ReadFromHardware: Invalid addr %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
+    }
 }
 
 template <typename T>
 inline void WriteToHardware(u32 addr, const T data) {
-        NOTICE_LOG(MEMMAP, "Test1 %08X", addr);
-        // ExeFS:/.code is loaded here:
-        if ((addr & 0xFFF00000) == 0x00100000) {
-                // TODO(ShizZy): This is dumb... handle correctly. From 3DBrew:
-                // http://3dbrew.org/wiki/Memory_layout#ARM11_User-land_memory_regions
-                // The ExeFS:/.code is loaded here, executables must be loaded to the 0x00100000 region when
-                // the exheader "special memory" flag is clear. The 0x03F00000-byte size restriction only 
-                // applies when this flag is clear. Executables are usually loaded to 0x14000000 when the 
-                // exheader "special memory" flag is set, however this address can be arbitrary.
-                *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
-                NOTICE_LOG(MEMMAP, "Test2");
+    NOTICE_LOG(MEMMAP, "Test1 %08X", addr);
+    // ExeFS:/.code is loaded here:
+    if ((addr & 0xFFF00000) == 0x00100000) {
+        // TODO(ShizZy): This is dumb... handle correctly. From 3DBrew:
+        // http://3dbrew.org/wiki/Memory_layout#ARM11_User-land_memory_regions
+        // The ExeFS:/.code is loaded here, executables must be loaded to the 0x00100000 region when
+        // the exheader "special memory" flag is clear. The 0x03F00000-byte size restriction only 
+        // applies when this flag is clear. Executables are usually loaded to 0x14000000 when the 
+        // exheader "special memory" flag is set, however this address can be arbitrary.
+        *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
+        NOTICE_LOG(MEMMAP, "Test2");
 
     // Scratchpad memory
     } else if (addr > MEM_SCRATCHPAD_VADDR && addr <= (MEM_SCRATCHPAD_VADDR + MEM_SCRATCHPAD_SIZE)) {
         *(T*)&g_scratchpad[addr & MEM_SCRATCHPAD_MASK] = data;
 
-        // Heap mapped by ControlMemory:
-        } else if ((addr & 0x3E000000) == 0x08000000) {
-                // TODO(ShizZy): Writes to this virtual address should be put in physical memory at FCRAM + GSP
-                // heap size... the following is writing to FCRAM + 0, which is actually supposed to be the 
-                // application's GSP heap
-                *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
-        } else if ((addr & 0xFF000000) == 0x14000000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to GSP heap");
-        } else if ((addr & 0xFFF00000) == 0x1EC00000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to IO registers");
-        } else if ((addr & 0xFF000000) == 0x1F000000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to VRAM");
-        } else if ((addr & 0xFFF00000) == 0x1FF00000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to DSP memory");
-        } else if ((addr & 0xFFFF0000) == 0x1FF80000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to Configuration Memory");
-        } else if ((addr & 0xFFFFF000) == 0x1FF81000) {
-                _assert_msg_(MEMMAP, false, "umimplemented write to shared page");
-        } else {
-                _assert_msg_(MEMMAP, false, "unknown hardware write");
-        }
+    // Heap mapped by ControlMemory:
+    } else if ((addr & 0x3E000000) == 0x08000000) {
+        // TODO(ShizZy): Writes to this virtual address should be put in physical memory at FCRAM + GSP
+        // heap size... the following is writing to FCRAM + 0, which is actually supposed to be the 
+        // application's GSP heap
+        *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
+    } else if ((addr & 0xFF000000) == 0x14000000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to GSP heap");
+    } else if ((addr & 0xFFF00000) == 0x1EC00000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to IO registers");
+    } else if ((addr & 0xFF000000) == 0x1F000000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to VRAM");
+    } else if ((addr & 0xFFF00000) == 0x1FF00000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to DSP memory");
+    } else if ((addr & 0xFFFF0000) == 0x1FF80000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to Configuration Memory");
+    } else if ((addr & 0xFFFFF000) == 0x1FF81000) {
+        _assert_msg_(MEMMAP, false, "umimplemented write to shared page");
+    } else {
+        _assert_msg_(MEMMAP, false, "unknown hardware write");
+    }
 }
 
 bool IsValidAddress(const u32 addr) {
-        if ((addr & 0x3E000000) == 0x08000000) {
-                return true;
-        } else if ((addr & 0x3F800000) == 0x04000000) {
-                return true;
-        } else if ((addr & 0xBFFF0000) == 0x00010000) {
-                return true;
-        } else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + MEM_FCRAM_MASK) {
-                return true;
-        } else {
-                return false;
-        }
+    if ((addr & 0x3E000000) == 0x08000000) {
+        return true;
+    } else if ((addr & 0x3F800000) == 0x04000000) {
+        return true;
+    } else if ((addr & 0xBFFF0000) == 0x00010000) {
+        return true;
+    } else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + MEM_FCRAM_MASK) {
+        return true;
+    } else {
+        return false;
+    }
 }
 
 u8 *GetPointer(const u32 addr) {
-        // TODO(bunnei): Just a stub for now... ImplementMe!
-        if ((addr & 0x3E000000) == 0x08000000) {
-                return g_fcram + (addr & MEM_FCRAM_MASK);
-        }
-        //else if ((addr & 0x3F800000) == 0x04000000) {
-        //      return g_vram + (addr & MEM_VRAM_MASK);
-        //}
-        //else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + g_MemorySize) {
-        //      return m_pRAM + (addr & g_MemoryMask);
-        //}
-        else {
-                //ERROR_LOG(MEMMAP, "Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
-                ERROR_LOG(MEMMAP, "Unknown GetPointer %08x", addr);
-                static bool reported = false;
-                //if (!reported) {
-                //      Reporting::ReportMessage("Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
-                //      reported = true;
-                //}
-                //if (!g_Config.bIgnoreBadMemAccess) {
-                //      Core_EnableStepping(true);
-                //      host->SetDebugMode(true);
-                //}
-                return 0;
-        }
+    // TODO(bunnei): Just a stub for now... ImplementMe!
+    if ((addr & 0x3E000000) == 0x08000000) {
+        return g_fcram + (addr & MEM_FCRAM_MASK);
+    }
+    //else if ((addr & 0x3F800000) == 0x04000000) {
+    //    return g_vram + (addr & MEM_VRAM_MASK);
+    //}
+    //else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + g_MemorySize) {
+    //    return m_pRAM + (addr & g_MemoryMask);
+    //}
+    else {
+        //ERROR_LOG(MEMMAP, "Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
+        ERROR_LOG(MEMMAP, "Unknown GetPointer %08x", addr);
+        static bool reported = false;
+        //if (!reported) {
+        //    Reporting::ReportMessage("Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
+        //    reported = true;
+        //}
+        //if (!g_Config.bIgnoreBadMemAccess) {
+        //    Core_EnableStepping(true);
+        //    host->SetDebugMode(true);
+        //}
+        return 0;
+    }
 }
 
 u8 Read8(const u32 addr) {
-        u8 _var = 0;
-        ReadFromHardware<u8>(_var, addr);
-        return (u8)_var;
+    u8 _var = 0;
+    ReadFromHardware<u8>(_var, addr);
+    return (u8)_var;
 }
 
 u16 Read16(const u32 addr) {
-        u16_le _var = 0;
-        ReadFromHardware<u16_le>(_var, addr);
-        return (u16)_var;
+    u16_le _var = 0;
+    ReadFromHardware<u16_le>(_var, addr);
+    return (u16)_var;
 }
 
 u32 Read32(const u32 addr) {
-        u32_le _var = 0;
-        ReadFromHardware<u32_le>(_var, addr);
-        return _var;
+    u32_le _var = 0;
+    ReadFromHardware<u32_le>(_var, addr);
+    return _var;
 }
 
 u64 Read64(const u32 addr) {
-        u64_le _var = 0;
-        ReadFromHardware<u64_le>(_var, addr);
-        return _var;
+    u64_le _var = 0;
+    ReadFromHardware<u64_le>(_var, addr);
+    return _var;
 }
 
 u32 Read8_ZX(const u32 addr) {
-        return (u32)Read8(addr);
+    return (u32)Read8(addr);
 }
 
 u32 Read16_ZX(const u32 addr) {
-        return (u32)Read16(addr);
+    return (u32)Read16(addr);
 }
 
 void Write8(const u32 addr, const u8 data) {
-        WriteToHardware<u8>(addr, data);
+    WriteToHardware<u8>(addr, data);
 }
 
 void Write16(const u32 addr, const u16 data) {
-        WriteToHardware<u16_le>(addr, data);
+    WriteToHardware<u16_le>(addr, data);
 }
 
 void Write32(const u32 addr, const u32 data) {
-        WriteToHardware<u32_le>(addr, data);
+    WriteToHardware<u32_le>(addr, data);
 }
 
 void Write64(const u32 addr, const u64 data) {
-        WriteToHardware<u64_le>(addr, data);
+    WriteToHardware<u64_le>(addr, data);
 }
 
 } // namespace