2026-09-16 01:15:21

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

src/common/CMakeLists.txt

@@ -110,6 +110,7 @@ add_library(
     socket_types.h
     sparse_large_vector.cpp
     sparse_large_vector.h
+    spin_lock.h
     stb.cpp
     stb.h
     steady_clock.cpp

src/common/error.cpp

@@ -24,7 +24,7 @@ std::string NativeErrorToString(int e) {
     DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                    FORMAT_MESSAGE_IGNORE_INSERTS,
                                nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
+                               LPSTR(&err_str), 1, nullptr);
     if (!res) {
         return "(FormatMessageA failed to format error)";
     }
@@ -32,9 +32,10 @@ std::string NativeErrorToString(int e) {
     LocalFree(err_str);
     return ret;
 #else
-    char err_str[255];
-#if defined(__ANDROID__) ||                                                                            \
-    (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)))
+    char err_str[256];
+    // See https://github.com/llvm/llvm-project/blob/c8fdb5f8b93c3e1da5e2ff3ba8b18627d6147b51/openmp/runtime/src/kmp_i18n.cpp#L711
+    // musl doesn't provide a macro gate but defines strerror_r() even if _GNU_SOURCE is defined
+#if defined(__managarm__) || (defined(__GLIBC__) || defined(__BIONIC__)) || defined(_GNU_SOURCE)
     // Thread safe (GNU-specific)
     const char* str = strerror_r(e, err_str, sizeof(err_str));
     return std::string(str);

src/common/fs/path_util.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <cctype>
 #include <iostream>
 #include <sstream>
 #include "common/container/unordered_map.h"
@@ -481,80 +480,28 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
                            [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
                path.end());
 
-    std::string root;
-    std::string_view components{path};
-    bool drive_relative = false;
-
-#ifdef _WIN32
-    const bool network = path.size() > 1 && path[0] == type2 && path[1] == type2;
-    const bool drive =
-        path.size() > 1 && std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':';
-
-    if (network) {
-        root.assign(2, type2);
-        components.remove_prefix(2);
-    } else if (drive) {
-        root.assign(path.data(), 2);
-        components.remove_prefix(2);
-        if (!components.empty() && components.front() == type2) {
-            root += type2;
-            components.remove_prefix(1);
-        } else {
-            drive_relative = true;
-        }
-    }
-#endif
-
-    if (root.empty() && !components.empty() && components.front() == type2) {
-        root += type2;
-        components.remove_prefix(1);
-    }
-
-    const auto path_parts = SplitPathComponents(components);
-    std::size_t root_component_count = 0;
-#ifdef _WIN32
-    if (network) {
-        root_component_count = 2;
-
-        const auto is_unc = [](std::string_view part) {
-            return part.size() == 3 && (part[0] == 'U' || part[0] == 'u') &&
-                   (part[1] == 'N' || part[1] == 'n') && (part[2] == 'C' || part[2] == 'c');
-        };
-        if (path_parts.size() >= 2 && path_parts[0] == "?" && is_unc(path_parts[1])) {
-            root_component_count = 4;
-        }
-    }
-#endif
-
+    const bool absolute = !path.empty() && path[0] == type2;
     std::vector<std::string_view> parts;
