VERY experimental Nintendo Switch 2 emulator
C++
[dynarmic] Coalesce non-exclusive Write/Read fallback functions (#4158)
lizzie9a30172e45fc
diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.cpp b/src/core/arm/dynarmic/arm_dynarmic_32.cppindex 8be0abc4fa..a59aa3cac3 100644--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp@@ -22,21 +22,15 @@ DynarmicCallbacks32::DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess, m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}{}-u8 DynarmicCallbacks32::MemoryRead8(u32 vaddr) {- CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);- return m_memory.Read8(vaddr);-}-u16 DynarmicCallbacks32::MemoryRead16(u32 vaddr) {- CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);- return m_memory.Read16(vaddr);-}-u32 DynarmicCallbacks32::MemoryRead32(u32 vaddr) {- CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);- return m_memory.Read32(vaddr);-}-u64 DynarmicCallbacks32::MemoryRead64(u32 vaddr) {- CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);- return m_memory.Read64(vaddr);+u64 DynarmicCallbacks32::MemoryRead(u32 vaddr, size_t size) {+ CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);+ switch (size) {+ case sizeof(u64): return m_memory.Read64(vaddr);+ case sizeof(u32): return m_memory.Read32(vaddr);+ case sizeof(u16): return m_memory.Read16(vaddr);+ case sizeof(u8): return m_memory.Read8(vaddr);+ default: UNREACHABLE();+ }}std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {@@ -50,27 +44,17 @@ std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];}-void DynarmicCallbacks32::MemoryWrite8(u32 vaddr, u8 value) {- if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {- m_memory.Write8(vaddr, value);- }-}-void DynarmicCallbacks32::MemoryWrite16(u32 vaddr, u16 value) {- if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {- m_memory.Write16(vaddr, value);- }-}-void DynarmicCallbacks32::MemoryWrite32(u32 vaddr, u32 value) {- if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {- m_memory.Write32(vaddr, value);- }-}-void DynarmicCallbacks32::MemoryWrite64(u32 vaddr, u64 value) {- if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {- m_memory.Write64(vaddr, value);+void DynarmicCallbacks32::MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) {+ if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {+ switch (size) {+ case sizeof(u64): return m_memory.Write64(vaddr, value);+ case sizeof(u32): return m_memory.Write32(vaddr, u32(value));+ case sizeof(u16): return m_memory.Write16(vaddr, u16(value));+ case sizeof(u8): return m_memory.Write8(vaddr, u8(value));+ default: UNREACHABLE();+ }}}-bool DynarmicCallbacks32::MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) {return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&m_memory.WriteExclusive8(vaddr, value, expected);diff --git a/src/core/arm/dynarmic/arm_dynarmic_32.h b/src/core/arm/dynarmic/arm_dynarmic_32.hindex 623597152f..22655dff47 100644--- a/src/core/arm/dynarmic/arm_dynarmic_32.h+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h@@ -30,18 +30,12 @@ class System;class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {public:explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process);- u8 MemoryRead8(u32 vaddr) override;- u16 MemoryRead16(u32 vaddr) override;- u32 MemoryRead32(u32 vaddr) override;- u64 MemoryRead64(u32 vaddr) override;+ u64 MemoryRead(u32 vaddr, size_t size) override;std::optional<u32> MemoryReadCode(u32 vaddr) override;void InstructionSynchronizationBarrierRaised() override {last_code_addr = u64(-1); //reset back, force refetch}- void MemoryWrite8(u32 vaddr, u8 value) override;- void MemoryWrite16(u32 vaddr, u16 value) override;- void MemoryWrite32(u32 vaddr, u32 value) override;- void MemoryWrite64(u32 vaddr, u64 value) override;+ void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override;bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override;bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override;bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override;diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cppindex 9db40b9356..894857a86d 100644--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp@@ -10,6 +10,7 @@#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"#include "core/core_timing.h"#include "core/hle/kernel/k_process.h"+#include "dynarmic/interface/A64/config.h"namespace Core {@@ -21,21 +22,15 @@ DynarmicCallbacks64::DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess, m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}{}-u8 DynarmicCallbacks64::MemoryRead8(u64 vaddr) {- CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);- return m_memory.Read8(vaddr);-}-u16 DynarmicCallbacks64::MemoryRead16(u64 vaddr) {- CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);- return m_memory.Read16(vaddr);-}-u32 DynarmicCallbacks64::MemoryRead32(u64 vaddr) {- CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);- return m_memory.Read32(vaddr);-}-u64 DynarmicCallbacks64::MemoryRead64(u64 vaddr) {- CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);- return m_memory.Read64(vaddr);+u64 DynarmicCallbacks64::MemoryRead(u64 vaddr, size_t size) {+ CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);+ switch (size) {+ case sizeof(u64): return m_memory.Read64(vaddr);+ case sizeof(u32): return m_memory.Read32(vaddr);+ case sizeof(u16): return m_memory.Read16(vaddr);+ case sizeof(u8): return m_memory.Read8(vaddr);+ default: UNREACHABLE();+ }}Dynarmic::A64::Vector DynarmicCallbacks64::MemoryRead128(u64 vaddr) {CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read);@@ -53,24 +48,15 @@ std::optional<u32> DynarmicCallbacks64::MemoryReadCode(u64 vaddr) {return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];}-void DynarmicCallbacks64::MemoryWrite8(u64 vaddr, u8 value) {- if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {- m_memory.Write8(vaddr, value);- }-}-void DynarmicCallbacks64::MemoryWrite16(u64 vaddr, u16 value) {- if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {- m_memory.Write16(vaddr, value);- }-}-void DynarmicCallbacks64::MemoryWrite32(u64 vaddr, u32 value) {- if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {- m_memory.Write32(vaddr, value);- }-}-void DynarmicCallbacks64::MemoryWrite64(u64 vaddr, u64 value) {- if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {- m_memory.Write64(vaddr, value);+void DynarmicCallbacks64::MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) {+ if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {+ switch (size) {+ case sizeof(u64): return m_memory.Write64(vaddr, u64(value));+ case sizeof(u32): return m_memory.Write32(vaddr, u32(value));+ case sizeof(u16): return m_memory.Write16(vaddr, u16(value));+ case sizeof(u8): return m_memory.Write8(vaddr, u8(value));+ default: UNREACHABLE();+ }}}void DynarmicCallbacks64::MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) {diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.h b/src/core/arm/dynarmic/arm_dynarmic_64.hindex 4c8570913f..5ea5dde8a6 100644--- a/src/core/arm/dynarmic/arm_dynarmic_64.h+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h@@ -16,6 +16,7 @@#include "common/hash.h"#include "core/arm/arm_interface.h"#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"+#include "dynarmic/interface/A64/config.h"namespace Core::Memory {class Memory;@@ -36,19 +37,13 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {public:explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process);- u8 MemoryRead8(u64 vaddr) override;- u16 MemoryRead16(u64 vaddr) override;- u32 MemoryRead32(u64 vaddr) override;- u64 MemoryRead64(u64 vaddr) override;+ u64 MemoryRead(u64 vaddr, size_t size) override;Dynarmic::A64::Vector MemoryRead128(u64 vaddr) override;std::optional<u32> MemoryReadCode(u64 vaddr) override;void InstructionSynchronizationBarrierRaised() override {last_code_addr = u64(-1); //reset back, force refetch}- void MemoryWrite8(u64 vaddr, u8 value) override;- void MemoryWrite16(u64 vaddr, u16 value) override;- void MemoryWrite32(u64 vaddr, u32 value) override;- void MemoryWrite64(u64 vaddr, u64 value) override;+ void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) override;void MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) override;bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override;bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override;diff --git a/src/core/hle/service/jit/jit_context.cpp b/src/core/hle/service/jit/jit_context.cppindex 36bf5d6649..e1e8eeadbe 100644--- a/src/core/hle/service/jit/jit_context.cpp+++ b/src/core/hle/service/jit/jit_context.cpp@@ -71,17 +71,14 @@ public:void InstructionSynchronizationBarrierRaised() override {last_code_addr = u64(-1); //reset back, force refetch}- u8 MemoryRead8(u64 vaddr) override {- return ReadMemory<u8>(vaddr);- }- u16 MemoryRead16(u64 vaddr) override {- return ReadMemory<u16>(vaddr);- }- u32 MemoryRead32(u64 vaddr) override {- return ReadMemory<u32>(vaddr);- }- u64 MemoryRead64(u64 vaddr) override {- return ReadMemory<u64>(vaddr);+ u64 MemoryRead(u64 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64): return ReadMemory<u64>(vaddr);+ case sizeof(u32): return ReadMemory<u32>(vaddr);+ case sizeof(u16): return ReadMemory<u16>(vaddr);+ case sizeof(u8): return ReadMemory<u8>(vaddr);+ default: UNREACHABLE();+ }}u128 MemoryRead128(u64 vaddr) override {return ReadMemory<u128>(vaddr);@@ -89,22 +86,19 @@ public:std::string MemoryReadCString(u64 vaddr) {std::string result{};u8 next;- while ((next = MemoryRead8(vaddr++)) != 0)+ while ((next = u8(MemoryRead(vaddr++, sizeof(u8)))) != 0)result += char(next);return result;}- void MemoryWrite8(u64 vaddr, u8 value) override {- WriteMemory<u8>(vaddr, value);- }- void MemoryWrite16(u64 vaddr, u16 value) override {- WriteMemory<u16>(vaddr, value);- }- void MemoryWrite32(u64 vaddr, u32 value) override {- WriteMemory<u32>(vaddr, value);- }- void MemoryWrite64(u64 vaddr, u64 value) override {- WriteMemory<u64>(vaddr, value);+ void MemoryWrite(u64 vaddr, u64 value, size_t size) override {+ switch (size) {+ case sizeof(u64): WriteMemory<u64>(vaddr, u64(value)); break;+ case sizeof(u32): WriteMemory<u32>(vaddr, u32(value)); break;+ case sizeof(u16): WriteMemory<u16>(vaddr, u16(value)); break;+ case sizeof(u8): WriteMemory<u8>(vaddr, u8(value)); break;+ default: UNREACHABLE();+ }}void MemoryWrite128(u64 vaddr, u128 value) override {WriteMemory<u128>(vaddr, value);@@ -193,14 +187,14 @@ public:// The loaded NRO file has ELF relocations that must be processed before it can run.// Normally this would be processed by RTLD, but in HLE context, we don't have// the linker available, so we have to do it ourselves.- const VAddr mod_offset{callbacks->MemoryRead32(4)};- if (callbacks->MemoryRead32(mod_offset) != Common::MakeMagic('M', 'O', 'D', '0'))+ const VAddr mod_offset{callbacks->MemoryRead(4, sizeof(u32))};+ if (callbacks->MemoryRead(mod_offset, sizeof(u32)) != Common::MakeMagic('M', 'O', 'D', '0'))return false;// For more info about dynamic entries, see the ELF ABI specification:// https://refspecs.linuxbase.org/elf/gabi4+/ch5.dynamic.html// https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html- VAddr dynamic_offset{mod_offset + callbacks->MemoryRead32(mod_offset + 4)};+ VAddr dynamic_offset{mod_offset + callbacks->MemoryRead(mod_offset + 4, sizeof(u32))};VAddr rela_dyn = 0, relr_dyn = 0;size_t num_rela = 0, num_relr = 0;while (true) {@@ -222,8 +216,8 @@ public:for (size_t i = 0; i < num_rela; i++) {const auto rela{callbacks->ReadMemory<Elf64_Rela>(rela_dyn + i * sizeof(Elf64_Rela))};if (Elf64RelType(rela.r_info) == ElfAArch64Relative) {- const VAddr contents{callbacks->MemoryRead64(rela.r_offset)};- callbacks->MemoryWrite64(rela.r_offset, contents + rela.r_addend);+ const VAddr contents{callbacks->MemoryRead(rela.r_offset, sizeof(u64))};+ callbacks->MemoryWrite(rela.r_offset, contents + rela.r_addend, sizeof(u64));}}@@ -231,7 +225,7 @@ public:for (size_t i = 0; i < num_relr; i++) {const auto relr = callbacks->ReadMemory<Elf64_Relr>(relr_dyn + i * sizeof(Elf64_Relr));const auto incr = [&](VAddr where) {- callbacks->MemoryWrite64(where, callbacks->MemoryRead64(where) + relocbase);+ callbacks->MemoryWrite(where, callbacks->MemoryRead(where, sizeof(u64)) + relocbase, sizeof(u64));};if ((relr & 1) == 0) {// where pointer@@ -294,7 +288,7 @@ public:if (argument_stack.size() > 8) {const VAddr new_sp = Common::AlignDown(top_of_stack - (argument_stack.size() - 8) * sizeof(u64), STACK_ALIGN);for (size_t i = 8; i < argument_stack.size(); i++)- callbacks->MemoryWrite64(new_sp + (i - 8) * sizeof(u64), argument_stack[i]);+ callbacks->MemoryWrite(new_sp + (i - 8) * sizeof(u64), argument_stack[i], sizeof(u64));jit->SetSP(new_sp);}// Reset the call state for the next invocation@@ -385,17 +379,17 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {if (dest < src) {for (size_t i = 0; i < n; i++)- MemoryWrite8(dest + i, MemoryRead8(src + i));+ MemoryWrite(dest + i, u8(MemoryRead(src + i, sizeof(u8))), sizeof(u8));} else {for (size_t i = n; i > 0; i--)- MemoryWrite8(dest + i - 1, MemoryRead8(src + i - 1));+ MemoryWrite(dest + i - 1, u8(MemoryRead(src + i - 1, sizeof(u8))), sizeof(u8));}} else if (pc == parent.helpers[size_t(HelperFn::Memset)]) {const VAddr dest{parent.jit->GetRegister(0)};const u64 c{parent.jit->GetRegister(1)};const size_t n{parent.jit->GetRegister(2)};for (size_t i = 0; i < n; i++)- MemoryWrite8(dest + i, u8(c));+ MemoryWrite(dest + i, u8(c), sizeof(u8));} else if (pc == parent.helpers[size_t(HelperFn::Resolve)]) {// X0 contains a char* for a symbol to resolveconst auto name{MemoryReadCString(parent.jit->GetRegister(0))};@@ -422,7 +416,7 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {}void DynarmicCallbacks64::ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) {- auto const inst = MemoryRead32(pc);+ auto const inst = MemoryRead(pc, sizeof(u32));LOG_CRITICAL(Service_JIT, "{} PC @ {:08x}, data = {:08x}", exception, pc, inst);parent.jit->HaltExecution();}diff --git a/src/core/tools/freezer.cpp b/src/core/tools/freezer.cppindex 73a86b3c8c..606ac2da42 100644--- a/src/core/tools/freezer.cpp+++ b/src/core/tools/freezer.cpp@@ -33,18 +33,10 @@ u64 MemoryReadWidth(Core::Memory::Memory& memory, u32 width, VAddr addr) {void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 value) {switch (width) {- case 1:- memory.Write8(addr, static_cast<u8>(value));- break;- case 2:- memory.Write16(addr, static_cast<u16>(value));- break;- case 4:- memory.Write32(addr, static_cast<u32>(value));- break;- case 8:- memory.Write64(addr, value);- break;+ case sizeof(u64): return memory.Write64(addr, value);+ case sizeof(u32): return memory.Write32(addr, u32(value));+ case sizeof(u16): return memory.Write16(addr, u16(value));+ case sizeof(u8): return memory.Write8(addr, u8(value));default:UNREACHABLE();}diff --git a/src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp b/src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cppindex 8b6ec2506e..dc14d16978 100644--- a/src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp+++ b/src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp@@ -82,7 +82,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, constauto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr) -> T {return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {- return (conf.callbacks->*callback)(vaddr);+ return (conf.callbacks->*callback)(vaddr, sizeof(T));});};@@ -136,12 +136,9 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, constoaknut::Label l_addr, l_this;auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr, T value) -> u32 {- return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,- [&](T expected) -> bool {- return (conf.callbacks->*callback)(vaddr, value, expected);- })- ? 0- : 1;+ return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {+ return (conf.callbacks->*callback)(vaddr, value, expected);+ }) ? 0 : 1;};void* target = code.xptr<void*>();@@ -179,26 +176,14 @@ void A32AddressSpace::EmitPrelude() {UnprotectCodeMemory();- prelude_info.read_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);- prelude_info.read_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);- prelude_info.read_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);- prelude_info.read_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);- prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);- prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);- prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);- prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);- prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead8, u8>(code, conf);- prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead16, u16>(code, conf);- prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead32, u32>(code, conf);- prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead64, u64>(code, conf);- prelude_info.write_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);- prelude_info.write_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);- prelude_info.write_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);- prelude_info.write_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);- prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);- prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);- prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);- prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);+ prelude_info.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);+ prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);+ prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u8>(code, conf);+ prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u16>(code, conf);+ prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u32>(code, conf);+ prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u64>(code, conf);+ prelude_info.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);+ prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);prelude_info.exclusive_write_memory_32 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive32, u32>(code, conf);diff --git a/src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp b/src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cppindex 2dbb7d2e1d..efb9fc538c 100644--- a/src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp+++ b/src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp@@ -81,7 +81,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, constauto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr) -> T {return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {- return (conf.callbacks->*callback)(vaddr);+ return (conf.callbacks->*callback)(vaddr, sizeof(T));});};@@ -133,14 +133,10 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, constusing namespace oaknut::util;oaknut::Label l_addr, l_this;-auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr, T value) -> u32 {- return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,- [&](T expected) -> bool {- return (conf.callbacks->*callback)(vaddr, value, expected);- })- ? 0- : 1;+ return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {+ return (conf.callbacks->*callback)(vaddr, value, expected);+ }) ? 0 : 1;};void* target = code.xptr<void*>();@@ -346,30 +342,18 @@ void A64AddressSpace::EmitPrelude() {UnprotectCodeMemory();- prelude_info.read_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);- prelude_info.read_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);- prelude_info.read_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);- prelude_info.read_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);+ prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);prelude_info.read_memory_128 = EmitRead128CallTrampoline(code, conf.callbacks);- prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);- prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);- prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);- prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);+ prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);prelude_info.wrapped_read_memory_128 = EmitWrappedRead128CallTrampoline(code, conf.callbacks);- prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead8, u8>(code, conf);- prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead16, u16>(code, conf);- prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead32, u32>(code, conf);- prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead64, u64>(code, conf);+ prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u8>(code, conf);+ prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u16>(code, conf);+ prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u32>(code, conf);+ prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u64>(code, conf);prelude_info.exclusive_read_memory_128 = EmitExclusiveRead128CallTrampoline(code, conf);- prelude_info.write_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);- prelude_info.write_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);- prelude_info.write_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);- prelude_info.write_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);+ prelude_info.write_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);prelude_info.write_memory_128 = EmitWrite128CallTrampoline(code, conf.callbacks);- prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);- prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);- prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);- prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);+ prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);prelude_info.wrapped_write_memory_128 = EmitWrappedWrite128CallTrampoline(code, conf.callbacks);prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);diff --git a/src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp b/src/dynarmic/src/dynarmic/backend/arm64/address_space.cppindex 947c50f4c3..7b83e372e6 100644--- a/src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp+++ b/src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp@@ -145,32 +145,42 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {case LinkTarget::ReturnFromRunCode:c.B(prelude_info.return_from_run_code);break;+ // { this, vaddr, size }case LinkTarget::ReadMemory8:- c.BL(prelude_info.read_memory_8);+ c.LDR(X2, 1);+ c.BL(prelude_info.read_memory);break;case LinkTarget::ReadMemory16:- c.BL(prelude_info.read_memory_16);+ c.LDR(X2, 2);+ c.BL(prelude_info.read_memory);break;case LinkTarget::ReadMemory32:- c.BL(prelude_info.read_memory_32);+ c.LDR(X2, 4);+ c.BL(prelude_info.read_memory);break;case LinkTarget::ReadMemory64:- c.BL(prelude_info.read_memory_64);+ c.LDR(X2, 8);+ c.BL(prelude_info.read_memory);break;case LinkTarget::ReadMemory128:c.BL(prelude_info.read_memory_128);break;+ // { this, vaddr, size }case LinkTarget::WrappedReadMemory8:- c.BL(prelude_info.wrapped_read_memory_8);+ c.LDR(X2, 1);+ c.BL(prelude_info.wrapped_read_memory);break;case LinkTarget::WrappedReadMemory16:- c.BL(prelude_info.wrapped_read_memory_16);+ c.LDR(X2, 2);+ c.BL(prelude_info.wrapped_read_memory);break;case LinkTarget::WrappedReadMemory32:- c.BL(prelude_info.wrapped_read_memory_32);+ c.LDR(X2, 4);+ c.BL(prelude_info.wrapped_read_memory);break;case LinkTarget::WrappedReadMemory64:- c.BL(prelude_info.wrapped_read_memory_64);+ c.LDR(X2, 8);+ c.BL(prelude_info.wrapped_read_memory);break;case LinkTarget::WrappedReadMemory128:c.BL(prelude_info.wrapped_read_memory_128);@@ -190,32 +200,41 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {case LinkTarget::ExclusiveReadMemory128:c.BL(prelude_info.exclusive_read_memory_128);break;+ // { this, vaddr, value, size }case LinkTarget::WriteMemory8:- c.BL(prelude_info.write_memory_8);+ c.LDR(X3, 1);+ c.BL(prelude_info.write_memory);break;case LinkTarget::WriteMemory16:- c.BL(prelude_info.write_memory_16);+ c.LDR(X3, 2);+ c.BL(prelude_info.write_memory);break;case LinkTarget::WriteMemory32:- c.BL(prelude_info.write_memory_32);+ c.LDR(X3, 4);+ c.BL(prelude_info.write_memory);break;case LinkTarget::WriteMemory64:- c.BL(prelude_info.write_memory_64);+ c.LDR(X3, 8);+ c.BL(prelude_info.write_memory);break;case LinkTarget::WriteMemory128:c.BL(prelude_info.write_memory_128);break;case LinkTarget::WrappedWriteMemory8:- c.BL(prelude_info.wrapped_write_memory_8);+ c.LDR(X3, 1);+ c.BL(prelude_info.wrapped_write_memory);break;case LinkTarget::WrappedWriteMemory16:- c.BL(prelude_info.wrapped_write_memory_16);+ c.LDR(X3, 2);+ c.BL(prelude_info.wrapped_write_memory);break;case LinkTarget::WrappedWriteMemory32:- c.BL(prelude_info.wrapped_write_memory_32);+ c.LDR(X3, 4);+ c.BL(prelude_info.wrapped_write_memory);break;case LinkTarget::WrappedWriteMemory64:- c.BL(prelude_info.wrapped_write_memory_64);+ c.LDR(X3, 8);+ c.BL(prelude_info.wrapped_write_memory);break;case LinkTarget::WrappedWriteMemory128:c.BL(prelude_info.wrapped_write_memory_128);diff --git a/src/dynarmic/src/dynarmic/backend/arm64/address_space.h b/src/dynarmic/src/dynarmic/backend/arm64/address_space.hindex 755b05bd02..73e2c94a19 100644--- a/src/dynarmic/src/dynarmic/backend/arm64/address_space.h+++ b/src/dynarmic/src/dynarmic/backend/arm64/address_space.h@@ -93,30 +93,18 @@ protected:void* return_to_dispatcher;void* return_from_run_code;- void* read_memory_8;- void* read_memory_16;- void* read_memory_32;- void* read_memory_64;+ void* read_memory;void* read_memory_128;- void* wrapped_read_memory_8;- void* wrapped_read_memory_16;- void* wrapped_read_memory_32;- void* wrapped_read_memory_64;+ void* wrapped_read_memory;void* wrapped_read_memory_128;void* exclusive_read_memory_8;void* exclusive_read_memory_16;void* exclusive_read_memory_32;void* exclusive_read_memory_64;void* exclusive_read_memory_128;- void* write_memory_8;- void* write_memory_16;- void* write_memory_32;- void* write_memory_64;+ void* write_memory;void* write_memory_128;- void* wrapped_write_memory_8;- void* wrapped_write_memory_16;- void* wrapped_write_memory_32;- void* wrapped_write_memory_64;+ void* wrapped_write_memory;void* wrapped_write_memory_128;void* exclusive_write_memory_8;void* exclusive_write_memory_16;diff --git a/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp b/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cppindex f138b5f137..e866b2acd6 100644--- a/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp+++ b/src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp@@ -31,16 +31,16 @@ using namespace Xbyak::util;void A32EmitX64::GenFastmemFallbacks() {const std::initializer_list<int> idxes{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{- {8, Devirtualize<&A32::UserCallbacks::MemoryRead8>(conf.callbacks)},- {16, Devirtualize<&A32::UserCallbacks::MemoryRead16>(conf.callbacks)},- {32, Devirtualize<&A32::UserCallbacks::MemoryRead32>(conf.callbacks)},- {64, Devirtualize<&A32::UserCallbacks::MemoryRead64>(conf.callbacks)},+ {8, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},+ {16, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},+ {32, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},+ {64, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},}};const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{- {8, Devirtualize<&A32::UserCallbacks::MemoryWrite8>(conf.callbacks)},- {16, Devirtualize<&A32::UserCallbacks::MemoryWrite16>(conf.callbacks)},- {32, Devirtualize<&A32::UserCallbacks::MemoryWrite32>(conf.callbacks)},- {64, Devirtualize<&A32::UserCallbacks::MemoryWrite64>(conf.callbacks)},+ {8, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {16, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {32, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {64, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},}};const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{{8, Devirtualize<&A32::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},@@ -56,12 +56,12 @@ void A32EmitX64::GenFastmemFallbacks() {code.align();read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));+ // params = { this, vaddr, size }if (vaddr_idx != code.ABI_PARAM2.getIdx()) {code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});}- if (ordered) {- code.mfence();- }+ code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);+ if (ordered) code.mfence();callback.EmitCall(code);if (value_idx != code.ABI_RETURN.getIdx()) {code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);@@ -76,6 +76,7 @@ void A32EmitX64::GenFastmemFallbacks() {code.align();write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();ABI_PushCallerSaveRegistersAndAdjustStack(code);+ // params = { this, vaddr, value, size }if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);} else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {@@ -92,10 +93,9 @@ void A32EmitX64::GenFastmemFallbacks() {}}code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);+ code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);callback.EmitCall(code);- if (ordered) {- code.mfence();- }+ if (ordered) code.mfence();ABI_PopCallerSaveRegistersAndAdjustStack(code);code.ret();PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a32_write_fallback_{}", bitsize));@@ -138,35 +138,35 @@ void A32EmitX64::GenFastmemFallbacks() {#undef Axxvoid A32EmitX64::EmitA32ReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);}void A32EmitX64::EmitA32ReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);}void A32EmitX64::EmitA32ReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);}void A32EmitX64::EmitA32ReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);}void A32EmitX64::EmitA32WriteMemory8(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite8>(ctx, inst);+ EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite>(ctx, inst);}void A32EmitX64::EmitA32WriteMemory16(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite16>(ctx, inst);+ EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite>(ctx, inst);}void A32EmitX64::EmitA32WriteMemory32(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite32>(ctx, inst);+ EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite>(ctx, inst);}void A32EmitX64::EmitA32WriteMemory64(A32EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite64>(ctx, inst);+ EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite>(ctx, inst);}void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {@@ -175,33 +175,33 @@ void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {void A32EmitX64::EmitA32ExclusiveReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);}}void A32EmitX64::EmitA32ExclusiveReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);}}void A32EmitX64::EmitA32ExclusiveReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);}}void A32EmitX64::EmitA32ExclusiveReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);}}diff --git a/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp b/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cppindex 4b7054b4b2..8bb2fcfa59 100644--- a/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp+++ b/src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp@@ -115,16 +115,16 @@ void A64EmitX64::GenMemory128Accessors() {void A64EmitX64::GenFastmemFallbacks() {const std::initializer_list<int> idxes{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{- {8, Devirtualize<&A64::UserCallbacks::MemoryRead8>(conf.callbacks)},- {16, Devirtualize<&A64::UserCallbacks::MemoryRead16>(conf.callbacks)},- {32, Devirtualize<&A64::UserCallbacks::MemoryRead32>(conf.callbacks)},- {64, Devirtualize<&A64::UserCallbacks::MemoryRead64>(conf.callbacks)},+ {8, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},+ {16, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},+ {32, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},+ {64, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},}};const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{- {8, Devirtualize<&A64::UserCallbacks::MemoryWrite8>(conf.callbacks)},- {16, Devirtualize<&A64::UserCallbacks::MemoryWrite16>(conf.callbacks)},- {32, Devirtualize<&A64::UserCallbacks::MemoryWrite32>(conf.callbacks)},- {64, Devirtualize<&A64::UserCallbacks::MemoryWrite64>(conf.callbacks)},+ {8, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {16, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {32, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},+ {64, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},}};const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{{8, Devirtualize<&A64::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},@@ -204,12 +204,12 @@ void A64EmitX64::GenFastmemFallbacks() {code.align();read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));+ // params = { this, vaddr, size }if (vaddr_idx != code.ABI_PARAM2.getIdx()) {code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});}- if (ordered) {- code.mfence();- }+ code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);+ if (ordered) code.mfence();callback.EmitCall(code);if (value_idx != code.ABI_RETURN.getIdx()) {code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);@@ -224,6 +224,7 @@ void A64EmitX64::GenFastmemFallbacks() {code.align();write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();ABI_PushCallerSaveRegistersAndAdjustStack(code);+ // params = { this, vaddr, value, size }if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);} else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {@@ -240,10 +241,9 @@ void A64EmitX64::GenFastmemFallbacks() {}}code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);+ code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);callback.EmitCall(code);- if (ordered) {- code.mfence();- }+ if (ordered) code.mfence();ABI_PopCallerSaveRegistersAndAdjustStack(code);code.ret();PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a64_write_fallback_{}", bitsize));@@ -286,19 +286,19 @@ void A64EmitX64::GenFastmemFallbacks() {#undef Axxvoid A64EmitX64::EmitA64ReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);}void A64EmitX64::EmitA64ReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);}void A64EmitX64::EmitA64ReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);}void A64EmitX64::EmitA64ReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);}void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {@@ -306,23 +306,23 @@ void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {}void A64EmitX64::EmitA64WriteMemory8(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite8>(ctx, inst);+ EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite>(ctx, inst);}void A64EmitX64::EmitA64WriteMemory16(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite16>(ctx, inst);+ EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite>(ctx, inst);}void A64EmitX64::EmitA64WriteMemory32(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite32>(ctx, inst);+ EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite>(ctx, inst);}void A64EmitX64::EmitA64WriteMemory64(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);+ EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite>(ctx, inst);}void A64EmitX64::EmitA64WriteMemory128(A64EmitContext& ctx, IR::Inst* inst) {- EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);+ EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite>(ctx, inst);}void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {@@ -331,33 +331,33 @@ void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {void A64EmitX64::EmitA64ExclusiveReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);+ EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);}}void A64EmitX64::EmitA64ExclusiveReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);+ EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);}}void A64EmitX64::EmitA64ExclusiveReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);+ EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);}}void A64EmitX64::EmitA64ExclusiveReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {if (conf.fastmem_exclusive_access) {- EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);} else {- EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);+ EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);}}diff --git a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.incindex 4fa14d504b..8bb8be3d5b 100644--- a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc+++ b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc@@ -1,3 +1,6 @@+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later+/* This file is part of the dynarmic project.* Copyright (c) 2022 MerryMage* SPDX-License-Identifier: 0BSD@@ -56,16 +59,13 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {// Neither fastmem nor page table: Use callbacksif constexpr (bitsize == 128) {ctx.reg_alloc.HostCall(code, nullptr, {}, args[1]);- if (ordered) {- code.mfence();- }+ if (ordered) code.mfence();code.CallFunction(memory_read_128);ctx.reg_alloc.DefineValue(code, inst, xmm1);} else {ctx.reg_alloc.HostCall(code, inst, {}, args[1]);- if (ordered) {- code.mfence();- }+ code.mov(code.ABI_PARAM3.cvt32(), bitsize / CHAR_BIT);+ if (ordered) code.mfence();Devirtualize<callback>(conf.callbacks).EmitCall(code);code.ZeroExtendFrom(bitsize, code.ABI_RETURN);}@@ -148,12 +148,12 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {ctx.reg_alloc.HostCall(code, nullptr);code.CallFunction(memory_write_128);} else {+ // { this, vaddr, value, size }ctx.reg_alloc.HostCall(code, nullptr, {}, args[1], args[2]);+ code.mov(code.ABI_PARAM4.cvt32(), bitsize / CHAR_BIT);Devirtualize<callback>(conf.callbacks).EmitCall(code);}- if (ordered) {- code.mfence();- }+ if (ordered) code.mfence();EmitCheckMemoryAbort(ctx, inst);return;}@@ -230,12 +230,11 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {if (ordered) {code.mfence();}- code.CallLambda(- [](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {- return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {- return (conf.callbacks->*callback)(vaddr);- });+ code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {+ return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {+ return (conf.callbacks->*callback)(vaddr, bitsize / CHAR_BIT);});+ });code.ZeroExtendFrom(bitsize, code.ABI_RETURN);} else {const Xbyak::Xmm result = ctx.reg_alloc.ScratchXmm(code);@@ -250,12 +249,11 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {if (ordered) {code.mfence();}- code.CallLambda(- [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {- ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {- return (conf.callbacks->*callback)(vaddr);- });+ code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {+ ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {+ return (conf.callbacks->*callback)(vaddr);});+ });code.movups(result, xword[rsp + ABI_SHADOW_SPACE]);ctx.reg_alloc.ReleaseStackSpace(code, 16 + ABI_SHADOW_SPACE);diff --git a/src/dynarmic/src/dynarmic/interface/A32/config.h b/src/dynarmic/src/dynarmic/interface/A32/config.hindex b93b116164..49063ed619 100644--- a/src/dynarmic/src/dynarmic/interface/A32/config.h+++ b/src/dynarmic/src/dynarmic/interface/A32/config.h@@ -66,7 +66,9 @@ struct UserCallbacks : public TranslateCallbacks {// All reads through this callback are 4-byte aligned.// Memory must be interpreted as little endian.- std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override { return MemoryRead32(vaddr); }+ std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override {+ return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));+ }// This function is called before the instruction at pc is read.// IR code can be emitted by the callee prior to instruction handling.@@ -80,16 +82,10 @@ struct UserCallbacks : public TranslateCallbacks {// Reads through these callbacks may not be aligned.// Memory must be interpreted as if ENDIANSTATE == 0, endianness will be corrected by the JIT.- virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;- virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;- virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;- virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;+ virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;// Writes through these callbacks may not be aligned.- virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;- virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;- virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;- virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;+ virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;// Writes through these callbacks may not be aligned.virtual bool MemoryWriteExclusive8(VAddr /*vaddr*/, std::uint8_t /*value*/, std::uint8_t /*expected*/) { return false; }diff --git a/src/dynarmic/src/dynarmic/interface/A64/config.h b/src/dynarmic/src/dynarmic/interface/A64/config.hindex 818aed73e7..859aeba709 100644--- a/src/dynarmic/src/dynarmic/interface/A64/config.h+++ b/src/dynarmic/src/dynarmic/interface/A64/config.h@@ -89,20 +89,16 @@ struct UserCallbacks {// All reads through this callback are 4-byte aligned.// Memory must be interpreted as little endian.- virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) { return MemoryRead32(vaddr); }+ virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) {+ return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));+ }// Reads through these callbacks may not be aligned.- virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;- virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;- virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;- virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;+ virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;virtual Vector MemoryRead128(VAddr vaddr) = 0;// Writes through these callbacks may not be aligned.- virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;- virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;- virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;- virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;+ virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;virtual void MemoryWrite128(VAddr vaddr, Vector value) = 0;// Writes through these callbacks may not be aligned.diff --git a/src/dynarmic/src/dynarmic/ir/opt_passes.cpp b/src/dynarmic/src/dynarmic/ir/opt_passes.cppindex 02b8e821da..b32bbd517a 100644--- a/src/dynarmic/src/dynarmic/ir/opt_passes.cpp+++ b/src/dynarmic/src/dynarmic/ir/opt_passes.cpp@@ -40,7 +40,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {if (inst.AreAllArgsImmediates()) {const u32 vaddr = inst.GetArg(1).GetU32();if (cb->IsReadOnlyMemory(vaddr)) {- const u8 value_from_memory = cb->MemoryRead8(vaddr);+ const u8 value_from_memory = u8(cb->MemoryRead(vaddr, sizeof(u8)));inst.ReplaceUsesWith(IR::Value{value_from_memory});}}@@ -51,7 +51,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {if (inst.AreAllArgsImmediates()) {const u32 vaddr = inst.GetArg(1).GetU32();if (cb->IsReadOnlyMemory(vaddr)) {- const u16 value_from_memory = cb->MemoryRead16(vaddr);+ const u16 value_from_memory = u16(cb->MemoryRead(vaddr, sizeof(u16)));inst.ReplaceUsesWith(IR::Value{value_from_memory});}}@@ -62,7 +62,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {if (inst.AreAllArgsImmediates()) {const u32 vaddr = inst.GetArg(1).GetU32();if (cb->IsReadOnlyMemory(vaddr)) {- const u32 value_from_memory = cb->MemoryRead32(vaddr);+ const u32 value_from_memory = u32(cb->MemoryRead(vaddr, sizeof(u32)));inst.ReplaceUsesWith(IR::Value{value_from_memory});}}@@ -73,7 +73,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {if (inst.AreAllArgsImmediates()) {const u32 vaddr = inst.GetArg(1).GetU32();if (cb->IsReadOnlyMemory(vaddr)) {- const u64 value_from_memory = cb->MemoryRead64(vaddr);+ const u64 value_from_memory = u64(cb->MemoryRead(vaddr, sizeof(u64)));inst.ReplaceUsesWith(IR::Value{value_from_memory});}}diff --git a/src/dynarmic/tests/A32/fuzz_thumb.cpp b/src/dynarmic/tests/A32/fuzz_thumb.cppindex 67a01daf9c..a29b877f3e 100644--- a/src/dynarmic/tests/A32/fuzz_thumb.cpp+++ b/src/dynarmic/tests/A32/fuzz_thumb.cpp@@ -503,7 +503,7 @@ TEST_CASE("Fuzz Thumb32 instructions set", "[JitX64][Thumb][Thumb32]") {}}-TEST_CASE("Verify fix for off by one error in MemoryRead32 worked", "[Thumb][Thumb16]") {+TEST_CASE("Verify fix for off by one error in MemoryRead<32> worked", "[Thumb][Thumb16]") {ThumbTestEnv test_env;// Prepare test subjectsdiff --git a/src/dynarmic/tests/A32/test_arm_instructions.cpp b/src/dynarmic/tests/A32/test_arm_instructions.cppindex 5a27cd499c..ee24131386 100644--- a/src/dynarmic/tests/A32/test_arm_instructions.cpp+++ b/src/dynarmic/tests/A32/test_arm_instructions.cpp@@ -553,9 +553,9 @@ TEST_CASE("arm: Memory access (fastmem)", "[arm][A32]") {memset(backing_memory, 0, memory_size);memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);- env.MemoryWrite32(0, 0xE5904000); // LDR R4, [R0]- env.MemoryWrite32(4, 0xE5814000); // STR R4, [R1]- env.MemoryWrite32(8, 0xEAFFFFFE); // B .+ env.MemoryWrite(0, 0xE5904000, sizeof(u32)); // LDR R4, [R0]+ env.MemoryWrite(4, 0xE5814000, sizeof(u32)); // STR R4, [R1]+ env.MemoryWrite(8, 0xEAFFFFFE, sizeof(u32)); // B .jit.Regs()[0] = 0x100;jit.Regs()[1] = 0x1F0;jit.Regs()[15] = 0; // PC = 0diff --git a/src/dynarmic/tests/A32/testenv.h b/src/dynarmic/tests/A32/testenv.hindex bebc2566da..a22cc7131e 100644--- a/src/dynarmic/tests/A32/testenv.h+++ b/src/dynarmic/tests/A32/testenv.h@@ -16,6 +16,7 @@#include "common/assert.h"#include "common/common_types.h"+#include "dynarmic/frontend/A32/translate/translate_callbacks.h"#include "dynarmic/interface/A32/a32.h"template<typename InstructionType_, u32 infinite_loop_u32>@@ -59,42 +60,51 @@ public:return infinite_loop_u32; // B .}- std::uint8_t MemoryRead8(u32 vaddr) override {- if (IsInCodeMem(vaddr)) {- return reinterpret_cast<u8*>(code_mem.data())[vaddr];+ u64 MemoryRead(u32 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64):+ return MemoryRead(vaddr, sizeof(u32))+ | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;+ case sizeof(u32):+ return MemoryRead(vaddr, sizeof(u16))+ | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;+ case sizeof(u16):+ return MemoryRead(vaddr, sizeof(u8))+ | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;+ case sizeof(u8): {+ if (IsInCodeMem(vaddr))+ return reinterpret_cast<u8*>(code_mem.data())[vaddr];+ if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end())+ return iter->second;+ return u8(vaddr);}- if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) {- return iter->second;+ default:+ std::abort();}- return static_cast<u8>(vaddr);- }- std::uint16_t MemoryRead16(u32 vaddr) override {- return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;- }- std::uint32_t MemoryRead32(u32 vaddr) override {- return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;- }- std::uint64_t MemoryRead64(u32 vaddr) override {- return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;}- void MemoryWrite8(u32 vaddr, std::uint8_t value) override {- if (vaddr < code_mem.size() * sizeof(u32)) {- code_mem_modified_by_guest = true;+ void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {+ switch (size) {+ case sizeof(u64):+ MemoryWrite(vaddr, u32(value), sizeof(u32));+ MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));+ break;+ case sizeof(u32):+ MemoryWrite(vaddr, u16(value), sizeof(u16));+ MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));+ break;+ case sizeof(u16):+ MemoryWrite(vaddr, u8(value), sizeof(u8));+ MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));+ break;+ case sizeof(u8):+ if (vaddr < code_mem.size() * sizeof(u32))+ code_mem_modified_by_guest = true;+ modified_memory[vaddr] = value;+ break;+ default:+ std::abort();}- modified_memory[vaddr] = value;- }- void MemoryWrite16(u32 vaddr, std::uint16_t value) override {- MemoryWrite8(vaddr, static_cast<u8>(value));- MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));- }- void MemoryWrite32(u32 vaddr, std::uint32_t value) override {- MemoryWrite16(vaddr, static_cast<u16>(value));- MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));- }- void MemoryWrite64(u32 vaddr, std::uint64_t value) override {- MemoryWrite32(vaddr, static_cast<u32>(value));- MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));}void CallSVC(std::uint32_t swi) override {@@ -143,46 +153,41 @@ public:return read<std::uint32_t>(vaddr);}- std::uint8_t MemoryRead8(std::uint32_t vaddr) override {- return read<std::uint8_t>(vaddr);- }- std::uint16_t MemoryRead16(std::uint32_t vaddr) override {- return read<std::uint16_t>(vaddr);- }- std::uint32_t MemoryRead32(std::uint32_t vaddr) override {- return read<std::uint32_t>(vaddr);- }- std::uint64_t MemoryRead64(std::uint32_t vaddr) override {- return read<std::uint64_t>(vaddr);+ u64 MemoryRead(u32 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64): return read<u64>(vaddr);+ case sizeof(u32): return read<u32>(vaddr);+ case sizeof(u16): return read<u16>(vaddr);+ case sizeof(u8): return read<u8>(vaddr);+ default:+ std::abort();+ }}- void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override {- write(vaddr, value);- }- void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override {- write(vaddr, value);- }- void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override {- write(vaddr, value);- }- void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override {- write(vaddr, value);+ void MemoryWrite(Dynarmic::A32::VAddr vaddr, std::uint64_t value, size_t size) override {+ switch (size) {+ case sizeof(u64): return write<u64>(vaddr, u64(value));+ case sizeof(u32): return write<u32>(vaddr, u32(value));+ case sizeof(u16): return write<u16>(vaddr, u16(value));+ case sizeof(u8): return write<u8>(vaddr, u8(value));+ default: std::abort();+ }}- bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {- MemoryWrite8(vaddr, value);+ bool MemoryWriteExclusive8(Dynarmic::A32::VAddr vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {+ MemoryWrite(vaddr, value, sizeof(u8));return true;}- bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {- MemoryWrite16(vaddr, value);+ bool MemoryWriteExclusive16(Dynarmic::A32::VAddr vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {+ MemoryWrite(vaddr, value, sizeof(u16));return true;}- bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {- MemoryWrite32(vaddr, value);+ bool MemoryWriteExclusive32(Dynarmic::A32::VAddr vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {+ MemoryWrite(vaddr, value, sizeof(u32));return true;}- bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {- MemoryWrite64(vaddr, value);+ bool MemoryWriteExclusive64(Dynarmic::A32::VAddr vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {+ MemoryWrite(vaddr, value, sizeof(u64));return true;}diff --git a/src/dynarmic/tests/A64/a64.cpp b/src/dynarmic/tests/A64/a64.cppindex 99cc9d3d4d..24ddfd4084 100644--- a/src/dynarmic/tests/A64/a64.cpp+++ b/src/dynarmic/tests/A64/a64.cpp@@ -1006,8 +1006,8 @@ TEST_CASE("A64: 128-bit exclusive read/write", "[a64]") {REQUIRE(jit.GetRegister(1) == 0x7f7e7d7c7b7a7978);REQUIRE(jit.GetRegister(2) == 0x8786858483828180);REQUIRE(jit.GetRegister(4) == 0);- REQUIRE(env.MemoryRead64(0x1234567812345678) == 0xaf00d1e5badcafe0);- REQUIRE(env.MemoryRead64(0x1234567812345680) == 0xd0d0cacad0d0caca);+ REQUIRE(env.MemoryRead(0x1234567812345678, sizeof(u64)) == 0xaf00d1e5badcafe0);+ REQUIRE(env.MemoryRead(0x1234567812345680, sizeof(u64)) == 0xd0d0cacad0d0caca);}TEST_CASE("A64: CNTPCT_EL0", "[a64]") {@@ -1517,11 +1517,11 @@ TEST_CASE("A64: Memory access (fastmem)", "[a64]") {memset(backing_memory, 0, memory_size);memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);- env.MemoryWrite32(0, 0xA9401404); // LDP X4, X5, [X0]- env.MemoryWrite32(4, 0xF9400046); // LDR X6, [X2]- env.MemoryWrite32(8, 0xA9001424); // STP X4, X5, [X1]- env.MemoryWrite32(12, 0xF9000066); // STR X6, [X3]- env.MemoryWrite32(16, 0x14000000); // B .+ env.MemoryWrite(0, 0xA9401404, sizeof(u32)); // LDP X4, X5, [X0]+ env.MemoryWrite(4, 0xF9400046, sizeof(u32)); // LDR X6, [X2]+ env.MemoryWrite(8, 0xA9001424, sizeof(u32)); // STP X4, X5, [X1]+ env.MemoryWrite(12, 0xF9000066, sizeof(u32)); // STR X6, [X3]+ env.MemoryWrite(16, 0x14000000, sizeof(u32)); // B .jit.SetRegister(0, 0x100);jit.SetRegister(1, 0x1F0);jit.SetRegister(2, 0x10F);@@ -1788,8 +1788,8 @@ TEST_CASE("A64: rand3", "[a64]") {memset(backing_memory, 0, memory_size);// cat rand2.txt | awk '{print "env.code_mem.emplace_back(0x"$2"); // "$0}' > rand2-out.tx- env.MemoryWrite32(100, 0x58028edd); // 0000000000000084 58028edd ldr x29, #20952- env.MemoryWrite32(104, 0x14000000); // 0000000000000ea4 14000000 b #0+ env.MemoryWrite(100, 0x58028edd, sizeof(u32)); // 0000000000000084 58028edd ldr x29, #20952+ env.MemoryWrite(104, 0x14000000, sizeof(u32)); // 0000000000000ea4 14000000 b #0jit.SetPC(100);jit.SetPstate(0xb0000000);@@ -1824,7 +1824,7 @@ TEST_CASE("A64: rand2", "[a64][.]") {// cat rand2.txt | awk '{print "env.code_mem.emplace_back(0x"$2"); // "$0}' > rand2-out.txconst std::array<uint32_t, 4096> code32 = {0xea80f352, 0x6e65e59d, 0x1e20c343, 0x2e3a7192, 0x2e267249, 0xd500405f, 0x6f01f461, 0x6eb684fc, 0x58028edd, 0x0ea5f5b6, 0x0ea069fb, 0x2e769517, 0x5e066063, 0x1e65c3f5, 0x4f00ff52, 0x93401cf6, 0x1e274248, 0x6f67aaf5, 0x5e0c0782, 0x5ef43f3c, 0x2e6595b7, 0x4e20590f, 0xb35aa451, 0x6ee2c5ed, 0x4e32bf46, 0x2ea1ba8f, 0x2f68a85e, 0x9237d90a, 0x5e23dd10, 0x0e762e32, 0x4e31a8cf, 0xce1f3360, 0x781a4ac0, 0x13834066, 0x5fa8101c, 0x6f7c5594, 0x0e71bb68, 0xbc0b3e8f, 0x785dbbda, 0x6f51e794, 0xce50af75, 0x1ad728ec, 0x6ee0da4c, 0xb84efa14, 0x2eb3f613, 0x4e287ade, 0x4eb8c734, 0x2e83f4e8, 0x0e397c80, 0xd08f93f8, 0xce718e48, 0x0f672a0d, 0x2e9edd40, 0x0e14128b, 0x6f5942e6, 0x8b3a0f03, 0x3c5d16b9, 0x7f7e3743, 0x4f4c54e4, 0x0ea0a9e9, 0x9e59dbe6, 0x6e7ddcd3, 0xcec08377, 0x9ba759f8, 0x2ea5046e, 0x0e24c569, 0xb8979780, 0x4e31b98c, 0x4efe4f46, 0x4ea7c762, 0x7e61c9c6, 0x6e30c880, 0x1ada0c25, 0x4e603a2f, 0xda9d7218, 0x0d40c5d9, 0x5e214b05, 0x9ba9efc5, 0x5e61b81e, 0x6e7bc31c, 0x0e61a163, 0x9e5832d2, 0x4e772248, 0x4e3d17c8, 0x92624f60, 0x7a1a02dc, 0x79891f65, 0x6eb45036, 0x0e321ee8, 0x4e2566f0, 0x4ea02b9b, 0x0f9dcb3d, 0x2e21b9f9, 0x0e21a8c3, 0xda1700bd, 0x6ea0fb38, 0x7e607a0b, 0x72845817, 0x7f61068e, 0x0d60e529, 0x4ea0ca5c, 0x1a94b20f, 0x8b87419d, 0x7ea9ed71, 0x2ea1a86e, 0x4d40c4da, 0x5ea0eada, 0x784ba96e, 0x7eb6ee02, 0x3db1c710, 0x0e217836, 0x7ee0bb96, 0x4e786c08, 0x4e976a08, 0x489ffe86, 0x4e79fc9b, 0x0e21cbce, 0x5ef7fc65, 0x4ea1286d, 0xd29c771e, 0x6f5c2839, 0x0ea00a9d, 0x6ee44c06, 0x5ee1d858, 0x5ef2fda6, 0x7eb0c9fe, 0x7f762791, 0x2e212ae6, 0x4e61c9db, 0x13003c57, 0x5ee1b8f8, 0x0f2396d2, 0x6ea0db1e, 0x0e71ba82, 0xab29c807, 0x6ef8f8b3, 0x1f18d4a1, 0x0e261d15, 0x1e290081, 0x1b0c7d12, 0x4e7771c3, 0xf845f1e4, 0x4d40c9e8, 0xce778452, 0x6eb9879d, 0x6e21c93d, 0xcec0829f, 0x52a0969f, 0x1e772b4f, 0x7ee1da88, 0x5f52fe0a, 0x7f3387b1, 0x5e214850, 0x1e65c025, 0x0e2ca294, 0x2e614829, 0x1e640077, 0x9e240048, 0x4ebe9537, 0x9bb7925e, 0x38b669c5, 0x2840d089, 0x6f43e648, 0x2e662d28, 0x4eabaff3, 0x6e734cc7, 0x0e31baee, 0x7ee0d93c, 0x5e282bde, 0x7e21bba4, 0x4e6c75fa, 0x5ac01217, 0x7f4304af, 0x1e7878ed, 0x1ada2196, 0x7ee1aba3, 0x93407f3c, 0x4f6c34eb, 0x6e3447a9, 0x7e7ae545, 0x5e0802bb, 0x6eeae63a, 0x7ee1da62, 0x5e280bb3, 0xf81d4009, 0x1e603b21, 0x5e281a14, 0x6eb0a99b, 0x1e266a25, 0x0d60cafe, 0x0e0b6194, 0x7a4ed2c5, 0x92b762ec, 0x4e6b5749, 0x3c16a6e5, 0x4ea0a92b, 0x0fa58b6a, 0x5f76148c, 0x6e30c95f, 0x1e6540fd, 0x5e28e40f, 0x0d403fd4, 0x7e30da36, 0x7fda9b51, 0x2ea04bde, 0x1e25c3d2, 0x1ee0434c, 0x5e21d8e7, 0x5ee1ba51, 0x5e61aba9, 0x4e2849fb, 0x5ee098ea, 0x4e60f63d, 0x0f280443, 0x5ee0da27, 0x2e78a6ce, 0x78054afc, 0x4e14286b, 0x4e218bd8, 0x2a3d2551, 0x3a04017a, 0x5f4317cd, 0x0e604a37, 0x9a834614, 0x0e2edf4d, 0x7a51a0a0, 0x5f8e9043, 0x6ea06bb2, 0xaa2857dd, 0x7a1903fc, 0x301ba9ba, 0x9ac929cd, 0x4e061ff0, 0x2e38fcfc, 0x0e2f614a, 0x7ee0d8e4, 0x6e73afda, 0x7f4156f7, 0x0e6078bf, 0x4ee1d9ed, 0x93403fbe, 0xce6f8640, 0x4e3855e3, 0x6f76fe23, 0x112466e8, 0x1e358a90, 0x7f45272c, 0x6ea19a9d, 0x8a696350, 0x1e3900f6, 0x5e61c866, 0x0e3fbfd0, 0x5ee09ad0, 0x0e651d27, 0x4dffc35e, 0x2e20c6ce, 0x0fbe118d, 0x1e656a15, 0xd1357365, 0x0e20a847, 0xce4a835c, 0x4e203905, 0x2e60090d, 0x7f4a27bb, 0x1e64c316, 0xce7d86a4, 0x7ebded2d, 0x6e70a97e, 0x4eb9a42b, 0x0e209bef, 0x6f151730, 0x0e7e30f7, 0x4e724509, 0xd503375f, 0xce58b6ae, 0x5e21a9b8, 0xcb2ca538, 0x5ac01131, 0x6ea19a24, 0xeb40c8b3, 0xc8df7d65, 0x78108341, 0x3218ab9b, 0x0f3da7dd, 0x2e003089, 0x4e21cab5, 0x8aa5c924, 0x1a94950c, 0x123e506f, 0x13117e37, 0x1ee6005b, 0x5ac00647, 0x5eec8cd5, 0x7ef0fb3d, 0x9223272a, 0x5ee0cb02, 0x6e66071d, 0x6ea1dbbf, 0x5e61c903, 0x5ac015ea, 0x93db6206, 0x7e62b5e3, 0x6ea0c87b, 0xdac0090e, 0x48df7d90, 0x6e206ba5, 0x9e2503c2, 0x6e25fc89, 0x4d60e2db, 0x1e3e22a0, 0x2eb81c19, 0x7856ea00, 0x5fbfb22d, 0x1e630244, 0x4e202a83, 0x1f50a722, 0x7f7b55d2, 0x0fae89b9, 0x4e781d73, 0xce738c3a, 0x4f15a591, 0x6e21c7e1, 0x586ff77e, 0x8a5d3592, 0x93401c67, 0x5e61cb86, 0xce6bc2c1, 0x6e393f10, 0x9bb70ec3, 0xdac0098c, 0x4da84b95, 0x7f494476, 0x9ace5c11, 0x7e61ca14, 0x4f7a60ef, 0x1ad32b39, 0x0ea3777f, 0x5e61da7f, 0x4f1404e2, 0x4e3244e2, 0x6e1b1ceb, 0x0dee5aac, 0x4e2f9dc4, 0x5ea1b8c3, 0x1e59f863, 0xd500403f, 0x4e3ae7d0, 0x4ef5c6ea, 0x08dffe3b, 0x6e36f4f6, 0x2e764f29, 0x0e726f23, 0x5f42375b, 0x7f71fc40, 0x6e618aad, 0x93403e5b, 0x0e205976, 0x0e7250c4, 0x6eb0abc9, 0x2e2049f0, 0x5f14754d, 0x7f6ce468, 0x6f950bbe, 0x6e31aa47, 0x4eb83396, 0x0dccc952, 0x2ea1ca90, 0xce69c701, 0xb0bed69e, 0x7c5dec39, 0x4e2868a2, 0x0e591b08, 0x5f34e6dd, 0x3a449184, 0x5e3ce6de, 0x4ea149b7, 0x4e7ad29b, 0xba198503, 0x1f683e8f, 0xfa52f2a7, 0x6e30dffc, 0x4e6c3d17, 0x2eae3248, 0xd503349f, 0x1e60002c, 0x0f180680, 0x9e240049, 0x6f75774e, 0xa90d8678, 0x9ad924c4, 0x7eb0f85b, 0x0e205aaf, 0x7ee08899, 0x5f4bffd8, 0x1b0ff5f3, 0x4ee11dcd, 0x2e218948, 0x0dcb2733, 0x4eac107c, 0x4ea04a53, 0x4e287b44, 0x0e60b82a, 0x5ee0ebbc, 0xce454ff1, 0x5e1761e7, 0x5e09202f, 0x0e0c0754, 0x1e72e6b9, 0x7e21da70, 0x0fbdb20c, 0x5efb8c84, 0xd500401f, 0x3a47526e, 0x1e680acf, 0x7f7375fc, 0xf80522da, 0x4ee60c02, 0x4d40c2e7, 0x6f89096b, 0x7ee1bb6e, 0x5e280b4a, 0x1e3120c8, 0x7eb2ef96, 0x4fd012dd, 0x0f3027ef, 0x4e2078a8, 0xd503201f, 0x2e2312d9, 0x6ebf1c6e, 0x5ee1f8df, 0x4e607a46, 0x6e30c877, 0x6c09d2d1, 0x4e61abd8, 0x0e35267e, 0x6ac17728, 0x0e861aa0, 0x6f63fe26, 0x6f157628, 0x6f30a5f9, 0x4d60cc0c, 0x4e21cb59, 0x2e68a3fb, 0x7efae601, 0x6ea0f82c, 0x9b25ec12, 0x1a1a0305, 0x0e043fe1, 0x6e73c0ed, 0x6ea1b8c0, 0x7e20380b, 0x0f0534e8, 0x1f56bc7d, 0xba0c0128, 0x1e672160, 0x6e7b259b, 0x7ee07b5d, 0x9a820443, 0x4e040581, 0x2f1d87e8, 0x1acd2f5b, 0x6e20794f, 0x2e6a3c93, 0xc8dffe13, 0xce5ab1c6, 0x6eea55f6, 0x4ea039b3, 0x0d602fec, 0x2e246e2f, 0x7857be39, 0xb80608fb, 0x1e67c017, 0x9bcf7f63, 0x0f92d857, 0x5e0812f7, 0x1e210172, 0x7e6128e9, 0x7ea94d41, 0x981179e1, 0x1effb018, 0x2e600828, 0x0eb9c6b2, 0x6ee1baae, 0x4ea0db28, 0x2ea1487b, 0x4ea6c7f0, 0x2e2374c7, 0x7e30d8dd, 0xb9991fa7, 0x4e791e3e, 0x889f7c4b, 0x0e6c753c, 0x1e740ad1, 0x1e244324, 0x1ef33010, 0x5ac01102, 0x9bd97fba, 0x6e290143, 0x1e2220d8, 0x4d8d5aee, 0x6f28570b, 0xfa4ab0c1, 0xdac00b14, 0x7ea1a90e, 0x2e3027d8, 0x6f25a733, 0x4e61a96e, 0x4e1a2fcb, 0x0e22fe0a, 0xc8df7cd0, 0x5e280a55, 0x4e012b20, 0x7e70dbf4, 0x520c5a4e, 0x6ea6c57f, 0x0e861af8, 0xd503233f, 0x889ffe3c, 0x5e274ea9, 0x4e21a89a, 0x0e170c02, 0x6efd4c0b, 0xd5033ebf, 0x6e61a92c, 0x2e205b72, 0x789fb828, 0x0e626e94, 0x2ea6724c, 0x9a10028b, 0x2c6c51fc, 0x5a9de6b9, 0x6e6881f3, 0x5ee0ea6b, 0x0faec36e, 0x0e955bca, 0x1acf206d, 0x7f6f571b, 0x4e286930, 0x12b41ceb, 0x1e770b7a, 0x0ea18ac2, 0x5e282aaf, 0xf2b7fa1e, 0x1ac34311, 0x13167d11, 0x4ea63412, 0x6e758038, 0x2f1d85d6, 0x0f275480, 0x0ead6c71, 0x6e204b69, 0x1e6303f4, 0x5e0031ef, 0x13001e40, 0x7a16006f, 0x6e6ae4c0, 0x0f0f242f, 0x6e674f50, 0x4e606b7a, 0x7e6ee684, 0x1e6b5957, 0x7ea1bbab, 0x7ea0b6cb, 0xce4da241, 0x0ea1b953, 0x0eb2af4b, 0x9ac309d0, 0x6e61d8bd, 0x5ea0d890, 0x5f47d1e7, 0xfa5981ca, 0x1e7f7959, 0x6ef24dd8, 0x0e0a41d1, 0x5ee0e898, 0x4e6038e2, 0x13097d65, 0x6f839088, 0x9e290265, 0x0e208824, 0x2e65af79, 0x6f36a561, 0x9ad3204b, 0x0e21482e, 0x1e24431d, 0xd50330bf, 0x0df641aa, 0x6e602a83, 0xce30505f, 0x5e025238, 0xd503201f, 0x4e608880, 0x4de9c38d, 0x5e0f5348, 0x6eb48ca9, 0x50fda31b, 0x2e251eec, 0x7842ba50, 0xd8a1cd86, 0x2ea09862, 0x0ea09983, 0x2ea333b0, 0x0ea6032c, 0x4f94801b, 0x7e3ee57d, 0x38135e4f, 0xd8fdd9dd, 0x5ee0fcde, 0x9e64033d, 0x6e37f547, 0x6e3dd7ef, 0x13003f3d, 0x0e602f9f, 0x4e7ad014, 0x9b3b6857, 0x5ea0cb67, 0x0eb31c9f, 0x4e7c5372, 0x5e61b8c0, 0x0ea19b23, 0x0ee6e1df, 0x6e63a626, 0x2f139405, 0x7eb0f96d, 0x9e588c63, 0x2e714c3a, 0x6e8c941e, 0x0f61b331, 0x6f01f625, 0x4e78d4ea, 0x6f403709, 0x1a0300da, 0xda0102c8, 0x7e61d9fd, 0xb89469bb, 0x0c838780, 0x2e60a590, 0x4dfd29e1, 0x4e150f2e, 0xce2810bc, 0x5f541591, 0x9ee60259, 0x2eb40e56, 0x5e014027, 0x2ef71faf, 0x4e2d452f, 0x5ee0a813, 0x4eb03301, 0x38443acf, 0x6eabd502, 0x0e2ee71e, 0x5a960364, 0xce7ec596, 0x7efbed09, 0x4ef42ea2, 0x0eb30ea5, 0x5ee0d9f8, 0x6f513552, 0xf89eb3fa, 0x7ea2eca6, 0x9b00cc19, 0xf897409e, 0x1e73485f, 0x381afa77, 0x0f169f3b, 0x5ee1aa70, 0x5e1803ee, 0x0dbf5a4c, 0xce78c7a6, 0x9b0b260c, 0x2ef8fa19, 0x6e70aa4b, 0xce45b805, 0x2ea08e86, 0x4ee0bafd, 0x2ea09a1f, 0x4e218900, 0x6e744f13, 0xce518653, 0xf81b7a68, 0xce45ac5e, 0x7e62e416, 0x1a1b02b6, 0x7e21db48, 0x381daaaf, 0x6b2c0987, 0x0e2ec651, 0x4eae8502, 0x9bde7ca0, 0x6f47201f, 0x7e61a8a3, 0x6e60d5db, 0x4e2879de, 0xf81d194e, 0x4f1b8d05, 0x4d0048b2, 0x6e203be9, 0x4e3e7eb1, 0x0e260ef8, 0x2e688518, 0x7e3fec46, 0xdac00843, 0xf85c8917, 0x2e212a0f, 0x0e8196da, 0xd503359f, 0xce4c81f2, 0x6ee19992, 0x6e21ca79, 0x4d40c1d2, 0x4f5816ef, 0x4e34c3ea, 0x4df7c283, 0x7ef7eeb6, 0x18e276ce, 0xab0d21c0, 0xd5032f7f, 0x4ea00dbf, 0x5ac01251, 0xd0121955, 0x7f1495e4, 0x7ef0fa11, 0x5e24dd9c, 0x9add25b5, 0x0eb2bdef, 0x9e1977c7, 0x6f4b26bd, 0x0e200a9c, 0x9b4f7c00, 0x0ea0392e, 0x7e212a2c, 0x0b248b90, 0x1acc27a1, 0x2e701c90, 0x5ee1b870, 0x5e280aba, 0x5ea0780e, 0x1e264246, 0x4e052d04, 0x0e731dc4, 0xce461997, 0x9a9e9413, 0x3d462048, 0x5ea1fac5, 0x2ea0c8c4, 0x9a030280, 0x2ebda4b8, 0x5eef8614, 0x6eadc4e0, 0xbd035a8f, 0x4e606b84, 0x4eb1aba1, 0x4e286928, 0x4e2858cc, 0x9add0ce9, 0x4e070d65, 0x5fd399d5, 0x0f03fde7, 0x6ee90c74, 0x4ef8e31e, 0x381d986a, 0x5ea0ebf4, 0x5ea0d87e, 0x2e76ac9e, 0x6eb36cd4, 0x2e6e1c4c, 0x2e2feebc, 0x1ace4b03, 0x5ee0db12, 0x5ea0e9b1, 0x2e1c32d5, 0x5fa49a09, 0x0e258737, 0x7e21ca8e, 0xce4f9988, 0x5f7f56a6, 0x0e739766, 0x4e28586c, 0x6e619908, 0xd500401f, 0xf88b9252, 0x6e251c8e, 0x9e20015b, 0x7f1486b9, 0x717c339b, 0x1f31ff70, 0x4ea0eb62, 0x9acb0926, 0x489f7d85, 0x4e209b54, 0x2e84cf03, 0x2e65946c, 0x0e7d80cd, 0xc8dffecc, 0xce668bd8, 0x6e2188af, 0xeb4ada34, 0x2b25ec33, 0x0d40e6e7, 0x4eb2c757, 0x4ec82ad0, 0x7e21cb0a, 0x0e21a847, 0x4e0b1ec0, 0x381e6ac0, 0x6e61c8f5, 0x0f10071c, 0x2ee21daa, 0x5e61ab31, 0x6e218892, 0x2e7e7cb5, 0x6f2826aa, 0x7f6b54df, 0x4eaa2620, 0xdac00034, 0x4f6477be, 0x7e6148ea, 0x4eef1f57, 0x78459aeb, 0x2ebc3f10, 0x2e35f4eb, 0x4fbf19ce, 0xd8d0e58e, 0x2e21bbc7, 0x6ee0cab6, 0x9bc57e3f, 0x2f854037, 0x4e92181c, 0x6e6d1f89, 0x0f305545, 0x4ee19a57, 0x0e887bdf, 0x5e1a4185, 0x7ef0c821, 0x2eb6607c, 0x2ea0d9b8, 0x9e0380f4, 0x2ebf1c83, 0x1e62597d, 0x7f6e2548, 0x5ac00205, 0x4e616adb, 0xce638b8c, 0x5e1653cf, 0x2e6069be, 0x0e2ac641, 0x1e33c76f, 0xce44956d, 0x9bb90d31, 0x1e24c20a, 0x7ee038c1, 0x93407e5e, 0x4e280127, 0xc8df7f7d, 0xba42f263, 0x1e6f199c, 0x6e212889, 0x6e92f60e, 0x6ebdc499, 0x8b9acbf8, 0x4d40c581, 0x3a020250, 0x6e6a6716, 0x9248403b, 0x9081ffea, 0x4e603856, 0x9ad1242b, 0x6f270579, 0x1a070349, 0xcec08133, 0xd503305f, 0x5a1a00ca, 0x2e60b8a2, 0x0e5f28fd, 0x0e31a3da, 0x7e61cbc1, 0xd503399f, 0x5f5e54aa, 0x0eb8bdea, 0x4eba8f10, 0x4e2a2e60, 0x2f3da7d6, 0x1e58e297, 0x6e71aa3e, 0x6b86701a, 0xce4fa5e6, 0x4ee7c463, 0x8a79307f, 0x0ebea541, 0x2e218af4, 0x4e774f8a, 0xb9b95dc5, 0x6e61abd5, 0x4dd1e814, 0x4da72098, 0x98307582, 0x3a512101, 0x7ef95497, 0x1ace5535, 0x5a0c0349, 0x4e28581b, 0x6ebf1c02, 0x5ea1da23, 0x1e274314, 0x5e25dd29, 0x6e75f594, 0x6eaf6ed5, 0x4e214abe, 0x4e064172, 0x2e21c8f4, 0xf84c5b08, 0x1e244312, 0x14000000};for (size_t i = 0; i < code32.size(); ++i)- env.MemoryWrite32(100 + i, code32[i]);+ env.MemoryWrite(100 + i, code32[i], sizeof(u32));env.ignore_invalid_insn = true;jit.SetRegister(0, 0x866524401a1d4e47);diff --git a/src/dynarmic/tests/A64/fibonacci.cpp b/src/dynarmic/tests/A64/fibonacci.cppindex f52a04e217..8816a89b1c 100644--- a/src/dynarmic/tests/A64/fibonacci.cpp+++ b/src/dynarmic/tests/A64/fibonacci.cpp@@ -25,48 +25,55 @@ public:u64 ticks_left = 0;::Common::unordered_map<u64, u8> memory{};- u8 MemoryRead8(u64 vaddr) override {- return memory[vaddr];- }-- u16 MemoryRead16(u64 vaddr) override {- return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;- }-- u32 MemoryRead32(u64 vaddr) override {- return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;- }-- u64 MemoryRead64(u64 vaddr) override {- return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;+ u64 MemoryRead(u64 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64):+ return MemoryRead(vaddr, sizeof(u32))+ | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;+ case sizeof(u32):+ return MemoryRead(vaddr, sizeof(u16))+ | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;+ case sizeof(u16):+ return MemoryRead(vaddr, sizeof(u8))+ | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;+ case sizeof(u8):+ return memory[vaddr];+ default:+ std::abort();+ }}std::array<u64, 2> MemoryRead128(u64 vaddr) override {- return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};- }-- void MemoryWrite8(u64 vaddr, u8 value) override {- memory[vaddr] = value;+ return {+ MemoryRead(vaddr, sizeof(u64)),+ MemoryRead(vaddr + sizeof(u64), sizeof(u64))+ };+ }++ void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {+ switch (size) {+ case sizeof(u64):+ MemoryWrite(vaddr, u32(value), sizeof(u32));+ MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));+ break;+ case sizeof(u32):+ MemoryWrite(vaddr, u16(value), sizeof(u16));+ MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));+ break;+ case sizeof(u16):+ MemoryWrite(vaddr, u8(value), sizeof(u8));+ MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));+ break;+ case sizeof(u8):+ memory[vaddr] = value;+ break;+ default:+ std::abort();+ }}-- void MemoryWrite16(u64 vaddr, u16 value) override {- MemoryWrite8(vaddr, u8(value));- MemoryWrite8(vaddr + 1, u8(value >> 8));- }-- void MemoryWrite32(u64 vaddr, u32 value) override {- MemoryWrite16(vaddr, u16(value));- MemoryWrite16(vaddr + 2, u16(value >> 16));- }-- void MemoryWrite64(u64 vaddr, u64 value) override {- MemoryWrite32(vaddr, u32(value));- MemoryWrite32(vaddr + 4, u32(value >> 32));- }-void MemoryWrite128(u64 vaddr, std::array<u64, 2> value) override {- MemoryWrite64(vaddr, value[0]);- MemoryWrite64(vaddr + 8, value[1]);+ MemoryWrite(vaddr, value[0], sizeof(u64));+ MemoryWrite(vaddr + 8, value[1], sizeof(u64));}void CallSVC(u32) override {@@ -135,9 +142,9 @@ TEST_CASE("A64: fibonacci", "[a64]") {code.RET();for (size_t i = 0; i < 1024; i++) {- env.MemoryWrite32(i * 4, instructions[i]);+ env.MemoryWrite(i * 4, instructions[i], sizeof(u32));}- env.MemoryWrite32(8888, 0xd4200000);+ env.MemoryWrite(8888, 0xd4200000, sizeof(u32));cpu.SetRegister(30, 8888);cpu.SetRegister(0, 10);diff --git a/src/dynarmic/tests/A64/testenv.h b/src/dynarmic/tests/A64/testenv.hindex f4ddc63a6b..11aa6389f8 100644--- a/src/dynarmic/tests/A64/testenv.h+++ b/src/dynarmic/tests/A64/testenv.h@@ -12,6 +12,7 @@#include "common/assert.h"#include "common/common_types.h"#include "dynarmic/interface/A64/a64.h"+#include "dynarmic/interface/A64/config.h"using Vector = Dynarmic::A64::Vector;@@ -34,64 +35,79 @@ public:return code_mem[index];}- std::uint8_t MemoryRead8(u64 vaddr) override {- if (IsInCodeMem(vaddr)) {- return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];+ u64 MemoryRead(u64 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64):+ return MemoryRead(vaddr, sizeof(u32))+ | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;+ case sizeof(u32):+ return MemoryRead(vaddr, sizeof(u16))+ | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;+ case sizeof(u16):+ return MemoryRead(vaddr, sizeof(u8))+ | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;+ case sizeof(u8): {+ if (IsInCodeMem(vaddr))+ return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];+ if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())+ return it->second;+ return u8(vaddr);+ }+ default:+ std::abort();}- if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())- return it->second;- return u8(vaddr);- }- std::uint16_t MemoryRead16(u64 vaddr) override {- return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;- }- std::uint32_t MemoryRead32(u64 vaddr) override {- return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;- }- std::uint64_t MemoryRead64(u64 vaddr) override {- return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;- }- Vector MemoryRead128(u64 vaddr) override {- return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};}- void MemoryWrite8(u64 vaddr, std::uint8_t value) override {- if (IsInCodeMem(vaddr)) {- code_mem_modified_by_guest = true;+ Vector MemoryRead128(u64 vaddr) override {+ return {+ MemoryRead(vaddr, sizeof(u64)),+ MemoryRead(vaddr + 8, sizeof(u64))+ };+ }++ void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {+ switch (size) {+ case sizeof(u64):+ MemoryWrite(vaddr, u32(value), sizeof(u32));+ MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));+ break;+ case sizeof(u32):+ MemoryWrite(vaddr, u16(value), sizeof(u16));+ MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));+ break;+ case sizeof(u16):+ MemoryWrite(vaddr, u8(value), sizeof(u8));+ MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));+ break;+ case sizeof(u8):+ if (IsInCodeMem(vaddr)) {+ code_mem_modified_by_guest = true;+ }+ modified_memory[vaddr] = value;+ break;+ default:+ std::abort();}- modified_memory[vaddr] = value;- }- void MemoryWrite16(u64 vaddr, std::uint16_t value) override {- MemoryWrite8(vaddr, u8(value));- MemoryWrite8(vaddr + 1, u8(value >> 8));- }- void MemoryWrite32(u64 vaddr, std::uint32_t value) override {- MemoryWrite16(vaddr, u16(value));- MemoryWrite16(vaddr + 2, u16(value >> 16));- }- void MemoryWrite64(u64 vaddr, std::uint64_t value) override {- MemoryWrite32(vaddr, u32(value));- MemoryWrite32(vaddr + 4, u32(value >> 32));}void MemoryWrite128(u64 vaddr, Vector value) override {- MemoryWrite64(vaddr, value[0]);- MemoryWrite64(vaddr + 8, value[1]);+ MemoryWrite(vaddr, value[0], sizeof(u64));+ MemoryWrite(vaddr + 8, value[1], sizeof(u64));}bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {- MemoryWrite8(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u8));return true;}bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {- MemoryWrite16(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u16));return true;}bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {- MemoryWrite32(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u32));return true;}bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {- MemoryWrite64(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u64));return true;}bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {@@ -145,52 +161,46 @@ public:return read<std::uint32_t>(vaddr);}- std::uint8_t MemoryRead8(u64 vaddr) override {- return read<std::uint8_t>(vaddr);- }- std::uint16_t MemoryRead16(u64 vaddr) override {- return read<std::uint16_t>(vaddr);- }- std::uint32_t MemoryRead32(u64 vaddr) override {- return read<std::uint32_t>(vaddr);- }- std::uint64_t MemoryRead64(u64 vaddr) override {- return read<std::uint64_t>(vaddr);+ u64 MemoryRead(u64 vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64): return read<u64>(vaddr);+ case sizeof(u32): return read<u32>(vaddr);+ case sizeof(u16): return read<u16>(vaddr);+ case sizeof(u8): return read<u8>(vaddr);+ default: std::abort();+ }}Vector MemoryRead128(u64 vaddr) override {return read<Vector>(vaddr);}- void MemoryWrite8(u64 vaddr, std::uint8_t value) override {- write(vaddr, value);- }- void MemoryWrite16(u64 vaddr, std::uint16_t value) override {- write(vaddr, value);- }- void MemoryWrite32(u64 vaddr, std::uint32_t value) override {- write(vaddr, value);- }- void MemoryWrite64(u64 vaddr, std::uint64_t value) override {- write(vaddr, value);+ void MemoryWrite(u64 vaddr, std::uint64_t value, size_t size) override {+ switch (size) {+ case sizeof(u64): return write<u64>(vaddr, u64(value));+ case sizeof(u32): return write<u32>(vaddr, u32(value));+ case sizeof(u16): return write<u16>(vaddr, u16(value));+ case sizeof(u8): return write<u8>(vaddr, u8(value));+ default: std::abort();+ }}void MemoryWrite128(u64 vaddr, Vector value) override {write(vaddr, value);}bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {- MemoryWrite8(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u8));return true;}bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {- MemoryWrite16(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u16));return true;}bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {- MemoryWrite32(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u32));return true;}bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {- MemoryWrite64(vaddr, value);+ MemoryWrite(vaddr, value, sizeof(u64));return true;}bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {diff --git a/src/dynarmic/tests/print_info.cpp b/src/dynarmic/tests/print_info.cppindex 5b1c5cfe63..87f4438ad4 100644--- a/src/dynarmic/tests/print_info.cpp+++ b/src/dynarmic/tests/print_info.cpp@@ -18,6 +18,7 @@#include <fmt/format.h>#include <fmt/ostream.h>#include <fmt/ranges.h>+#include "dynarmic/frontend/A32/translate/translate_callbacks.h"#include "dynarmic/mcl/bit.hpp"#include "common/common_types.h"@@ -118,36 +119,47 @@ public:u64 ticks_left = 0;std::map<u32, u8> memory;- std::uint8_t MemoryRead8(u32 vaddr) override {- if (auto iter = memory.find(vaddr); iter != memory.end()) {- return iter->second;+ u64 MemoryRead(Dynarmic::A32::VAddr vaddr, size_t size) override {+ switch (size) {+ case sizeof(u64):+ return MemoryRead(vaddr, sizeof(u32))+ | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;+ case sizeof(u32):+ return MemoryRead(vaddr, sizeof(u16))+ | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;+ case sizeof(u16):+ return MemoryRead(vaddr, sizeof(u8))+ | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;+ case sizeof(u8): {+ if (auto const it = memory.find(vaddr); it != memory.end())+ return it->second;+ return 0;+ }+ default:+ std::abort();}- return 0;- }- std::uint16_t MemoryRead16(u32 vaddr) override {- return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;- }- std::uint32_t MemoryRead32(u32 vaddr) override {- return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;- }- std::uint64_t MemoryRead64(u32 vaddr) override {- return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;}- void MemoryWrite8(u32 vaddr, std::uint8_t value) override {- memory[vaddr] = value;- }- void MemoryWrite16(u32 vaddr, std::uint16_t value) override {- MemoryWrite8(vaddr, static_cast<u8>(value));- MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));- }- void MemoryWrite32(u32 vaddr, std::uint32_t value) override {- MemoryWrite16(vaddr, static_cast<u16>(value));- MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));- }- void MemoryWrite64(u32 vaddr, std::uint64_t value) override {- MemoryWrite32(vaddr, static_cast<u32>(value));- MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));+ void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {+ switch (size) {+ case sizeof(u64):+ MemoryWrite(vaddr, u32(value), sizeof(u32));+ MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));+ break;+ case sizeof(u32):+ MemoryWrite(vaddr, u16(value), sizeof(u16));+ MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));+ break;+ case sizeof(u16):+ MemoryWrite(vaddr, u8(value), sizeof(u8));+ MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));+ break;+ case sizeof(u8):+ memory[vaddr] = value;+ break;+ default:+ std::abort();+ }}void CallSVC(std::uint32_t swi) override {@@ -231,7 +243,7 @@ void ExecuteA32Instruction(u32 instruction) {if (const auto address = get_value()) {fmt::print("value: ");if (const auto value = get_value()) {- env.MemoryWrite32(*address, *value);+ env.MemoryWrite(*address, *value, sizeof(u32));fmt::print("> mem[{:#08x}] = {:#08x}\n", *address, *value);}}@@ -247,8 +259,8 @@ void ExecuteA32Instruction(u32 instruction) {cpu.SetFpscr(fpscr);const u32 initial_pc = regs[15];- env.MemoryWrite32(initial_pc + 0, instruction);- env.MemoryWrite32(initial_pc + 4, 0xEAFFFFFE); // B +0+ env.MemoryWrite(initial_pc + 0, instruction, sizeof(u32));+ env.MemoryWrite(initial_pc + 4, 0xEAFFFFFE, sizeof(u32)); // B +0cpu.Run();fmt::print("{}", fmt::join(cpu.Disassemble(), "\n"));diff --git a/src/dynarmic/tests/unicorn_emu/a32_unicorn.cpp b/src/dynarmic/tests/unicorn_emu/a32_unicorn.cppindex c0e1e13d9b..1fe09cdef0 100644--- a/src/dynarmic/tests/unicorn_emu/a32_unicorn.cpp+++ b/src/dynarmic/tests/unicorn_emu/a32_unicorn.cpp@@ -290,7 +290,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_typeauto page = std::make_unique<Page>();page->address = base_address;for (size_t i = 0; i < page->data.size(); ++i)- page->data[i] = this_->testenv.MemoryRead8(static_cast<u32>(base_address + i));+ page->data[i] = u8(this_->testenv.MemoryRead(u32(base_address + i), sizeof(u8)));uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());if (err == UC_ERR_MAP)@@ -321,24 +321,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_typetemplate<class TestEnvironment>bool A32Unicorn<TestEnvironment>::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u32 start_address, int size, u64 value, void* user_data) {auto* this_ = static_cast<A32Unicorn*>(user_data);-- switch (size) {- case 1:- this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));- break;- case 2:- this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));- break;- case 4:- this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));- break;- case 8:- this_->testenv.MemoryWrite64(start_address, value);- break;- default:- UNREACHABLE();- }-+ this_->testenv.MemoryWrite(start_address, value, size);return true;}diff --git a/src/dynarmic/tests/unicorn_emu/a64_unicorn.cpp b/src/dynarmic/tests/unicorn_emu/a64_unicorn.cppindex c9a194d50a..4afb6a6859 100644--- a/src/dynarmic/tests/unicorn_emu/a64_unicorn.cpp+++ b/src/dynarmic/tests/unicorn_emu/a64_unicorn.cpp@@ -197,7 +197,7 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 staauto page = std::make_unique<Page>();page->address = base_address;for (size_t i = 0; i < page->data.size(); ++i)- page->data[i] = this_->testenv.MemoryRead8(base_address + i);+ page->data[i] = u8(this_->testenv.MemoryRead(base_address + i, sizeof(u8)));uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());if (err == UC_ERR_MAP)@@ -227,23 +227,6 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 stabool A64Unicorn::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u64 start_address, int size, u64 value, void* user_data) {auto* this_ = static_cast<A64Unicorn*>(user_data);-- switch (size) {- case 1:- this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));- break;- case 2:- this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));- break;- case 4:- this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));- break;- case 8:- this_->testenv.MemoryWrite64(start_address, value);- break;- default:- UNREACHABLE();- }-+ this_->testenv.MemoryWrite(start_address, value, size);return true;}