Reapply "[core/memory] remove indirection handling for unaligned access (#3584)" (#3725)

This reverts commit 59b0e66722.

src/common/x64/cpu_detect.cpp

@@ -106,6 +106,8 @@ static CPUCaps Detect() {
     // Detect family and other miscellaneous features
     if (max_std_fn >= 1) {
         __cpuid(cpu_id, 0x00000001);
+        caps.sse = Common::Bit<25>(cpu_id[3]);
+        caps.sse2 = Common::Bit<26>(cpu_id[3]);
         caps.sse3 = Common::Bit<0>(cpu_id[2]);
         caps.pclmulqdq = Common::Bit<1>(cpu_id[2]);
         caps.ssse3 = Common::Bit<9>(cpu_id[2]);
@@ -148,6 +150,9 @@ static CPUCaps Detect() {
 
             caps.waitpkg = Common::Bit<5>(cpu_id[2]);
             caps.gfni = Common::Bit<8>(cpu_id[2]);
+
+            __cpuidex(cpu_id, 0x00000007, 0x00000001);
+            caps.avx_vnni = caps.avx && Common::Bit<4>(cpu_id[0]);
         }
     }
 
@@ -165,6 +170,7 @@ static CPUCaps Detect() {
         // Check for more features
         __cpuid(cpu_id, 0x80000001);
         caps.lzcnt = Common::Bit<5>(cpu_id[2]);
+        caps.fma4 = Common::Bit<16>(cpu_id[2]);
         caps.monitorx = Common::Bit<29>(cpu_id[2]);
     }
 

src/common/x64/cpu_detect.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-FileCopyrightText: Copyright 2013 Dolphin Emulator Project / 2015 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -39,12 +36,15 @@ struct CPUCaps {
     u32 crystal_frequency;
     u64 tsc_frequency; // Derived from the above three values
 
+    bool sse : 1;
+    bool sse2 : 1;
     bool sse3 : 1;
     bool ssse3 : 1;
     bool sse4_1 : 1;
     bool sse4_2 : 1;
 
     bool avx : 1;
+    bool avx_vnni : 1;
     bool avx2 : 1;
     bool avx512f : 1;
     bool avx512dq : 1;
@@ -59,6 +59,7 @@ struct CPUCaps {
     bool bmi2 : 1;
     bool f16c : 1;
     bool fma : 1;
+    bool fma4 : 1;
     bool gfni : 1;
     bool invariant_tsc : 1;
     bool lzcnt : 1;

src/core/memory.cpp

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <bit>
 #include <cstring>
 #include <mutex>
 #include <span>
@@ -122,83 +123,14 @@ struct Memory::Impl {
         }
     }
 
-    [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
-        Common::PhysicalAddress const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
-        return {};
+    [[nodiscard]] inline u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
+        auto const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        return paddr ? system.DeviceMemory().GetPointer<u8>(paddr + vaddr) : nullptr;
     }
 
-    [[nodiscard]] u8* GetPointerFromDebugMemory(u64 vaddr) const {
-        const Common::PhysicalAddress paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr != 0)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
-        return {};
-    }
-
-    u8 Read8(const Common::ProcessAddress addr) {
-        return Read<u8>(addr);
-    }
-
-    u16 Read16(const Common::ProcessAddress addr) {
-        if ((addr & 1) == 0) {
-            return Read<u16_le>(addr);
-        } else {
-            const u32 a{Read<u8>(addr)};
-            const u32 b{Read<u8>(addr + sizeof(u8))};
-            return static_cast<u16>((b << 8) | a);
-        }
-    }
-
-    u32 Read32(const Common::ProcessAddress addr) {
-        if ((addr & 3) == 0) {
-            return Read<u32_le>(addr);
-        } else {
-            const u32 a{Read16(addr)};
-            const u32 b{Read16(addr + sizeof(u16))};
-            return (b << 16) | a;
-        }
-    }
-
-    u64 Read64(const Common::ProcessAddress addr) {
-        if ((addr & 7) == 0) {
-            return Read<u64_le>(addr);
-        } else {
-            const u32 a{Read32(addr)};
-            const u32 b{Read32(addr + sizeof(u32))};
-            return (static_cast<u64>(b) << 32) | a;
-        }
-    }
-
-    void Write8(const Common::ProcessAddress addr, const u8 data) {
-        Write<u8>(addr, data);
-    }
-
-    void Write16(const Common::ProcessAddress addr, const u16 data) {
-        if ((addr & 1) == 0) {
-            Write<u16_le>(addr, data);
-        } else {
-            Write<u8>(addr, static_cast<u8>(data));
-            Write<u8>(addr + sizeof(u8), static_cast<u8>(data >> 8));
-        }
-    }
-
-    void Write32(const Common::ProcessAddress addr, const u32 data) {
-        if ((addr & 3) == 0) {
-            Write<u32_le>(addr, data);
-        } else {
-            Write16(addr, static_cast<u16>(data));
-            Write16(addr + sizeof(u16), static_cast<u16>(data >> 16));
-        }
-    }
-
-    void Write64(const Common::ProcessAddress addr, const u64 data) {
-        if ((addr & 7) == 0) {
-            Write<u64_le>(addr, data);
-        } else {
-            Write32(addr, static_cast<u32>(data));
-            Write32(addr + sizeof(u32), static_cast<u32>(data >> 32));
-        }
+    [[nodiscard]] inline u8* GetPointerFromDebugMemory(u64 vaddr) const {
+        auto const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        return paddr ? system.DeviceMemory().GetPointer<u8>(paddr + vaddr) : nullptr;
     }
 
     bool WriteExclusive8(const Common::ProcessAddress addr, const u8 data, const u8 expected) {
@@ -564,7 +496,7 @@ struct Memory::Impl {
     }
 
     template<typename F, typename G>
-    [[nodiscard]] u8* GetPointerImpl(u64 vaddr, F&& on_unmapped, G&& on_rasterizer) const {
+    [[nodiscard]] inline u8* GetPointerImpl(u64 vaddr, F&& on_unmapped, G&& on_rasterizer) const {
         // AARCH64 masks the upper 16 bit of all memory accesses
         vaddr &= 0xffffffffffffULL;
         if (AddressSpaceContains(*current_page_table, vaddr, 1)) [[likely]] {
@@ -619,18 +551,42 @@ struct Memory::Impl {
     /// @returns The instance of T read from the specified virtual address.
     template <typename T>
     inline T Read(Common::ProcessAddress vaddr) noexcept requires(std::is_trivially_copyable_v<T>) {
-        const u64 addr = GetInteger(vaddr);
-        if (auto const ptr = GetPointerImpl(addr, [addr]() {
-            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr);
-        }, [&]() {
-            HandleRasterizerDownload(addr, sizeof(T));
-        }); ptr) [[likely]] {
-            // It may be tempting to rewrite this particular section to use "reinterpret_cast";
-            // afterall, it's trivially copyable so surely it can be copied ov- Alignment.
-            // Remember, alignment. memcpy() will deal with all the alignment extremely fast.
-            T result{};
-            std::memcpy(&result, ptr, sizeof(T));
-            return result;
+        auto const addr_c1 = GetInteger(vaddr);
+        if (!(sizeof(T) > 1 && (addr_c1 & 4095) + sizeof(T) > 4096)) {
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerDownload(addr_c1, sizeof(T));
+            }); ptr_c1) {
+                // It may be tempting to rewrite this particular section to use "reinterpret_cast";
+                // afterall, it's trivially copyable so surely it can be copied ov- Alignment.
+                // Remember, alignment. memcpy() will deal with all the alignment extremely fast.
+                T result{};
+                std::memcpy(&result, ptr_c1, sizeof(T));
+                return result;
+            }
+        } else {
+            auto const addr_c2 = (addr_c1 & (~0xfff)) + 0x1000;
+            // page crossing: say if sizeof(T) = 2, vaddr = 4095
+            // 4095 + 2 mod 4096 = 1 => 2 - 1 = 1, thus c1=1, c2=1
+            auto const count_c2 = (addr_c1 + sizeof(T)) & 4095;
+            auto const count_c1 = sizeof(T) - count_c2;
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerDownload(addr_c1, count_c1);
+            }); ptr_c1) {
+                if (auto const ptr_c2 = GetPointerImpl(addr_c2, [addr_c2] {
+                    LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr_c2);
+                }, [&] {
+                    HandleRasterizerDownload(addr_c2, count_c2);
+                }); ptr_c2) {
+                    std::array<char, sizeof(T)> result{};
+                    std::memcpy(result.data() + 0, ptr_c1, count_c1);
+                    std::memcpy(result.data() + count_c1, ptr_c2, count_c2);
+                    return std::bit_cast<T>(result);
+                }
+            }
         }
         return T{};
     }
@@ -640,11 +596,37 @@ struct Memory::Impl {
     /// @tparam T The data type to write to memory.
     template <typename T>
     inline void Write(Common::ProcessAddress vaddr, const T data) noexcept requires(std::is_trivially_copyable_v<T>) {
-        const u64 addr = GetInteger(vaddr);
-        if (auto const ptr = GetPointerImpl(addr, [addr, data]() {
-            LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8, addr, u64(data));
-        }, [&]() { HandleRasterizerWrite(addr, sizeof(T)); }); ptr) [[likely]]
-            std::memcpy(ptr, &data, sizeof(T));
+        auto const addr_c1 = GetInteger(vaddr);
+        if (!(sizeof(T) > 1 && (addr_c1 & 4095) + sizeof(T) > 4096)) {
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerWrite(addr_c1, sizeof(T));
+            }); ptr_c1) {
+                std::memcpy(ptr_c1, &data, sizeof(T));
+            }
+        } else {
+            auto const addr_c2 = (addr_c1 & (~0xfff)) + 0x1000;
+            // page crossing: say if sizeof(T) = 2, vaddr = 4095
+            // 4095 + 2 mod 4096 = 1 => 2 - 1 = 1, thus c1=1, c2=1
+            auto const count_c2 = (addr_c1 + sizeof(T)) & 4095;
+            auto const count_c1 = sizeof(T) - count_c2;
+            if (auto const ptr_c1 = GetPointerImpl(addr_c1, [addr_c1] {
+                LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X}", sizeof(T) * 8, addr_c1);
+            }, [&] {
+                HandleRasterizerWrite(addr_c1, count_c1);
+            }); ptr_c1) {
+                if (auto const ptr_c2 = GetPointerImpl(addr_c2, [addr_c2] {
+                    LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X}", sizeof(T) * 8, addr_c2);
+                }, [&] {
+                    HandleRasterizerWrite(addr_c2, count_c2);
+                }); ptr_c2) {
+                    std::array<char, sizeof(T)> tmp = std::bit_cast<std::array<char, sizeof(T)>>(data);
+                    std::memcpy(ptr_c1, tmp.data() + 0, count_c1);
+                    std::memcpy(ptr_c2, tmp.data() + count_c1, count_c2);
+                }
+            }
+        }
     }
 
     template <typename T>