-    for (std::size_t i = 0; i < path_parts.size(); ++i) {
-        const auto part = path_parts[i];
-        if (i < root_component_count) {
-            parts.push_back(part);
-        } else if (part.empty() || part == ".") {
+
+    for (const auto part : SplitPathComponents(path))
+    {
+        if (part.empty() || part == ".")
             continue;
-        } else if (part == "..") {
-            if (parts.size() > root_component_count) {
-                parts.pop_back();
-            }
-        } else {
-            parts.push_back(part);
-        }
+        if (part == ".." && !parts.empty() && parts.back() != "..")
+            parts.pop_back();
+        else if (part != "..") parts.push_back(part);
     }
 
-    const std::size_t root_length = root.size();
-    std::string resolved = std::move(root);
-    for (std::size_t i = 0; i < parts.size(); ++i) {
-        if (i != 0 || (!resolved.empty() && resolved.back() != type2 && !drive_relative))
+    std::string resolved = absolute ? std::string(1, type2) : std::string{};
+    for (std::size_t i = 0; i < parts.size(); ++i)
+    {
+        if (i != 0)
             resolved += type2;
         resolved.append(parts[i].data(), parts[i].size());
     }
 
     path = std::move(resolved);
 
-    if (!path.empty() && path.size() == root_length) {
-        return path;
-    }
     return std::string(RemoveTrailingSlash(path));
 }
 

src/common/fs/path_util.h

@@ -347,9 +347,8 @@ enum class DirectorySeparator {
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 [[nodiscard]] std::vector<std::string> SplitPathComponentsCopy(std::string_view filename);
 
-// Normalizes directory separators, removes duplicate and non-root trailing separators, and resolves
-// '.' and '..' components without traversing above the path root. Windows drive and UNC roots are
-// preserved.
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
 [[nodiscard]] std::string SanitizePath(
     std::string_view path,
     DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);

src/common/spin_lock.h

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(ARCHITECTURE_x86_64)
+#include <xmmintrin.h>
+#endif
+#include <atomic>
+
+namespace Common {
+
+/// @brief A lock similar to mutex that forces a thread to spin wait instead calling the
+/// supervisor. Should be used on short sequences of code.
+struct SpinLock {
+    SpinLock() noexcept = default;
+    SpinLock(const SpinLock&) noexcept = delete;
+    SpinLock& operator=(const SpinLock&) noexcept = delete;
+    SpinLock(SpinLock&&) noexcept = delete;
+    SpinLock& operator=(SpinLock&&) noexcept = delete;
+
+    inline void lock() noexcept {
+        while (lck.test_and_set(std::memory_order_acquire)) {
+#if defined(ARCHITECTURE_x86_64)
+            _mm_pause();
+#elif defined(ARCHITECTURE_arm64) && defined(_MSC_VER)
+            __yield();
+#elif defined(ARCHITECTURE_arm64)
+            asm("yield");
+#endif
+        }
+    }
+
+    inline void unlock() noexcept {
+        lck.clear(std::memory_order_release);
+    }
+
+    [[nodiscard]] inline bool try_lock() noexcept {
+        return !lck.test_and_set(std::memory_order_acquire);
+    }
+
+    std::atomic_flag lck = ATOMIC_FLAG_INIT;
+};
+
+} // namespace Common

src/common/uuid.cpp

@@ -208,9 +208,9 @@ UUID UUID::MakeRandomRFC4122V4() {
     return uuid;
 }
 
-UUID UUID::MakeRFC4122V5(std::span<u8, 16> sha1) {
+UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
     UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sha1.size());
+    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
     uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
     uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
     return uuid;

src/common/uuid.h

@@ -104,7 +104,7 @@ struct UUID {
     /// @returns A random UUID that is RFC 4122 Version 4 compliant.
     [[nodiscard]] static UUID MakeRandomRFC4122V4();
 
-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 16> sha1);
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);
 
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };

src/core/hle/kernel/k_scheduler.cpp

