cpu: implement exclusive read/writes

Author: N3xoX1

src/nxemu-cpu/exclusive_monitor_interface.cpp

@@ -1,59 +1,60 @@
 #include "exclusive_monitor_interface.h"
 
-ExclusiveMonitor::ExclusiveMonitor(IMemory & /*memory*/, uint32_t processorCount) :
-    Dynarmic::ExclusiveMonitor(processorCount)
+ExclusiveMonitor::ExclusiveMonitor(IMemory & memory, uint32_t processorCount) :
+    Dynarmic::ExclusiveMonitor(processorCount),
+    m_memory(memory)
 {
 }
 
-uint8_t ExclusiveMonitor::ExclusiveRead8(uint32_t /*coreIndex*/, uint64_t /*addr*/)
+uint8_t ExclusiveMonitor::ExclusiveRead8(uint32_t coreIndex, uint64_t addr)
 {
-    __debugbreak();
-    return 0;
+    return ReadAndMark<uint16_t>(coreIndex, addr, [&]() -> uint32_t { return m_memory.Read8(addr); });
 }
 
-uint16_t ExclusiveMonitor::ExclusiveRead16(uint32_t /*coreIndex*/, uint64_t /*addr*/)
+uint16_t ExclusiveMonitor::ExclusiveRead16(uint32_t coreIndex, uint64_t addr)
 {
-    __debugbreak();
-    return 0;
+    return ReadAndMark<uint16_t>(coreIndex, addr, [&]() -> uint32_t { return m_memory.Read16(addr); });
 }
 
-uint32_t ExclusiveMonitor::ExclusiveRead32(uint32_t /*coreIndex*/, uint64_t /*addr*/)
+uint32_t ExclusiveMonitor::ExclusiveRead32(uint32_t coreIndex, uint64_t addr)
 {
-    __debugbreak();
-    return 0;
+    return ReadAndMark<uint32_t>(coreIndex, addr, [&]() -> uint32_t { return m_memory.Read32(addr); });
 }
 
-uint64_t ExclusiveMonitor::ExclusiveRead64(uint32_t /*coreIndex*/, uint64_t /*addr*/)
+uint64_t ExclusiveMonitor::ExclusiveRead64(uint32_t coreIndex, uint64_t addr)
 {
-    __debugbreak();
-    return 0;
+    return ReadAndMark<uint64_t>(coreIndex, addr, [&]() -> uint64_t { return m_memory.Read64(addr); });
 }
 
-void ExclusiveMonitor::ClearExclusive(uint32_t /*coreIndex*/)
+void ExclusiveMonitor::ClearExclusive(uint32_t coreIndex)
 {
-    __debugbreak();
+    ClearProcessor(coreIndex);
 }
 
-bool ExclusiveMonitor::ExclusiveWrite8(uint32_t /*coreIndex*/, uint64_t /*addr*/, uint8_t /*value*/)
+bool ExclusiveMonitor::ExclusiveWrite8(uint32_t coreIndex, uint64_t addr, uint8_t value)
 {
-    __debugbreak();
-    return false;
+    return DoExclusiveOperation<uint8_t>(coreIndex, addr, [&](uint8_t expected) -> bool {
+        return m_memory.WriteExclusive8(addr, value, expected);
+    });
 }
 
-bool ExclusiveMonitor::ExclusiveWrite16(uint32_t /*coreIndex*/, uint64_t /*addr*/, uint16_t /*value*/)
+bool ExclusiveMonitor::ExclusiveWrite16(uint32_t coreIndex, uint64_t addr, uint16_t value)
 {
-    __debugbreak();
-    return false;
+    return DoExclusiveOperation<uint16_t>(coreIndex, addr, [&](uint16_t expected) -> bool {
+        return m_memory.WriteExclusive16(addr, value, expected);
+    });
 }
 
