More MSAN features.

- DMA writes now properly flag memory as initialized.
- GDB now supports the memory region properly.

Author: nicolasnoble

src/core/cdrom.cc

@@ -1466,6 +1466,7 @@ class CDRomImpl : public PCSX::CDRom {
                     memFile->write<uint8_t>(m_transfer[m_transferIndex++]);
                     adjustTransferIndex();
                 }
+                PCSX::g_emulator->m_mem->msanDmaWrite(madr, cdsize);
                 if (PCSX::g_emulator->settings.get<PCSX::Emulator::SettingDebugSettings>()
                         .get<PCSX::Emulator::DebugSettings::Debug>()) {
                     PCSX::g_emulator->m_debug->checkDMAwrite(3, madr, cdsize);

src/core/gdb-server.cc

@@ -270,6 +270,9 @@ static const std::string memoryMap = R"(<?xml version="1.0"?>
   <memory type="ram" start="0xffffffff9fc00000" length="0x80000"/>
   <memory type="ram" start="0xffffffffbfc00000" length="0x80000"/>
 
+  <!-- MSAN -->
+  <memory type="ram" start="0x0000000020000000" length="0x60000000"/>
+
   <!-- This really is only for 0xfffe0130 -->
   <memory type="ram" start="0xfffffffffffe0000" length="0x200"/>
 </memory-map>

src/core/gpu.cc

@@ -514,6 +514,7 @@ void PCSX::GPU::dma(uint32_t madr, uint32_t bcr, uint32_t chcr) {  // GPU
             size = (bcr >> 16) * (bcr & 0xffff);
             directDMARead(ptr, size, madr);
             g_emulator->m_cpu->Clear(madr, size);
+            g_emulator->m_mem->msanDmaWrite(madr, size * 4);
             if (g_emulator->settings.get<Emulator::SettingDebugSettings>().get<Emulator::DebugSettings::Debug>()) {
                 g_emulator->m_debug->checkDMAwrite(2, madr, size * 4);
             }

src/core/mdec.cc

@@ -480,6 +480,7 @@ void PCSX::MDEC::dma1(uint32_t adr, uint32_t bcr, uint32_t chcr) {
     size *= 4;
     /* I guess the memory speed is limitating */
     dmacnt = size;
+    g_emulator->m_mem->msanDmaWrite(adr, size);
     if (g_emulator->settings.get<Emulator::SettingDebugSettings>().get<Emulator::DebugSettings::Debug>()) {
         g_emulator->m_debug->checkDMAwrite(1, adr, size);
     }

src/core/psxdma.cc

@@ -61,6 +61,7 @@ void dma4(uint32_t madr, uint32_t bcr, uint32_t chcr) {  // SPU
             }
             size = (bcr >> 16) * (bcr & 0xffff) * 2;
             PCSX::g_emulator->m_spu->readDMAMem(ptr, size);
+            PCSX::g_emulator->m_mem->msanDmaWrite(madr, size * 2);
             if (PCSX::g_emulator->settings.get<PCSX::Emulator::SettingDebugSettings>()
                     .get<PCSX::Emulator::DebugSettings::Debug>()) {
                 PCSX::g_emulator->m_debug->checkDMAwrite(4, madr, size * 2);
@@ -116,6 +117,7 @@ void dma6(uint32_t madr, uint32_t bcr, uint32_t chcr) {
             mem++;
             *mem = 0xffffff;
         }
+        PCSX::g_emulator->m_mem->msanDmaWrite(madr, size * 4);
         if (PCSX::g_emulator->settings.get<PCSX::Emulator::SettingDebugSettings>()
                 .get<PCSX::Emulator::DebugSettings::Debug>()) {
             PCSX::g_emulator->m_debug->checkDMAwrite(6, madr, size * 4);

src/core/psxmem.cc

@@ -791,21 +791,39 @@ ssize_t PCSX::Memory::MemoryAsFile::writeAt(const void *src, size_t size, size_t
     return ret;
 }
 
-void PCSX::Memory::MemoryAsFile::readBlock(void *dest, size_t size, size_t ptr) {
+void PCSX::Memory::MemoryAsFile::readBlock(void *dest_, size_t size, size_t ptr) {
+    auto dest = reinterpret_cast<uint8_t *>(dest_);
     auto block = m_memory->m_readLUT[ptr / c_blockSize];
     if (!block) {
         memset(dest, 0, size);
+        if (m_memory->msanInitialized()) {
+            for (size_t i = 0; i < size; ++i) {
+                size_t msanPtr = ptr + i;
+                if (inMsanRange(msanPtr) && (m_memory->msanGetStatus<1>(msanPtr) == MsanStatus::OK)) {
+                    dest[i] = m_memory->m_msanRAM[msanPtr - c_msanStart];
+                }
+            }
+        }
         return;
     }
     auto offset = ptr % c_blockSize;
     auto toCopy = std::min(size, c_blockSize - offset);
     memcpy(dest, block + offset, toCopy);
 }
 
-void PCSX::Memory::MemoryAsFile::writeBlock(const void *src, size_t size, size_t ptr) {
+void PCSX::Memory::MemoryAsFile::writeBlock(const void *src_, size_t size, size_t ptr) {
     // Yes. That's not a bug nor a typo.
+    auto src = reinterpret_cast<const uint8_t *>(src_);
     auto block = m_memory->m_readLUT[ptr / c_blockSize];
     if (!block) {
+        if (m_memory->msanInitialized()) {
+            for (size_t i = 0; i < size; ++i) {
+                size_t msanPtr = ptr + i;
+                if (inMsanRange(msanPtr)) {
+                    m_memory->m_msanRAM[msanPtr - c_msanStart] = src[i];
+                }
+            }
+        }
         return;
     }
     auto offset = ptr % c_blockSize;

src/core/psxmem.h

@@ -103,7 +103,7 @@ class Memory {
                 }
                 bestCase = MsanStatus::UNINITIALIZED;
             }
-            bitmask &= 0xFF;
+            bitmask &= 0xff;
         }
         if ((m_msanInitializedBitmap[bitmapIndex] & bitmask) != bitmask) [[unlikely]] {
             if ((m_msanUsableBitmap[bitmapIndex] & bitmask) != bitmask) {
@@ -124,7 +124,7 @@ class Memory {
                 return false;
             }
             m_msanInitializedBitmap[bitmapIndex + 1] |= nextBitmask;
-            bitmask &= 0xFF;
+            bitmask &= 0xff;
         }
         if ((m_msanUsableBitmap[bitmapIndex] & bitmask) != bitmask) [[unlikely]] {
             return false;
@@ -133,6 +133,14 @@ class Memory {
         return true;
     }
 
+    void msanDmaWrite(uint32_t addr, uint32_t size) {
+        if (!msanInitialized() || !inMsanRange(addr)) return;
+        addr -= c_msanStart;
+        for (uint32_t i = 0; i < size; ++i) {
+            m_msanInitializedBitmap[(addr + i) / 8] |= 1 << ((addr + i) % 8);
+        }
+    }
+
     static inline bool inMsanRange(uint32_t addr) { return addr >= c_msanStart && addr < c_msanEnd; }
 
     template <unsigned n>

src/mips/common/crt0/cxxglue.c

@@ -49,7 +49,7 @@ void cxxmain(int argc, char** argv) {
     size_t count, i;
 
 #ifdef USE_PCSXMSAN
-    pcsx_msanInit();
+    pcsx_initMsan();
 #endif
 
     count = __preinit_array_end - __preinit_array_start;