@@ -842,35 +824,35 @@ const u8* Memory::GetPointer(Common::ProcessAddress vaddr) const {
 }
 
 u8 Memory::Read8(const Common::ProcessAddress addr) {
-    return impl->Read8(addr);
+    return impl->Read<u8>(addr);
 }
 
 u16 Memory::Read16(const Common::ProcessAddress addr) {
-    return impl->Read16(addr);
+    return impl->Read<u16_le>(addr);
 }
 
 u32 Memory::Read32(const Common::ProcessAddress addr) {
-    return impl->Read32(addr);
+    return impl->Read<u32_le>(addr);
 }
 
 u64 Memory::Read64(const Common::ProcessAddress addr) {
-    return impl->Read64(addr);
+    return impl->Read<u64_le>(addr);
 }
 
 void Memory::Write8(Common::ProcessAddress addr, u8 data) {
-    impl->Write8(addr, data);
+    impl->Write<u8>(addr, data);
 }
 
 void Memory::Write16(Common::ProcessAddress addr, u16 data) {
-    impl->Write16(addr, data);
+    impl->Write<u16_le>(addr, data);
 }
 
 void Memory::Write32(Common::ProcessAddress addr, u32 data) {
-    impl->Write32(addr, data);
+    impl->Write<u32_le>(addr, data);
 }
 
 void Memory::Write64(Common::ProcessAddress addr, u64 data) {
-    impl->Write64(addr, data);
+    impl->Write<u64_le>(addr, data);
 }
 
 bool Memory::WriteExclusive8(Common::ProcessAddress addr, u8 data, u8 expected) {

src/qt_common/qt_common.cpp

@@ -223,7 +223,7 @@ void Init(QWidget* root) {
         } else if (caps.avx2) {
             cpu_string += '2';
         }
-        if (caps.fma) {
+        if (caps.fma || caps.fma4) {
             cpu_string += " | FMA";
         }
     }

src/yuzu/bootmanager.cpp

@@ -54,7 +54,6 @@
 #include "input_common/drivers/mouse.h"
 #include "input_common/drivers/tas_input.h"
 #include "input_common/drivers/touch_screen.h"
-#include "input_common/drivers/camera.h"
 #include "input_common/main.h"
 #include "qt_common/qt_common.h"
 #include "video_core/gpu.h"

src/yuzu/main_window.cpp

@@ -3120,7 +3120,7 @@ void MainWindow::OnMenuReportCompatibility() {
 
     // #if defined(ARCHITECTURE_x86_64) && !defined(__APPLE__)
     //     const auto& caps = Common::GetCPUCaps();
-    //     const bool has_fma = caps.fma;
+    //     const bool has_fma = caps.fma || caps.fma4;
     //     const auto processor_count = std::thread::hardware_concurrency();
     //     const bool has_4threads = processor_count == 0 || processor_count >= 4;
     //     const bool has_8gb_ram = Common::GetMemInfo().TotalPhysicalMemory >= 8_GiB;