-bool ExclusiveMonitor::ExclusiveWrite32(uint32_t /*coreIndex*/, uint64_t /*addr*/, uint32_t /*value*/)
+bool ExclusiveMonitor::ExclusiveWrite32(uint32_t coreIndex, uint64_t addr, uint32_t value)
 {
-    __debugbreak();
-    return false;
+    return DoExclusiveOperation<uint32_t>(coreIndex, addr, [&](uint32_t expected) -> bool {
+        return m_memory.WriteExclusive32(addr, value, expected);
+    });
 }
 
-bool ExclusiveMonitor::ExclusiveWrite64(uint32_t /*coreIndex*/, uint64_t /*addr*/, uint64_t /*value*/)
+bool ExclusiveMonitor::ExclusiveWrite64(uint32_t coreIndex, uint64_t addr, uint64_t value)
 {
-    __debugbreak();
-    return false;
+    return DoExclusiveOperation<uint64_t>(coreIndex, addr, [&](uint64_t expected) -> bool {
+        return m_memory.WriteExclusive64(addr   , value, expected);
+    });
 }

src/nxemu-cpu/exclusive_monitor_interface.h

@@ -27,4 +27,6 @@ class ExclusiveMonitor :
     ExclusiveMonitor() = delete;
     ExclusiveMonitor(const ExclusiveMonitor &) = delete;
     ExclusiveMonitor & operator=(const ExclusiveMonitor &) = delete;
+
+    IMemory & m_memory;
 };

src/nxemu-module-spec/cpu.h

@@ -55,6 +55,16 @@ __interface IMemory
 {
     void RasterizerMarkRegionCached(uint64_t vaddr, uint64_t size, bool cached) = 0;
     uint8_t * GetPointerSilent(uint64_t vaddr) = 0;
+
+    uint8_t Read8(uint64_t addr) = 0;
+    uint16_t Read16(uint64_t addr) = 0;
+    uint32_t Read32(uint64_t addr) = 0;
+    uint64_t Read64(uint64_t addr) = 0;
+
+    bool WriteExclusive8(uint64_t addr, uint8_t data, uint8_t expected) = 0;
+    bool WriteExclusive16(uint64_t addr, uint16_t data, uint16_t expected) = 0;
+    bool WriteExclusive32(uint64_t addr, uint32_t data, uint32_t expected) = 0;
+    bool WriteExclusive64(uint64_t addr, uint64_t data, uint64_t expected) = 0;
 };
 
 __interface ICpuInfo

src/nxemu-os/core/hle/kernel/k_thread.cpp

@@ -556,7 +556,7 @@ u16 KThread::GetUserDisableCount() const {
     }
 
     auto& memory = this->GetOwnerProcess()->GetMemory();
