2026-09-17 05:45:29

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/common/cpu_features.cpp

@@ -244,8 +244,7 @@ WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
     , ns_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_) : 0}
     , us_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_) : 0}
     , ms_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_) : 0}
-    , rdtsc_ns_integer{invariant_ ? rdtsc_frequency_ / NsRatio::den : 1}
-    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_ % NsRatio::den, NsRatio::den) : 0}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
     , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
     , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
     , invariant{invariant_}
@@ -292,7 +291,7 @@ bool WallClock::IsNative() const {
 }
 
 u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
-    return ns.count() * rdtsc_ns_integer + MultiplyHigh(ns.count(), rdtsc_ns_factor);
+    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
 }
 #elif defined(HAS_NCE)
 namespace {
@@ -417,7 +416,7 @@ u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
 const WallClock g_wall_clock = [] {
 #if defined(ARCHITECTURE_x86_64)
     auto const& caps = Common::g_cpu_caps;
-    return WallClock(caps.invariant_tsc && caps.tsc_frequency > std::nano::den, caps.tsc_frequency);
+    return WallClock(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den, caps.tsc_frequency);
 #elif defined(HAS_NCE)
     return WallClock(false, 1);
 #else

src/common/cpu_features.h

@@ -96,7 +96,6 @@ public:
     u64 ns_rdtsc_factor;
     u64 us_rdtsc_factor;
     u64 ms_rdtsc_factor;
-    u64 rdtsc_ns_integer;
     u64 rdtsc_ns_factor;
     u64 cntpct_rdtsc_factor;
     u64 gputick_rdtsc_factor;

src/common/settings.h

@@ -649,10 +649,10 @@ struct Values {
 
     SwitchableSetting<bool> fix_bloom_effects{linkage, false, "fix_bloom_effects",
                                                      Category::RendererHacks};
-
+#ifdef __ANDROID__
     SwitchableSetting<bool> emulate_bgr565{linkage, false, "emulate_bgr565",
                                             Category::RendererHacks};
-
+#endif
     SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                          Category::RendererHacks};
     SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp

@@ -11,7 +11,8 @@
 #include <tuple>
 #include <utility>
 
-#include "common/logging.h"
+#include <fmt/format.h>
+#include <fmt/ostream.h>
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp

@@ -11,7 +11,8 @@
 #include <tuple>
 #include <utility>
 
-#include "common/logging.h"
+#include <fmt/format.h>
+#include <fmt/ostream.h>
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc

@@ -1,6 +1,3 @@
-// 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
@@ -14,6 +11,10 @@
 #define AxxJitState CONCATENATE_TOKENS(Axx, JitState)
 #define AxxUserConfig Axx::UserConfig
 
+namespace {
+using Vector = std::array<u64, 2>;
+}
+
 std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitContext& ctx, IR::Inst* inst) const {
     if (!conf.fastmem_pointer || !exception_handler.SupportsFastmem()) {
         return std::nullopt;
@@ -27,19 +28,22 @@ std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitC
 }
 
 FakeCall AxxEmitX64::FastmemCallback(u64 rip_) {
-    if (auto const it = fastmem_patch_info.find(rip_); it != fastmem_patch_info.end()) {
+    const auto iter = fastmem_patch_info.find(rip_);
+    if (iter != fastmem_patch_info.end()) {
         FakeCall result{
-            .call_rip = it->second.callback,
-            .ret_rip = it->second.resume_rip,
+            .call_rip = iter->second.callback,
+            .ret_rip = iter->second.resume_rip,
         };
-        if (it->second.recompile) {
-            const auto marker = it->second.marker;
+        if (iter->second.recompile) {
+            const auto marker = iter->second.marker;
             do_not_fastmem.insert(marker);
             InvalidateBasicBlocks({std::get<0>(marker)});
         }
         return result;
     }
-    UNREACHABLE_MSG("SIGSEGV @ JIT, rip={:#016x}", rip_); //("iter != fastmem_patch_info.end()");
+    fmt::print("dynarmic: Segfault happened within JITted code at rip = {:016x}\n"
+        "Segfault wasn't at a fastmem patch location!\n", rip_);
+    UNREACHABLE(); //("iter != fastmem_patch_info.end()");
 }
 
 template<std::size_t bitsize, auto callback>
@@ -79,17 +83,22 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128 ? ctx.reg_alloc.ScratchXmm(code).getIdx() : ctx.reg_alloc.ScratchGpr(code).getIdx();
+
     const auto wrapped_fn = read_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
+
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto src_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
+
         const auto location = EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
+
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
+
             fastmem_patch_info.emplace(
                 std::bit_cast<u64>(location),
                 FastmemPatchInfo{
@@ -98,23 +107,25 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
                     *fastmem_marker,
                     conf.recompile_on_fastmem_failure,
                 });
+
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else if (conf.page_table) {
+    } else {
         // Use page table
+        ASSERT(conf.page_table);
         const auto src_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
+
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
-        UNREACHABLE();
     }
     code.L(*end);
+
     if constexpr (bitsize == 128) {
         ctx.reg_alloc.DefineValue(code, inst, Xbyak::Xmm{value_idx});
     } else {
@@ -157,16 +168,18 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128
-        ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
-        : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
+                            ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
+                            : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
 
     const auto wrapped_fn = write_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
+
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto dest_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
+
         const auto location = EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
@@ -185,8 +198,9 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else if (conf.page_table) {
+    } else {
         // Use page table
+        ASSERT(conf.page_table);
         const auto dest_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
@@ -196,8 +210,6 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
-        UNREACHABLE();
     }
     code.L(*end);
 }
@@ -239,8 +251,8 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
             code.mfence();
         }
         code.CallLambda(
-            [](AxxUserConfig& conf, Axx::VAddr vaddr, u128& ret) {
-                ret = conf.global_monitor->ReadAndMark<u128>(conf.processor_id, vaddr, [&]() -> u128 {
+            [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
+                ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
                     return (conf.callbacks->*callback)(vaddr);
                 });
             });
@@ -291,8 +303,8 @@ void AxxEmitX64::EmitExclusiveWriteMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         ctx.reg_alloc.AllocStackSpace(code, 16 + ABI_SHADOW_SPACE);
         code.lea(code.ABI_PARAM3, ptr[rsp + ABI_SHADOW_SPACE]);
         code.movaps(xword[code.ABI_PARAM3], xmm1);
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, u128& value) -> u32 {
-            return conf.global_monitor->DoExclusiveOperation<u128>(conf.processor_id, vaddr, [&](u128 expected) -> bool {
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& value) -> u32 {
+            return conf.global_monitor->DoExclusiveOperation<Vector>(conf.processor_id, vaddr, [&](Vector expected) -> bool {
                 return (conf.callbacks->*callback)(vaddr, value, expected);
             }) ? 0 : 1;
         });

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -135,16 +135,10 @@ template<>
     if (unused_top_bits == 0) {
         code.mov(tmp, vaddr);
         code.shr(tmp, int(page_table_const_bits));
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
     } else if (ctx.conf.silently_mirror_page_table) {
         if (valid_page_index_bits >= 32) {
             if (code.HasHostFeature(HostFeature::BMI2)) {
-                auto const bit_count = ctx.reg_alloc.ScratchGpr(code);
+                const Xbyak::Reg64 bit_count = ctx.reg_alloc.ScratchGpr(code);
                 code.mov(bit_count, unused_top_bits);
                 code.bzhi(tmp, vaddr, bit_count);
                 code.shr(tmp, int(page_table_const_bits));
@@ -159,31 +153,19 @@ template<>
             code.shr(tmp, int(page_table_const_bits));
             code.and_(tmp, u32((1 << valid_page_index_bits) - 1));
         }
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
     } else {
-        // Common VA sizes: 39 - 12 => 27, 42 - 12 => 30
-        // Check if bits outside of VA space are non-zero
         ASSERT(valid_page_index_bits < 32);
         code.mov(tmp, vaddr);
-        if (ctx.conf.check_halt_on_memory_access) {
-            auto const tmp2 = ctx.reg_alloc.ScratchGpr(code);
-            code.mov(tmp2, u64(-(1ull << valid_page_index_bits) << page_table_const_bits));
-            code.test(tmp, tmp2);
-            code.jnz(abort, code.T_NEAR);
-            ctx.reg_alloc.Release(tmp2);
-        }
         code.shr(tmp, int(page_table_const_bits));
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
+        code.test(tmp, u32(-(1 << valid_page_index_bits)));
+        code.jnz(abort, code.T_NEAR);
+    }
+
+    if (ctx.conf.page_table_log2_stride > 3) {
+        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+        code.mov(page, qword[r14 + tmp.cvt64()]);
+    } else {
+        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
     }
 
     // check for marked bit, use as unmapped if marked
@@ -211,7 +193,7 @@ template<>
         return page + vaddr;
     }
     code.mov(tmp, vaddr);
-    code.and_(tmp, u32(page_table_const_mask));
+    code.and_(tmp, static_cast<u32>(page_table_const_mask));
     return page + tmp;
 }
 

src/video_core/vulkan_common/vulkan_device.cpp

@@ -993,7 +993,11 @@ bool Device::HasTimelineSemaphore() const {
 }
 
 bool Device::MustEmulateBGR565() const {
+#ifdef __ANDROID__
     return Settings::values.emulate_bgr565.GetValue();
+#else
+    return false;
+#endif
 }
 
 bool Device::GetSuitability(bool requires_swapchain) {

src/yuzu/configuration/shared_widget.cpp

@@ -774,7 +774,7 @@ Builder::~Builder() = default;
 
 static bool IsAndroidOnly(const Settings::BasicSetting& setting) {
     const std::string& label = setting.GetLabel();
-    return label.starts_with("frame_gen") || label == "emulate_bgr565";
+    return label.starts_with("frame_gen");
 }
 
 Widget* Builder::BuildWidget(Settings::BasicSetting* setting,