Fix msan false positive swl swr uninit read

src/core/DynaRec_aa64/recompiler.h

@@ -83,6 +83,9 @@
 static uint8_t read8Wrapper(uint32_t address) { return PCSX::g_emulator->m_mem->read8(address); }
 static uint16_t read16Wrapper(uint32_t address) { return PCSX::g_emulator->m_mem->read16(address); }
 static uint32_t read32Wrapper(uint32_t address) { return PCSX::g_emulator->m_mem->read32(address); }
+static uint32_t read32MaskedWrapper(uint32_t address, const uint32_t msanSubBitmask) {
+    return PCSX::g_emulator->m_mem->read32(address, PCSX::Memory::ReadType::Data, msanSubBitmask);
+}
 
 static void SPU_writeRegisterWrapper(uint32_t addr, uint16_t value) {
     PCSX::g_emulator->m_spu->writeRegister(addr, value);
@@ -91,6 +94,9 @@ static void SPU_writeRegisterWrapper(uint32_t addr, uint16_t value) {
 static void write8Wrapper(uint32_t address, uint32_t value) { PCSX::g_emulator->m_mem->write8(address, value); }
 static void write16Wrapper(uint32_t address, uint32_t value) { PCSX::g_emulator->m_mem->write16(address, value); }
 static void write32Wrapper(uint32_t address, uint32_t value) { PCSX::g_emulator->m_mem->write32(address, value); }
+static void write32MaskedWrapper(uint32_t address, uint32_t value, const uint32_t msanSubBitmask) {
+    PCSX::g_emulator->m_mem->write32(address, value, msanSubBitmask);
+}
 
 using DynarecCallback = void (*)();  // A function pointer to JIT-emitted code
 

src/core/DynaRec_x64/recompiler.h

@@ -84,7 +84,13 @@
 #define _ImmLU_ _fImmLU_(code)
 
 static uint32_t read32Wrapper(uint32_t address) { return PCSX::g_emulator->m_mem->read32(address); }
+static uint32_t read32MaskedWrapper(uint32_t address, const uint32_t msanSubBitmask) {
+    return PCSX::g_emulator->m_mem->read32(address, PCSX::Memory::ReadType::Data, msanSubBitmask);
+}
 static void write32Wrapper(uint32_t address, uint32_t value) { PCSX::g_emulator->m_mem->write32(address, value); }
+static void write32MaskedWrapper(uint32_t address, uint32_t value, const uint32_t msanSubBitmask) {
+    PCSX::g_emulator->m_mem->write32(address, value, msanSubBitmask);
+}
 static void SPU_writeRegisterWrapper(uint32_t addr, uint16_t value) {
     PCSX::g_emulator->m_spu->writeRegister(addr, value);
 }

src/core/DynaRec_x64/symbols.cc

@@ -26,9 +26,10 @@
 #include "fmt/format.h"
 
 #define REGISTER_VARIABLE(variable, name, size) \
-    m_symbols += fmt::format("{} {} {}\n", (void*)&(variable), (name), (size))
+    m_symbols += fmt::format("{} {} {}\n", reinterpret_cast<const void*>(&(variable)), (name), (size))
 
-#define REGISTER_FUNCTION(function, name) m_symbols += fmt::format("{} {}\n", (void*)&(function), (name));
+#define REGISTER_FUNCTION(function, name) \
+    m_symbols += fmt::format("{} {}\n", reinterpret_cast<const void*>(&(function)), (name));
 
 #define REGISTER_CLASS_FUNCTION(function, name)            \
     {                                                      \
@@ -93,7 +94,9 @@ void DynaRecCPU::makeSymbols() {
     }
 
     REGISTER_FUNCTION(read32Wrapper, "read32_wrapper");
+    REGISTER_FUNCTION(read32MaskedWrapper, "read32_masked_wrapper");
     REGISTER_FUNCTION(write32Wrapper, "write32_wrapper");
+    REGISTER_FUNCTION(write32MaskedWrapper, "write32_masked_wrapper");
 
     REGISTER_CLASS_FUNCTION(PCSX::Memory::read8, "read8");
     REGISTER_CLASS_FUNCTION(PCSX::Memory::read16, "read16");

src/core/gpu.cc

@@ -327,6 +327,11 @@
         if (usingMsan && PCSX::Memory::inMsanRange(addr)) {
             addr &= 0xfffffffc;
             switch (g_emulator->m_mem->msanGetStatus<4>(addr)) {
+                case PCSX::MsanStatus::PARTIALLY_INITIALIZED:
+                    g_system->log(LogClass::GPU,
+                                  _("GPU DMA went into uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                  addr);
+                    break;
                 case PCSX::MsanStatus::UNINITIALIZED:
                     g_system->log(LogClass::GPU, _("GPU DMA went into usable but uninitialized msan memory: %8.8lx\n"),
                                   addr);
@@ -596,6 +601,11 @@
             addr &= 0xfffffffc;
             const uint32_t *headerPtr = (uint32_t *)(g_emulator->m_mem->m_msanRAM + (addr - PCSX::Memory::c_msanStart));
             switch (g_emulator->m_mem->msanGetStatus<4>(addr)) {
+                case PCSX::MsanStatus::PARTIALLY_INITIALIZED:
+                    g_system->log(LogClass::GPU,
+                                  _("GPU DMA went into uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                  addr);
+                    break;
                 case PCSX::MsanStatus::UNINITIALIZED:
                     g_system->log(LogClass::GPU, _("GPU DMA went into usable but uninitialized msan memory: %8.8lx\n"),
                                   addr);

src/core/psxhw.h

@@ -78,6 +78,11 @@ class HW {
                     if (usingMsan && PCSX::Memory::inMsanRange(madr)) {
                         madr &= 0xfffffffc;
                         switch (g_emulator->m_mem->msanGetStatus<4>(madr)) {
+                            case MsanStatus::PARTIALLY_INITIALIZED:
+                                g_system->log(LogClass::GPU,
+                                              _("GPU DMA went into uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                              madr);
+                                break;
                             case PCSX::MsanStatus::UNINITIALIZED:
                                 g_system->log(LogClass::GPU,
                                               _("GPU DMA went into usable but uninitialized msan memory: %8.8lx\n"),

src/core/psxinterpreter.cc

@@ -25,6 +25,7 @@
 #include "core/pgxp_debug.h"
 #include "core/pgxp_gte.h"
 #include "core/psxemulator.h"
+#include "core/psxmem.h"
 #include "core/r3000a.h"
 #include "tracy/Tracy.hpp"
 
@@ -935,25 +936,35 @@
 void InterpretedCPU::psxLWL(uint32_t code) {
     uint32_t addr = _oB_;
     uint32_t shift = addr & 3;
-    uint32_t mem = PCSX::g_emulator->m_mem->read32(addr & ~3);
+    const uint32_t msanReadMask = 0b1111 >> (3 - shift);
+    uint32_t mem = PCSX::g_emulator->m_mem->read32(
+        addr & ~3,
+        PCSX::Memory::ReadType::Data,
+        msanReadMask
+    );
 
     // load delay = 1 latency
     if (!_Rt_) return;
     _u32(delayedLoadRef(_Rt_, LWL_MASK[shift])) = mem << LWL_SHIFT[shift];
 
     /*
     Mem = 1234.  Reg = abcd
     0   4bcd   (mem << 24) | (reg & 0x00ffffff)
     1   34cd   (mem << 16) | (reg & 0x0000ffff)
     2   234d   (mem <<  8) | (reg & 0x000000ff)
     3   1234   (mem      ) | (reg & 0x00000000)
     */
 }
 
 void InterpretedCPU::psxLWR(uint32_t code) {
     uint32_t addr = _oB_;
     uint32_t shift = addr & 3;
-    uint32_t mem = PCSX::g_emulator->m_mem->read32(addr & ~3);
+    const uint32_t msanReadMask = (0b1111 << shift) & 0b1111;
+    uint32_t mem = PCSX::g_emulator->m_mem->read32(
+        addr & ~3,
+        PCSX::Memory::ReadType::Data,
+        msanReadMask
+    );
 
     // load delay = 1 latency
     if (!_Rt_) return;
@@ -998,15 +1009,18 @@
     uint32_t addr = _oB_;
     uint32_t shift = addr & 3;
     addr ^= shift;
-    uint32_t mem;
-    // special handling to avoid msan interpreting this as a read
-    if (PCSX::g_emulator->m_mem->msanInitialized() && PCSX::g_emulator->m_mem->inMsanRange(addr)) {
-        mem = *(uint32_t *)&PCSX::g_emulator->m_mem->m_msanRAM[addr - PCSX::Memory::c_msanStart];
-    } else {
-        mem = PCSX::g_emulator->m_mem->read32(addr);
-    }
-
-    PCSX::g_emulator->m_mem->write32(addr, (_u32(_rRt_) >> SWL_SHIFT[shift]) | (mem & SWL_MASK[shift]));
+    // 0x0 mask avoids msan interpreting this as a read
+    uint32_t mem = PCSX::g_emulator->m_mem->read32(
+        addr,
+        PCSX::Memory::ReadType::Data,
+        0x0 
+    );
+    const uint32_t msanWriteMask = 0b1111 >> (3 - shift);
+    PCSX::g_emulator->m_mem->write32(
+        addr,
+        (_u32(_rRt_) >> SWL_SHIFT[shift]) | (mem & SWL_MASK[shift]),
+        msanWriteMask
+    );
     /*
     Mem = 1234.  Reg = abcd
     0   123a   (reg >> 24) | (mem & 0xffffff00)
@@ -1020,15 +1034,18 @@
     uint32_t addr = _oB_;
     uint32_t shift = addr & 3;
     addr ^= shift;
-    uint32_t mem;
-    // special handling to avoid msan interpreting this as a read
-    if (PCSX::g_emulator->m_mem->msanInitialized() && PCSX::g_emulator->m_mem->inMsanRange(addr)) {
-        mem = *(uint32_t *)&PCSX::g_emulator->m_mem->m_msanRAM[addr - PCSX::Memory::c_msanStart];
-    } else {
-        mem = PCSX::g_emulator->m_mem->read32(addr);
-    }
-
-    PCSX::g_emulator->m_mem->write32(addr, (_u32(_rRt_) << SWR_SHIFT[shift]) | (mem & SWR_MASK[shift]));
+    // 0x0 mask avoids msan interpreting this as a read
+    uint32_t mem = PCSX::g_emulator->m_mem->read32(
+        addr,
+        PCSX::Memory::ReadType::Data,
+        0x0 
+    );
+    const uint32_t msanWriteMask = (0b1111 << shift) & 0b1111;
+    PCSX::g_emulator->m_mem->write32(
+        addr,
+        (_u32(_rRt_) << SWR_SHIFT[shift]) | (mem & SWR_MASK[shift]),
+        msanWriteMask
+    );
 
     /*
     Mem = 1234.  Reg = abcd

src/core/psxmem.cc

@@ -27,6 +27,7 @@
 #include "core/pio-cart.h"
 #include "core/psxhw.h"
 #include "core/r3000a.h"
+#include "core/system.h"
 #include "mips/common/util/encoder.hh"
 #include "support/file.h"
 #include "supportpsx/binloader.h"
@@ -297,6 +298,11 @@ uint8_t PCSX::Memory::read8(uint32_t address) {
     if (pointer != nullptr) {
         if (msanInitialized() && inMsanRange(address)) [[unlikely]] {
             switch (msanGetStatus<1>(address)) {
+                case MsanStatus::PARTIALLY_INITIALIZED:
+                    g_system->log(LogClass::CPU,
+                                  _("8-bit read from uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                  address);
+                    break;
                 case MsanStatus::UNINITIALIZED:
                     g_system->log(LogClass::CPU, _("8-bit read from usable but uninitialized msan memory: %8.8lx\n"),
                                   address);
@@ -348,6 +354,11 @@ uint16_t PCSX::Memory::read16(uint32_t address) {
     if (pointer != nullptr) {
         if (msanInitialized() && inMsanRange(address)) {
             switch (msanGetStatus<2>(address)) {
+                case MsanStatus::PARTIALLY_INITIALIZED:
+                    g_system->log(LogClass::CPU,
+                                  _("16-bit read from uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                  address);
+                    break;
                 case MsanStatus::UNINITIALIZED:
                     g_system->log(LogClass::CPU, _("16-bit read from usable but uninitialized msan memory: %8.8lx\n"),
                                   address);
@@ -387,15 +398,20 @@ uint16_t PCSX::Memory::read16(uint32_t address) {
     return 0xffff;
 }
 
-uint32_t PCSX::Memory::read32(uint32_t address, ReadType readType) {
+uint32_t PCSX::Memory::read32(uint32_t address, ReadType readType, const uint32_t msanSubBitmask) {
     if (readType == ReadType::Data) g_emulator->m_cpu->m_regs.cycle += 1;
     const uint32_t page = address >> 16;
     const auto pointer = (uint8_t *)m_readLUT[page];
     const bool pioConnected = g_emulator->settings.get<Emulator::SettingPIOConnected>().value;
 
     if (pointer != nullptr) {
         if (msanInitialized() && inMsanRange(address)) {
-            switch (msanGetStatus<4>(address)) {
+            switch (msanGetStatus<4>(address, msanSubBitmask)) {
+                case MsanStatus::PARTIALLY_INITIALIZED:
+                    g_system->log(LogClass::CPU,
+                                  _("32-bit read from uninitialized bytes in usable, partially initialized msan memory: %8.8lx\n"),
+                                  address);
+                    break;
                 case MsanStatus::UNINITIALIZED:
                     g_system->log(LogClass::CPU, _("32-bit read from usable but uninitialized msan memory: %8.8lx\n"),
                                   address);
@@ -586,15 +602,15 @@ void PCSX::Memory::write16(uint32_t address, uint32_t value) {
     }
 }
 
-void PCSX::Memory::write32(uint32_t address, uint32_t value) {
+void PCSX::Memory::write32(uint32_t address, uint32_t value, const uint32_t msanSubBitmask) {
     g_emulator->m_cpu->m_regs.cycle += 1;
     const uint32_t page = address >> 16;
     const auto pointer = (uint8_t *)m_writeLUT[page];
     const bool pioConnected = g_emulator->settings.get<Emulator::SettingPIOConnected>().value;
 
     if (pointer != nullptr) {
         if (msanInitialized() && inMsanRange(address)) {
-            if (msanValidateWrite<4>(address)) {
+            if (msanValidateWrite<4>(address, msanSubBitmask)) {
                 *(uint32_t *)&m_msanRAM[address - c_msanStart] = SWAP_LEu32(value);
             } else {
                 g_system->log(LogClass::CPU, _("32-bit write to unusable msan memory: %8.8lx\n"), address);
@@ -884,6 +900,7 @@ uint32_t PCSX::Memory::msanAlloc(uint32_t size) {
 
     // Check if we still have enough memory.
     if (m_msanPtr + actualSize > c_msanSize) {
+        g_system->printf(_("m_msanPtr: 0x%x actualSize: %zu, c_msanSize: %zu\n"), m_msanPtr, actualSize, c_msanSize);
         g_system->printf(_("Out of memory in MsanAlloc\n"));
         g_system->pause();
         return 0;

src/core/psxmem.h

@@ -48,9 +48,11 @@
 namespace PCSX {
 
 enum class MsanStatus {
-    UNUSABLE,       // memory that hasn't been allocated or has been freed
-    UNINITIALIZED,  // allocated memory that has never been written to, has undefined contents
-    OK              // free to use
+    UNUSABLE,               // memory that hasn't been allocated or has been freed
+    UNINITIALIZED,          // allocated memory that has never been written to, has undefined contents
+    PARTIALLY_INITIALIZED,  // allocated memory that has had some subset of bytes being read initialised
+                            // but not all of them
+    OK                      // free to use
 };
 
 class Memory {
@@ -66,10 +68,10 @@ class Memory {
 
     uint8_t read8(uint32_t address);
     uint16_t read16(uint32_t address);
-    uint32_t read32(uint32_t address, ReadType = ReadType::Data);
+    uint32_t read32(uint32_t address, ReadType = ReadType::Data, const uint32_t msanSubBitmask = UINT32_MAX);
     void write8(uint32_t address, uint32_t value);
     void write16(uint32_t address, uint32_t value);
-    void write32(uint32_t address, uint32_t value);
+    void write32(uint32_t address, uint32_t value, const uint32_t msanSubBitmask = UINT32_MAX);
     const void *pointerRead(uint32_t address);
     const void *pointerWrite(uint32_t address, int size);
 
@@ -92,33 +94,35 @@ class Memory {
     uint32_t msanGetChainPtr(uint32_t addr) const;
 
     template <uint32_t length>
-    MsanStatus msanGetStatus(uint32_t addr) const {
+    MsanStatus msanGetStatus(uint32_t addr, const uint32_t subBitmask = UINT32_MAX) const {
         uint32_t bitmapIndex = (addr - c_msanStart) / 8;
-        uint32_t bitmask = ((1 << length) - 1) << addr % 8;
+        uint32_t bitmask = (((1 << length) - 1) << addr % 8) & subBitmask;
         MsanStatus bestCase = MsanStatus::OK;
         if (uint32_t nextBitmask = bitmask >> 8) [[unlikely]] {
-            if ((m_msanInitializedBitmap[bitmapIndex + 1] & nextBitmask) != nextBitmask) {
+            const uint8_t nextInitEntry = m_msanInitializedBitmap[bitmapIndex + 1] & nextBitmask;
+            if (nextInitEntry != nextBitmask) {
                 if ((m_msanUsableBitmap[bitmapIndex + 1] & nextBitmask) != nextBitmask) {
                     return MsanStatus::UNUSABLE;
                 }
-                bestCase = MsanStatus::UNINITIALIZED;
+                bestCase = nextInitEntry ? MsanStatus::PARTIALLY_INITIALIZED : MsanStatus::UNINITIALIZED;
             }
             bitmask &= 0xff;
         }
-        if ((m_msanInitializedBitmap[bitmapIndex] & bitmask) != bitmask) [[unlikely]] {
+            const uint8_t initEntry = m_msanInitializedBitmap[bitmapIndex] & bitmask;
+        if (initEntry != bitmask) [[unlikely]] {
             if ((m_msanUsableBitmap[bitmapIndex] & bitmask) != bitmask) {
                 return MsanStatus::UNUSABLE;
             }
-            return MsanStatus::UNINITIALIZED;
+            return initEntry ? MsanStatus::PARTIALLY_INITIALIZED : MsanStatus::UNINITIALIZED;
         }
         return bestCase;
     }
 
     // if the write is valid, marks the address as initialized, otherwise returns false
     template <uint32_t length>
-    bool msanValidateWrite(uint32_t addr) {
+    bool msanValidateWrite(uint32_t addr, const uint32_t subBitmask = UINT32_MAX) {
         uint32_t bitmapIndex = (addr - c_msanStart) / 8;
-        uint32_t bitmask = ((1 << length) - 1) << addr % 8;
+        uint32_t bitmask = (((1 << length) - 1) << addr % 8) & subBitmask;
         if (uint32_t nextBitmask = bitmask >> 8) [[unlikely]] {
             if ((m_msanUsableBitmap[bitmapIndex + 1] & nextBitmask) != nextBitmask) {
                 return false;

src/main/main.cc

@@ -1,4 +1,4 @@
 /***************************************************************************
  *   Copyright (C) 2019 PCSX-Redux authors                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -17,10 +17,13 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
+#include "main/main.h"
+#include <atomic>
 #include <csignal>
 #include <filesystem>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <string>
 
 #include "core/arguments.h"
@@ -30,6 +33,7 @@
 #include "core/psxemulator.h"
 #include "core/r3000a.h"
 #include "core/sstate.h"
+#include "core/system.h"
 #include "core/ui.h"
 #include "flags.h"
 #include "fmt/chrono.h"
@@ -155,7 +159,7 @@
     void useLogfile(const PCSX::u8string &filename) {
         m_logfile.setFile(new PCSX::UvFile(filename, PCSX::FileOps::TRUNCATE));
     }
-    bool m_inStartup = true;
+    std::atomic_bool m_inStartup = true;
 };
 
 struct Cleaner {
@@ -484,3 +488,11 @@
 
     return exitCode;
 }
+
+bool MainInvoker::isInStartup() {
+    if (PCSX::g_system == nullptr || PCSX::g_emulator == nullptr) {
+        return true;
+    }
+    SystemImpl* system = reinterpret_cast<SystemImpl*>(PCSX::g_system);
+    return system->m_inStartup;
+}

src/main/main.h

@@ -50,6 +50,7 @@ class MainInvoker {
         fprintf(stderr, "PCSX-Redux test finished with exit code %d\n", r);
         return r;
     }
+    bool isInStartup();
 
   private:
     int m_count;