@@ -465,10 +465,6 @@ void KScheduler::ScheduleImplFiber(KernelCore& kernel) {
         // Check if we need scheduling. If we do, then we can't complete the switch and should
         // retry.
         if (m_state.needs_scheduling.load(std::memory_order_seq_cst)) {
-            // Some libc++ lazily init mutex
-            [[maybe_unused]] auto const can_lock = highest_priority_thread->m_context_guard.try_lock();
-            DEBUG_ASSERT(!can_lock);
-
             // Our switch failed.
             // We should unlock the thread context, and then retry.
             highest_priority_thread->m_context_guard.unlock();
@@ -500,10 +496,6 @@ void KScheduler::Unload(KernelCore& kernel, KThread* thread) {
 
     // Check if the thread is terminated by checking the DPC flags.
     if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
-        // Some libc++ lazily init mutex
-        [[maybe_unused]] auto const can_lock = thread->m_context_guard.try_lock();
-        DEBUG_ASSERT(!can_lock);
-
         // The thread isn't terminated, so we want to unlock it.
         thread->m_context_guard.unlock();
     }

src/core/hle/kernel/k_slab_heap.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -12,6 +12,7 @@
 #include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/spin_lock.h"
 
 namespace Kernel {
 
@@ -29,7 +30,7 @@ public:
     };
 
 public:
-    KSlabHeapImpl() = default;
+    constexpr KSlabHeapImpl() = default;
 
     void Initialize() {
         ASSERT(m_head == nullptr);
@@ -67,7 +68,7 @@ public:
 
 private:
     std::atomic<Node*> m_head{};
-    std::mutex m_lock;
+    Common::SpinLock m_lock;
 };
 
 } // namespace impl

src/core/hle/kernel/k_thread.h

@@ -19,6 +19,7 @@
 
 #include "common/intrusive_red_black_tree.h"
 #include "common/scratch_buffer.h"
+#include "common/spin_lock.h"
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/k_affinity_mask.h"
 #include "core/hle/kernel/k_light_lock.h"
@@ -919,7 +920,7 @@ private:
     bool m_resource_limit_release_hint{};
     bool m_is_kernel_address_key{};
     StackParameters m_stack_parameters{};
-    std::mutex m_context_guard{};
+    Common::SpinLock m_context_guard{};
 
     // For emulation
     std::shared_ptr<Common::Fiber> m_host_context{};

src/core/hle/service/am/service/application_functions.cpp

@@ -347,22 +347,21 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {
 
 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
     LOG_WARNING(Service_AM, "(stubbed)");
-    R_UNLESS(out_pseudo_device_id != nullptr, ResultUnknown);
+    R_UNLESS(out_pseudo_device_id, ResultUnknown);
 
     // This should be hashed with the device specific hash
     // for now this will do
     const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    R_UNLESS(res.first != nullptr, ResultUnknown);
-    std::array<u8, EVP_MAX_MD_SIZE> hash;
+    u8 hash[EVP_MAX_MD_SIZE];
     unsigned int hash_len = 0;
     auto const seed = res.first->raw.seed_for_pseudo_device_id;
     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
     auto const algorithm = EVP_sha1();
     EVP_DigestInit_ex(ctx, algorithm, nullptr);
     EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash.data(), &hash_len);
+    EVP_DigestFinal_ex(ctx, hash, &hash_len);
     EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 16>{hash.begin(), hash.begin() + 16});
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
     R_SUCCEED();
 }
 

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

@@ -90,7 +90,7 @@ template<>
         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.mov(page, qword[r14 + tmp.cvt64() * int(ctx.conf.page_table_log2_stride)]);
     }
 
     // check for marked bit, use as unmapped if marked
@@ -161,12 +161,8 @@ template<>
         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)]);
-    }
+    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+    code.mov(page, qword[r14 + tmp]);
 
     // check for marked bit, use as unmapped if marked
     if (ctx.conf.page_table_marked_bit) {
@@ -182,10 +178,9 @@ template<>
         code.mov(tmp, ctx.conf.page_table_pointer_mask);
         code.and_(page, tmp);
     }
-    // check for sign bit, apply sign extension as needed
     if (ctx.conf.page_table_sign_extension) {
-        code.shl(page, 63 - int(*ctx.conf.page_table_sign_extension));
-        code.sar(page, 63 - int(*ctx.conf.page_table_sign_extension));
+        code.shl(page, *ctx.conf.page_table_sign_extension);
+        code.sar(page, *ctx.conf.page_table_sign_extension);
     }
 
     code.jz(abort, code.T_NEAR);