-    return memory.Read16(m_tls_address + offsetof(ThreadLocalRegion, disable_count));
+    return memory.Read16((m_tls_address + offsetof(ThreadLocalRegion, disable_count)).GetValue());
 }
 
 void KThread::SetInterruptFlag() {

src/nxemu-os/core/memory.cpp

@@ -892,19 +892,19 @@ const u8* Memory::GetPointer(Common::ProcessAddress vaddr) const {
     return impl->GetPointer(vaddr);
 }
 
-u8 Memory::Read8(const Common::ProcessAddress addr) {
+uint8_t Memory::Read8(uint64_t addr) {
     return impl->Read8(addr);
 }
 
-u16 Memory::Read16(const Common::ProcessAddress addr) {
+uint16_t Memory::Read16(uint64_t addr) {
     return impl->Read16(addr);
 }
 
-u32 Memory::Read32(const Common::ProcessAddress addr) {
+uint32_t Memory::Read32(uint64_t addr) {
     return impl->Read32(addr);
 }
 
-u64 Memory::Read64(const Common::ProcessAddress addr) {
+uint64_t Memory::Read64(uint64_t addr) {
     return impl->Read64(addr);
 }
 
@@ -924,19 +924,19 @@ void Memory::Write64(Common::ProcessAddress addr, u64 data) {
     impl->Write64(addr, data);
 }
 
-bool Memory::WriteExclusive8(Common::ProcessAddress addr, u8 data, u8 expected) {
+bool Memory::WriteExclusive8(uint64_t addr, uint8_t data, uint8_t expected) {
     return impl->WriteExclusive8(addr, data, expected);
 }
 
-bool Memory::WriteExclusive16(Common::ProcessAddress addr, u16 data, u16 expected) {
+bool Memory::WriteExclusive16(uint64_t addr, uint16_t data, uint16_t expected) {
     return impl->WriteExclusive16(addr, data, expected);
 }
 
-bool Memory::WriteExclusive32(Common::ProcessAddress addr, u32 data, u32 expected) {
+bool Memory::WriteExclusive32(uint64_t addr, uint32_t data, uint32_t expected) {
     return impl->WriteExclusive32(addr, data, expected);
 }
 
-bool Memory::WriteExclusive64(Common::ProcessAddress addr, u64 data, u64 expected) {
+bool Memory::WriteExclusive64(uint64_t addr, uint64_t data, uint64_t expected) {
     return impl->WriteExclusive64(addr, data, expected);
 }
 

src/nxemu-os/core/memory.h

@@ -175,7 +175,7 @@ class Memory :
      *
      * @returns the read 8-bit unsigned value.
      */
-    u8 Read8(Common::ProcessAddress addr);
+    uint8_t Read8(uint64_t addr) override;
 
     /**
      * Reads a 16-bit unsigned value from the current process' address space
@@ -185,7 +185,7 @@ class Memory :
      *
      * @returns the read 16-bit unsigned value.
      */
-    u16 Read16(Common::ProcessAddress addr);
+    uint16_t Read16(uint64_t addr) override;
 
     /**
      * Reads a 32-bit unsigned value from the current process' address space
@@ -195,7 +195,7 @@ class Memory :
      *
      * @returns the read 32-bit unsigned value.
      */
-    u32 Read32(Common::ProcessAddress addr);
+    uint32_t Read32(uint64_t addr) override;
 
     /**
      * Reads a 64-bit unsigned value from the current process' address space
@@ -205,7 +205,7 @@ class Memory :
      *
      * @returns the read 64-bit value.
      */
-    u64 Read64(Common::ProcessAddress addr);
+    uint64_t Read64(uint64_t addr) override;
 
     /**
      * Writes an 8-bit unsigned integer to the given virtual address in
@@ -262,7 +262,7 @@ class Memory :
      *
      * @post The memory range [addr, sizeof(data)) contains the given data value.
      */
-    bool WriteExclusive8(Common::ProcessAddress addr, u8 data, u8 expected);
+    bool WriteExclusive8(uint64_t addr, uint8_t data, uint8_t expected) override;
 
     /**
      * Writes a 16-bit unsigned integer to the given virtual address in
@@ -275,7 +275,7 @@ class Memory :
      *
      * @post The memory range [addr, sizeof(data)) contains the given data value.
      */
-    bool WriteExclusive16(Common::ProcessAddress addr, u16 data, u16 expected);
+    bool WriteExclusive16(uint64_t addr, uint16_t data, uint16_t expected) override;
 
     /**
      * Writes a 32-bit unsigned integer to the given virtual address in
@@ -288,7 +288,7 @@ class Memory :
      *
      * @post The memory range [addr, sizeof(data)) contains the given data value.
      */
-    bool WriteExclusive32(Common::ProcessAddress addr, u32 data, u32 expected);
+    bool WriteExclusive32(uint64_t addr, uint32_t data, uint32_t expected) override;
 
     /**
      * Writes a 64-bit unsigned integer to the given virtual address in
@@ -301,7 +301,7 @@ class Memory :
      *
      * @post The memory range [addr, sizeof(data)) contains the given data value.
      */
-    bool WriteExclusive64(Common::ProcessAddress addr, u64 data, u64 expected);
+    bool WriteExclusive64(uint64_t addr, uint64_t data, uint64_t expected) override;
 
     /**
      * Writes a 128-bit unsigned integer to the given virtual address in