Msvc suppress 4324

Disables "structure was padded due to alignment specifier" warnings.

CMakeLists.txt

@@ -411,13 +411,12 @@ if (CONAN_REQUIRED_LIBS)
     # Download conan.cmake automatically, you can also just copy the conan.cmake file
     if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
         message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        # TODO: Use a tagged release. The latest tagged release does not support VS2022 as of this writing.
-        file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/43e385830ee35377dbd2dcbe8d5a9e750301ea00/conan.cmake"
+        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
                         "${CMAKE_BINARY_DIR}/conan.cmake")
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    conan_check(VERSION 1.41.0 REQUIRED)
+    conan_check(VERSION 1.24.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
     # We don't need to add it through find_package or anything since the other two can find it just fine

src/CMakeLists.txt

@@ -32,7 +32,6 @@ if (MSVC)
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
-    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
         /Zi
@@ -45,7 +44,6 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
-        /GT
 
         # External headers diagnostics
         /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -71,10 +69,6 @@ if (MSVC)
         /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
-    if (ARCHITECTURE_x86_64)
-        add_compile_options(/QIntel-jcc-erratum)
-    endif()
-
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
 

src/common/CMakeLists.txt

@@ -55,7 +55,6 @@ add_library(common STATIC
     dynamic_library.h
     error.cpp
     error.h
-    expected.h
     fiber.cpp
     fiber.h
     fs/file.cpp

src/common/alignment.h

@@ -64,7 +64,7 @@ public:
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
     using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::false_type;
+    using is_always_equal = std::true_type;
 
     constexpr AlignmentAllocator() noexcept = default;
 
@@ -83,11 +83,6 @@ public:
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
-
-    template <typename T2, size_t Align2>
-    constexpr bool operator==(const AlignmentAllocator<T2, Align2>&) const noexcept {
-        return std::is_same_v<T, T2> && Align == Align2;
-    }
 };
 
 } // namespace Common

src/common/expected.h

@@ -1,987 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This is based on the proposed implementation of std::expected (P0323)
-// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace Common {
-
-template <typename T, typename E>
-class Expected;
-
-template <typename E>
-class Unexpected {
-public:
-    Unexpected() = delete;
-
-    constexpr explicit Unexpected(const E& e) : m_val{e} {}
-
-    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
-
-    constexpr E& value() & {
-        return m_val;
-    }
-
-    constexpr const E& value() const& {
-        return m_val;
-    }
-
-    constexpr E&& value() && {
-        return std::move(m_val);
-    }
-
-    constexpr const E&& value() const&& {
-        return std::move(m_val);
-    }
-
-private:
-    E m_val;
-};
-
-template <typename E>
-constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
-    return lhs.value() <=> rhs.value();
-}
-
-struct unexpect_t {
-    constexpr explicit unexpect_t() = default;
-};
-
-namespace detail {
-
-struct no_init_t {
-    constexpr explicit no_init_t() = default;
-};
-
-/**
- * This specialization is for when T is not trivially destructible,
- * so the destructor must be called on destruction of `expected'
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() {
-        if (m_has_val) {
-            m_val.~T();
-        }
-    }
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-/**
- * This specialization is for when T is trivially destructible,
- * so the destructor of `expected` can be trivial
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base<T, E, true> {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() = default;
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-template <typename T, typename E>
-struct expected_operations_base : expected_storage_base<T, E> {
-    using expected_storage_base<T, E>::expected_storage_base;
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
-        this->m_has_val = true;
-    }
-
-    template <typename Rhs>
-    void construct_with(Rhs&& rhs) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
-        this->m_has_val = true;
-    }
-
-    template <typename... Args>
-    void construct_error(Args&&... args) noexcept {
-        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
-        this->m_has_val = false;
-    }
-
-    void assign(const expected_operations_base& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    void assign(expected_operations_base&& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    template <typename Rhs>
-    void assign_common(Rhs&& rhs) {
-        if (this->m_has_val) {
-            if (rhs.m_has_val) {
-                get() = std::forward<Rhs>(rhs).get();
-            } else {
-                destroy_val();
-                construct_error(std::forward<Rhs>(rhs).geterr());
-            }
-        } else {
-            if (!rhs.m_has_val) {
-                geterr() = std::forward<Rhs>(rhs).geterr();
-            }
-        }
-    }
-
-    bool has_value() const {
-        return this->m_has_val;
-    }
-
-    constexpr T& get() & {
-        return this->m_val;
-    }
-
-    constexpr const T& get() const& {
-        return this->m_val;
-    }
-
-    constexpr T&& get() && {
-        return std::move(this->m_val);
-    }
-
-    constexpr const T&& get() const&& {
-        return std::move(this->m_val);
-    }
-
-    constexpr Unexpected<E>& geterr() & {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& geterr() const& {
-        return this->m_unexpect;
-    }
-
-    constexpr Unexpected<E>&& geterr() && {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr const Unexpected<E>&& geterr() const&& {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr void destroy_val() {
-        get().~T();
-    }
-};
-
-/**
- * This manages conditionally having a trivial copy constructor
- * This specialization is for when T is trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-
-    expected_copy_base() = default;
-
-    expected_copy_base(const expected_copy_base& rhs)
-        : expected_operations_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(rhs);
-        } else {
-            this->construct_error(rhs.geterr());
-        }
-    }
-
-    expected_copy_base(expected_copy_base&&) = default;
-
-    expected_copy_base& operator=(const expected_copy_base&) = default;
-
-    expected_copy_base& operator=(expected_copy_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move constructor
- * This specialization is for when T is trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-};
-
-/**
- * This specialization is for when T is not trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-
-    expected_move_base() = default;
-
-    expected_move_base(const expected_move_base&) = default;
-
-    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
-        : expected_copy_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(std::move(rhs));
-        } else {
-            this->construct_error(std::move(rhs.geterr()));
-        }
-    }
-
-    expected_move_base& operator=(const expected_move_base&) = default;
-
-    expected_move_base& operator=(expected_move_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial copy assignment operator
- * This specialization is for when T is trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
-                                    std::is_trivially_copy_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-
-    expected_copy_assign_base() = default;
-
-    expected_copy_assign_base(const expected_copy_assign_base&) = default;
-
-    expected_copy_assign_base(expected_copy_assign_base&&) = default;
-
-    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
-        this->assign(rhs);
-        return *this;
-    }
-
-    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move assignment operator
- * This specialization is for when T is trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
-                                    std::is_trivially_move_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
-
-/**
- * This specialization is for when T is not trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-
-    expected_move_assign_base() = default;
-
-    expected_move_assign_base(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base(expected_move_assign_base&&) = default;
-
-    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
-        std::conjunction_v<std::is_nothrow_move_constructible<T>,
-                           std::is_nothrow_move_assignable<T>>) {
-        this->assign(std::move(rhs));
-        return *this;
-    }
-};
-
-/**
- * expected_delete_ctor_base will conditionally delete copy and move constructors
- * depending on whether T is copy/move constructible
- * Additionally, this requires E to be copy/move constructible
- */
-template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
-          bool EnableMove = std::is_move_constructible_v<T>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, true, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, true> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-/**
- * expected_delete_assign_base will conditionally delete copy and move assignment operators
- * depending on whether T is copy/move constructible + assignable
- * Additionally, this requires E to be copy/move constructible + assignable
- */
-template <
-    typename T, typename E,
-    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
-    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, true, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, true> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-/**
- * This is needed to be able to construct the expected_default_ctor_base which follows,
- * while still conditionally deleting the default constructor.
- */
-struct default_constructor_tag {
-    constexpr explicit default_constructor_tag() = default;
-};
-
-/**
- * expected_default_ctor_base will ensure that expected
- * has a deleted default constructor if T is not default constructible
- * This specialization is for when T is default constructible
- */
-template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
-struct expected_default_ctor_base {
-    constexpr expected_default_ctor_base() noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E>
-struct expected_default_ctor_base<T, E, false> {
-    constexpr expected_default_ctor_base() noexcept = delete;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E, typename U>
-using expected_enable_forward_value =
-    std::enable_if_t<std::is_constructible_v<T, U&&> &&
-                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
-                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
-
-template <typename T, typename E, typename U, typename G, typename UR, typename GR>
-using expected_enable_from_other = std::enable_if_t<
-    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
-    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&&> &&
-    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&&, T>>;
-
-} // namespace detail
-
-template <typename T, typename E>
-class Expected : private detail::expected_move_assign_base<T, E>,
-                 private detail::expected_delete_ctor_base<T, E>,
-                 private detail::expected_delete_assign_base<T, E>,
-                 private detail::expected_default_ctor_base<T, E> {
-public:
-    using value_type = T;
-    using error_type = E;
-    using unexpected_type = Unexpected<E>;
-
-    constexpr Expected() = default;
-    constexpr Expected(const Expected&) = default;
-    constexpr Expected(Expected&&) = default;
-    Expected& operator=(const Expected&) = default;
-    Expected& operator=(Expected&&) = default;
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr Expected(std::in_place_t, Args&&... args)
-        : impl_base{std::in_place, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{std::in_place, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr explicit Expected(const Unexpected<G>& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G> const& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit Expected(unexpect_t, Args&&... args)
-        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
-                                 std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr explicit Expected(const Expected<U, G>& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
-                                std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr explicit Expected(Expected<U, G>&& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
-                                               std::is_assignable_v<G&, G>>* = nullptr>
-    Expected& operator=(const Unexpected<G>& rhs) {
-        if (!has_value()) {
-            err() = rhs;
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{rhs};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
-                                               std::is_move_assignable_v<G>>* = nullptr>
-    Expected& operator=(Unexpected<G>&& rhs) noexcept {
-        if (!has_value()) {
-            err() = std::move(rhs);
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{std::move(rhs)};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                               Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                                Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    constexpr T* operator->() {
-        return valptr();
-    }
-
-    constexpr const T* operator->() const {
-        return valptr();
-    }
-
-    template <typename U = T>
-    constexpr U& operator*() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& operator*() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& operator*() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& operator*() const&& {
-        return std::move(val());
-    }
-
-    constexpr bool has_value() const noexcept {
-        return this->m_has_val;
-    }
-
-    constexpr explicit operator bool() const noexcept {
-        return this->m_has_val;
-    }
-
-    template <typename U = T>
-    constexpr U& value() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& value() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& value() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& value() const&& {
-        return std::move(val());
-    }
-
-    constexpr E& error() & {
-        return err().value();
-    }
-
-    constexpr const E& error() const& {
-        return err().value();
-    }
-
-    constexpr E&& error() && {
-        return std::move(err().value());
-    }
-
-    constexpr const E&& error() const&& {
-        return std::move(err().value());
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) const& {
-        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be copy-constructible and convertible from U&&");
-        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) && {
-        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be move-constructible and convertible from U&&");
-        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-    }
-
-private:
-    static_assert(!std::is_reference_v<T>, "T must not be a reference");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
-                  "T must not be std::in_place_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
-                  "T must not be Unexpected<E>");
-    static_assert(!std::is_reference_v<E>, "E must not be a reference");
-
-    T* valptr() {
-        return std::addressof(this->m_val);
-    }
-
-    const T* valptr() const {
-        return std::addressof(this->m_val);
-    }
-
-    Unexpected<E>* errptr() {
-        return std::addressof(this->m_unexpect);
-    }
-
-    const Unexpected<E>* errptr() const {
-        return std::addressof(this->m_unexpect);
-    }
-
-    template <typename U = T>
-    constexpr U& val() {
-        return this->m_val;
-    }
-
-    template <typename U = T>
-    constexpr const U& val() const {
-        return this->m_val;
-    }
-
-    constexpr Unexpected<E>& err() {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& err() const {
-        return this->m_unexpect;
-    }
-
-    using impl_base = detail::expected_move_assign_base<T, E>;
-    using ctor_base = detail::expected_default_ctor_base<T, E>;
-};
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return (lhs.has_value() != rhs.has_value())
-               ? false
-               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const Expected<T, E>& x, const U& v) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const U& v, const Expected<T, E>& x) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
-    return !operator==(x, v);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
-    return !operator==(v, x);
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return !operator==(x, e);
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return !operator==(e, x);
-}
-
-} // namespace Common

src/common/logging/backend.cpp

@@ -186,6 +186,10 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
+    static void Start() {
+        instance->StartBackendThread();
+    }
+
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -201,54 +205,59 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string message) {
+                   const char* function, const char* message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
-        message_queue.Push(entry);
+            CreateEntry(log_class, log_level, filename, line_num, function, message);
+        message_queue.push(entry);
     }
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
-              Common::SetCurrentThreadName("yuzu:Log");
-              Entry entry;
-              const auto write_logs = [this, &entry]() {
-                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-              };
-              while (true) {
-                  entry = message_queue.PopWait();
-                  if (entry.final_entry) {
-                      break;
-                  }
-                  write_logs();
-              }
-              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-              // case where a system is repeatedly spamming logs even on close.
-              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-              while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                  write_logs();
-              }
-          })} {}
+        : filter{filter_}, file_backend{file_backend_filename} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
+    void StartBackendThread() {
+        backend_thread = std::thread([this] {
+            Common::SetCurrentThreadName("yuzu:Log");
+            Entry entry;
+            const auto write_logs = [this, &entry]() {
+                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+            };
+            while (true) {
+                if (!message_queue.try_pop(entry)) {
+                    continue;
+                }
+                if (entry.final_entry) {
+                    break;
+                }
+                write_logs();
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+            // case where a system is repeatedly spamming logs even on close.
+            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+            while (max_logs_to_write-- && message_queue.try_pop(entry)) {
+                write_logs();
+            }
+        });
+    }
+
     void StopBackendThread() {
         Entry stop_entry{};
         stop_entry.final_entry = true;
-        message_queue.Push(stop_entry);
+        message_queue.push(stop_entry);
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string message) const {
+                      const char* function, const char* message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
-
         return {
             .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
             .log_class = log_class,
@@ -256,7 +265,7 @@ private:
             .filename = filename,
             .line_num = line_nr,
             .function = function,
-            .message = std::move(message),
+            .message = message,
             .final_entry = false,
         };
     }
@@ -279,7 +288,7 @@ private:
     FileBackend file_backend;
 
     std::thread backend_thread;
-    MPSCQueue<Entry> message_queue{};
+    MPMCQueue<Entry> message_queue{100000};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -288,6 +297,10 @@ void Initialize() {
     Impl::Initialize();
 }
 
+void Start() {
+    Impl::Start();
+}
+
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }
@@ -301,11 +314,14 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
+                       unsigned int line_num, const char* function, fmt::string_view format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
-                                   fmt::vformat(format, args));
+        std::string message = fmt::vformat(format, args);
+        auto len = message.size() + 1;
+        char* msg = new char[len];
+        memcpy(msg, message.data(), len);
+        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function, msg);
     }
 }
 } // namespace Common::Log

src/common/logging/backend.h

@@ -14,6 +14,8 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
+void Start();
+
 void DisableLoggingInTests();
 
 /**

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
+                       unsigned int line_num, const char* function, fmt::string_view format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, const char* format, const Args&... args) {
+                   const char* function, fmt::string_view format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/common/logging/log_entry.h

@@ -14,14 +14,14 @@ namespace Common::Log {
  * A log entry. Log entries are store in a structured format to permit more varied output
  * formatting on different frontends, as well as facilitating filtering and aggregation.
  */
-struct Entry {
+struct Entry final {
     std::chrono::microseconds timestamp;
     Class log_class{};
     Level log_level{};
     const char* filename = nullptr;
     unsigned int line_num = 0;
-    std::string function;
-    std::string message;
+    const char* function;
+    const char* message;
     bool final_entry = false;
 };
 

src/common/settings.h

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -486,9 +487,9 @@ struct Values {
     // System
     Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
-    std::optional<s64> custom_rtc;
+    std::optional<std::chrono::seconds> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
-    s64 custom_rtc_differential;
+    std::chrono::seconds custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
     RangedSetting<s32> language_index{1, 0, 17, "language_index"};

src/common/threadsafe_queue.h

@@ -1,195 +1,287 @@
-// Copyright 2010 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
+/*
+Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
 
 #pragma once
 
-// a simple lockless thread-safe,
-// single reader, single writer queue
-
 #include <atomic>
-#include <condition_variable>
-#include <cstddef>
-#include <mutex>
-#include <utility>
+#include <cassert>
+#include <cstddef> // offsetof
+#include <limits>
+#include <memory>
+#include <new> // std::hardware_destructive_interference_size
+#include <stdexcept>
+
+#ifndef __cpp_aligned_new
+#ifdef _WIN32
+#include <malloc.h> // _aligned_malloc
+#else
+#include <stdlib.h> // posix_memalign
+#endif
+#endif
 
 namespace Common {
-template <typename T, bool with_stop_token = false>
-class SPSCQueue {
+namespace mpmc {
+#ifdef __cpp_lib_hardware_interference_size
+static constexpr size_t hardwareInterferenceSize = std::hardware_destructive_interference_size;
+#else
+static constexpr size_t hardwareInterferenceSize = 64;
+#endif
+
+#if defined(_MSC_VER)
+// Disables "structure was padded due to alignment specifier" warnings.
+#pragma warning(suppress : 4324)
+#endif
+
+#if defined(__cpp_aligned_new)
+template <typename T>
+using AlignedAllocator = std::allocator<T>;
+#else
+template <typename T>
+struct AlignedAllocator {
+    using value_type = T;
+
+    T* allocate(std::size_t n) {
+        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
+            throw std::bad_array_new_length();
+        }
+#ifdef _WIN32
+        auto* p = static_cast<T*>(_aligned_malloc(sizeof(T) * n, alignof(T)));
+        if (p == nullptr) {
+            throw std::bad_alloc();
+        }
+#else
+        T* p;
+        if (posix_memalign(reinterpret_cast<void**>(&p), alignof(T), sizeof(T) * n) != 0) {
+            throw std::bad_alloc();
+        }
+#endif
+        return p;
+    }
+
+    void deallocate(T* p, std::size_t) {
+#ifdef _WIN32
+        _aligned_free(p);
+#else
+        free(p);
+#endif
+    }
+};
+#endif
+
+template <typename T>
+struct Slot {
+    ~Slot() noexcept {
+        if (turn & 1) {
+            destroy();
+        }
+    }
+
+    template <typename... Args>
+    void construct(Args&&... args) noexcept {
+        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
+                      "T must be nothrow constructible with Args&&...");
+        new (&storage) T(std::forward<Args>(args)...);
+    }
+
+    void destroy() noexcept {
+        static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
+        reinterpret_cast<T*>(&storage)->~T();
+    }
+
+    T&& move() noexcept {
+        return reinterpret_cast<T&&>(storage);
+    }
+
+    // Align to avoid false sharing between adjacent slots
+    alignas(hardwareInterferenceSize) std::atomic<size_t> turn = {0};
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
+};
+
+template <typename T, typename Allocator = AlignedAllocator<Slot<T>>>
+class Queue {
+private:
+    static_assert(std::is_nothrow_copy_assignable<T>::value ||
+                      std::is_nothrow_move_assignable<T>::value,
+                  "T must be nothrow copy or move assignable");
+
+    static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
+
 public:
-    SPSCQueue() {
-        write_ptr = read_ptr = new ElementPtr();
-    }
-    ~SPSCQueue() {
-        // this will empty out the whole queue
-        delete read_ptr;
+    explicit Queue(const size_t capacity, const Allocator& allocator = Allocator())
+        : capacity_(capacity), allocator_(allocator), head_(0), tail_(0) {
+        if (capacity_ < 1) {
+            throw std::invalid_argument("capacity < 1");
+        }
+        // Allocate one extra slot to prevent false sharing on the last slot
+        slots_ = allocator_.allocate(capacity_ + 1);
+        // Allocators are not required to honor alignment for over-aligned types
+        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
+        // alignment here
+        if (reinterpret_cast<size_t>(slots_) % alignof(Slot<T>) != 0) {
+            allocator_.deallocate(slots_, capacity_ + 1);
+            throw std::bad_alloc();
+        }
+        for (size_t i = 0; i < capacity_; ++i) {
+            new (&slots_[i]) Slot<T>();
+        }
+        static_assert(alignof(Slot<T>) == hardwareInterferenceSize,
+                      "Slot must be aligned to cache line boundary to prevent false sharing");
+        static_assert(sizeof(Slot<T>) % hardwareInterferenceSize == 0,
+                      "Slot size must be a multiple of cache line size to prevent "
+                      "false sharing between adjacent slots");
+        static_assert(sizeof(Queue) % hardwareInterferenceSize == 0,
+                      "Queue size must be a multiple of cache line size to "
+                      "prevent false sharing between adjacent queues");
+        static_assert(offsetof(Queue, tail_) - offsetof(Queue, head_) ==
+                          static_cast<std::ptrdiff_t>(hardwareInterferenceSize),
+                      "head and tail must be a cache line apart to prevent false sharing");
     }
 
-    [[nodiscard]] std::size_t Size() const {
-        return size.load();
+    ~Queue() noexcept {
+        for (size_t i = 0; i < capacity_; ++i) {
+            slots_[i].~Slot();
+        }
+        allocator_.deallocate(slots_, capacity_ + 1);
     }
 
-    [[nodiscard]] bool Empty() const {
-        return Size() == 0;
+    // non-copyable and non-movable
+    Queue(const Queue&) = delete;
+    Queue& operator=(const Queue&) = delete;
+
+    template <typename... Args>
+    void emplace(Args&&... args) noexcept {
+        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
+                      "T must be nothrow constructible with Args&&...");
+        auto const head = head_.fetch_add(1);
+        auto& slot = slots_[idx(head)];
+        while (turn(head) * 2 != slot.turn.load(std::memory_order_acquire))
+            ;
+        slot.construct(std::forward<Args>(args)...);
+        slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
     }
 
-    [[nodiscard]] T& Front() const {
-        return read_ptr->current;
-    }
-
-    template <typename Arg>
-    void Push(Arg&& t) {
-        // create the element, add it to the queue
-        write_ptr->current = std::forward<Arg>(t);
-        // set the next pointer to a new element ptr
-        // then advance the write pointer
-        ElementPtr* new_ptr = new ElementPtr();
-        write_ptr->next.store(new_ptr, std::memory_order_release);
-        write_ptr = new_ptr;
-        ++size;
-
-        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
-        // line before cv.wait
-        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
-        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
-        std::lock_guard lock{cv_mutex};
-        cv.notify_one();
-    }
-
-    void Pop() {
-        --size;
-
-        ElementPtr* tmpptr = read_ptr;
-        // advance the read pointer
-        read_ptr = tmpptr->next.load();
-        // set the next element to nullptr to stop the recursive deletion
-        tmpptr->next.store(nullptr);
-        delete tmpptr; // this also deletes the element
-    }
-
-    bool Pop(T& t) {
-        if (Empty())
-            return false;
-
-        --size;
-
-        ElementPtr* tmpptr = read_ptr;
-        read_ptr = tmpptr->next.load(std::memory_order_acquire);
-        t = std::move(tmpptr->current);
-        tmpptr->next.store(nullptr);
-        delete tmpptr;
-        return true;
-    }
-
-    void Wait() {
-        if (Empty()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, [this] { return !Empty(); });
+    template <typename... Args>
+    bool try_emplace(Args&&... args) noexcept {
+        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
+                      "T must be nothrow constructible with Args&&...");
+        auto head = head_.load(std::memory_order_acquire);
+        for (;;) {
+            auto& slot = slots_[idx(head)];
+            if (turn(head) * 2 == slot.turn.load(std::memory_order_acquire)) {
+                if (head_.compare_exchange_strong(head, head + 1)) {
+                    slot.construct(std::forward<Args>(args)...);
+                    slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
+                    return true;
+                }
+            } else {
+                auto const prevHead = head;
+                head = head_.load(std::memory_order_acquire);
+                if (head == prevHead) {
+                    return false;
+                }
+            }
         }
     }
 
-    T PopWait() {
-        Wait();
-        T t;
-        Pop(t);
-        return t;
+    void push(const T& v) noexcept {
+        static_assert(std::is_nothrow_copy_constructible<T>::value,
+                      "T must be nothrow copy constructible");
+        emplace(v);
     }
 
-    T PopWait(std::stop_token stop_token) {
-        if (Empty()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop_token, [this] { return !Empty(); });
-        }
-        if (stop_token.stop_requested()) {
-            return T{};
-        }
-        T t;
-        Pop(t);
-        return t;
+    template <typename P, typename = typename std::enable_if<
+                              std::is_nothrow_constructible<T, P&&>::value>::type>
+    void push(P&& v) noexcept {
+        emplace(std::forward<P>(v));
     }
 
-    // not thread-safe
-    void Clear() {
-        size.store(0);
-        delete read_ptr;
-        write_ptr = read_ptr = new ElementPtr();
+    bool try_push(const T& v) noexcept {
+        static_assert(std::is_nothrow_copy_constructible<T>::value,
+                      "T must be nothrow copy constructible");
+        return try_emplace(v);
+    }
+
+    template <typename P, typename = typename std::enable_if<
+                              std::is_nothrow_constructible<T, P&&>::value>::type>
+    bool try_push(P&& v) noexcept {
+        return try_emplace(std::forward<P>(v));
+    }
+
+    void pop(T& v) noexcept {
+        auto const tail = tail_.fetch_add(1);
+        auto& slot = slots_[idx(tail)];
+        while (turn(tail) * 2 + 1 != slot.turn.load(std::memory_order_acquire))
+            ;
+        v = slot.move();
+        slot.destroy();
+        slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
+    }
+
+    bool try_pop(T& v) noexcept {
+        auto tail = tail_.load(std::memory_order_acquire);
+        for (;;) {
+            auto& slot = slots_[idx(tail)];
+            if (turn(tail) * 2 + 1 == slot.turn.load(std::memory_order_acquire)) {
+                if (tail_.compare_exchange_strong(tail, tail + 1)) {
+                    v = slot.move();
+                    slot.destroy();
+                    slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
+                    return true;
+                }
+            } else {
+                auto const prevTail = tail;
+                tail = tail_.load(std::memory_order_acquire);
+                if (tail == prevTail) {
+                    return false;
+                }
+            }
+        }
     }
 
 private:
-    // stores a pointer to element
-    // and a pointer to the next ElementPtr
-    class ElementPtr {
-    public:
-        ElementPtr() {}
-        ~ElementPtr() {
-            ElementPtr* next_ptr = next.load();
-
-            if (next_ptr)
-                delete next_ptr;
-        }
-
-        T current;
-        std::atomic<ElementPtr*> next{nullptr};
-    };
-
-    ElementPtr* write_ptr;
-    ElementPtr* read_ptr;
-    std::atomic_size_t size{0};
-    std::mutex cv_mutex;
-    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
-};
-
-// a simple thread-safe,
-// single reader, multiple writer queue
-
-template <typename T, bool with_stop_token = false>
-class MPSCQueue {
-public:
-    [[nodiscard]] std::size_t Size() const {
-        return spsc_queue.Size();
+    constexpr size_t idx(size_t i) const noexcept {
+        return i % capacity_;
     }
 
-    [[nodiscard]] bool Empty() const {
-        return spsc_queue.Empty();
-    }
-
-    [[nodiscard]] T& Front() const {
-        return spsc_queue.Front();
-    }
-
-    template <typename Arg>
-    void Push(Arg&& t) {
-        std::lock_guard lock{write_lock};
-        spsc_queue.Push(t);
-    }
-
-    void Pop() {
-        return spsc_queue.Pop();
-    }
-
-    bool Pop(T& t) {
-        return spsc_queue.Pop(t);
-    }
-
-    void Wait() {
-        spsc_queue.Wait();
-    }
-
-    T PopWait() {
-        return spsc_queue.PopWait();
-    }
-
-    T PopWait(std::stop_token stop_token) {
-        return spsc_queue.PopWait(stop_token);
-    }
-
-    // not thread-safe
-    void Clear() {
-        spsc_queue.Clear();
+    constexpr size_t turn(size_t i) const noexcept {
+        return i / capacity_;
     }
 
 private:
-    SPSCQueue<T, with_stop_token> spsc_queue;
-    std::mutex write_lock;
+    const size_t capacity_;
+    Slot<T>* slots_;
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
+    Allocator allocator_ [[no_unique_address]];
+#else
+    Allocator allocator_;
+#endif
+
+    // Align to avoid false sharing between head_ and tail_
+    alignas(hardwareInterferenceSize) std::atomic<size_t> head_;
+    alignas(hardwareInterferenceSize) std::atomic<size_t> tail_;
 };
-} // namespace Common
+} // namespace mpmc
+
+template <typename T, typename Allocator = mpmc::AlignedAllocator<mpmc::Slot<T>>>
+using MPMCQueue = mpmc::Queue<T, Allocator>;
+
+} // namespace Common

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -263,7 +263,7 @@ void ARM_Dynarmic_64::Run() {
 }
 
 void ARM_Dynarmic_64::Step() {
-    jit->Step();
+    cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,

src/core/core.cpp

@@ -83,6 +83,12 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
     }
 }
 
+void KProcessDeleter(Kernel::KProcess* process) {
+    process->Destroy();
+}
+
+using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
+
 } // Anonymous namespace
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -190,9 +196,8 @@ struct System::Impl {
         cpu_manager.Initialize();
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
+            std::chrono::system_clock::now().time_since_epoch());
         Settings::values.custom_rtc_differential =
             Settings::values.custom_rtc.value_or(current_time) - current_time;
 
@@ -255,10 +260,11 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
+        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
+        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
                                             Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
+        main_process->Open();
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
@@ -268,7 +274,7 @@ struct System::Impl {
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeCurrentProcess(main_process.get());
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -333,6 +339,8 @@ struct System::Impl {
         kernel.Shutdown();
         memory.Reset();
         applet_manager.ClearAll();
+        // TODO: The main process should be freed based on KAutoObject ref counting.
+        main_process.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -394,6 +402,7 @@ struct System::Impl {
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
+    KProcessPtr main_process{nullptr, KProcessDeleter};
     Core::Memory::Memory memory;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};

src/core/file_sys/control_metadata.cpp

@@ -9,7 +9,7 @@
 
 namespace FileSys {
 
-const std::array<const char*, 16> LANGUAGE_NAMES{{
+const std::array<const char*, 15> LANGUAGE_NAMES{{
     "AmericanEnglish",
     "BritishEnglish",
     "Japanese",
@@ -25,7 +25,6 @@ const std::array<const char*, 16> LANGUAGE_NAMES{{
     "Korean",
     "Taiwanese",
     "Chinese",
-    "BrazilianPortuguese",
 }};
 
 std::string LanguageEntry::GetApplicationName() const {

src/core/file_sys/control_metadata.h

@@ -88,12 +88,11 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
-    BrazilianPortuguese = 15,
 
     Default = 255,
 };
 
-extern const std::array<const char*, 16> LANGUAGE_NAMES;
+extern const std::array<const char*, 15> LANGUAGE_NAMES;
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/file_sys/romfs_factory.cpp

@@ -39,12 +39,13 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable) {
-        return file;
+        return MakeResult<VirtualFile>(file);
     }
 
     const PatchManager patch_manager{current_process_title_id, filesystem_controller,
                                      content_provider};
-    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
@@ -57,7 +58,8 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
 
-    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
@@ -81,7 +83,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
         return ResultUnknown;
     }
 
-    return romfs;
+    return MakeResult<VirtualFile>(romfs);
 }
 
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/savedata_factory.cpp

@@ -94,7 +94,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
@@ -115,7 +115,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {

src/core/file_sys/sdmc_factory.cpp

@@ -25,7 +25,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;
 
 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return sd_dir;
+    return MakeResult<VirtualDir>(sd_dir);
 }
 
 VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {

src/core/hle/kernel/k_handle_table.cpp

@@ -56,7 +56,6 @@ bool KHandleTable::Remove(Handle handle) {
     }
 
     // Close the object.
-    kernel.UnregisterInUseObject(obj);
     obj->Close();
     return true;
 }

src/core/hle/kernel/k_page_table.cpp

@@ -859,7 +859,7 @@ ResultVal<VAddr> KPageTable::SetHeapSize(std::size_t size) {
         current_heap_addr = heap_region_start + size;
     }
 
-    return heap_region_start;
+    return MakeResult<VAddr>(heap_region_start);
 }
 
 ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
@@ -893,7 +893,7 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
 
     block_manager->Update(addr, needed_num_pages, state, perm);
 
-    return addr;
+    return MakeResult<VAddr>(addr);
 }
 
 ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {

src/core/hle/kernel/k_process.cpp

@@ -434,6 +434,11 @@ void KProcess::PrepareForTermination() {
 }
 
 void KProcess::Finalize() {
+    // Release memory to the resource limit.
+    if (resource_limit != nullptr) {
+        resource_limit->Close();
+    }
+
     // Finalize the handle table and close any open handles.
     handle_table.Finalize();
 
@@ -455,12 +460,6 @@ void KProcess::Finalize() {
         }
     }
 
-    // Release memory to the resource limit.
-    if (resource_limit != nullptr) {
-        resource_limit->Close();
-        resource_limit = nullptr;
-    }
-
     // Perform inherited finalization.
     KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject>::Finalize();
 }

src/core/hle/kernel/k_scheduler.h

@@ -49,11 +49,6 @@ public:
     /// Gets the current running thread
     [[nodiscard]] KThread* GetCurrentThread() const;
 
-    /// Gets the idle thread
-    [[nodiscard]] KThread* GetIdleThread() const {
-        return idle_thread;
-    }
-
     /// Returns true if the scheduler is idle
     [[nodiscard]] bool IsIdle() const {
         return GetCurrentThread() == idle_thread;

src/core/hle/kernel/kernel.cpp

@@ -91,6 +91,12 @@ struct KernelCore::Impl {
     }
 
     void Shutdown() {
+        // Shutdown all processes.
+        if (current_process) {
+            current_process->Finalize();
+            current_process->Close();
+            current_process = nullptr;
+        }
         process_list.clear();
 
         // Close all open server ports.
@@ -164,24 +170,6 @@ struct KernelCore::Impl {
         // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
         next_host_thread_id = Core::Hardware::NUM_CPU_CORES;
 
-        // Close kernel objects that were not freed on shutdown
-        {
-            std::lock_guard lk(registered_in_use_objects_lock);
-            if (registered_in_use_objects.size()) {
-                for (auto& object : registered_in_use_objects) {
-                    object->Close();
-                }
-                registered_in_use_objects.clear();
-            }
-        }
-
-        // Shutdown all processes.
-        if (current_process) {
-            current_process->Finalize();
-            current_process->Close();
-            current_process = nullptr;
-        }
-
         // Track kernel objects that were not freed on shutdown
         {
             std::lock_guard lk(registered_objects_lock);
@@ -726,11 +714,9 @@ struct KernelCore::Impl {
     std::unordered_set<KServerPort*> server_ports;
     std::unordered_set<KServerSession*> server_sessions;
     std::unordered_set<KAutoObject*> registered_objects;
-    std::unordered_set<KAutoObject*> registered_in_use_objects;
     std::mutex server_ports_lock;
     std::mutex server_sessions_lock;
     std::mutex registered_objects_lock;
-    std::mutex registered_in_use_objects_lock;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::vector<Kernel::PhysicalCore> cores;
@@ -942,16 +928,6 @@ void KernelCore::UnregisterKernelObject(KAutoObject* object) {
     impl->registered_objects.erase(object);
 }
 
-void KernelCore::RegisterInUseObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_in_use_objects_lock);
-    impl->registered_in_use_objects.insert(object);
-}
-
-void KernelCore::UnregisterInUseObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_in_use_objects_lock);
-    impl->registered_in_use_objects.erase(object);
-}
-
 bool KernelCore::IsValidNamedPort(NamedPortTable::const_iterator port) const {
     return port != impl->named_ports.cend();
 }

src/core/hle/kernel/kernel.h

@@ -204,14 +204,6 @@ public:
     /// destroyed during the current emulation session.
     void UnregisterKernelObject(KAutoObject* object);
 
-    /// Registers kernel objects with guest in use state, this is purely for close
-    /// after emulation has been shutdown.
-    void RegisterInUseObject(KAutoObject* object);
-
-    /// Unregisters a kernel object previously registered with RegisterInUseObject when it was
-    /// destroyed during the current emulation session.
-    void UnregisterInUseObject(KAutoObject* object);
-
     /// Determines whether or not the given port is a valid named port.
     bool IsValidNamedPort(NamedPortTable::const_iterator port) const;
 

src/core/hle/kernel/svc.cpp

@@ -409,7 +409,7 @@ static ResultCode GetProcessId32(Core::System& system, u32* out_process_id_low,
 
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr handles_address,
-                                      s32 num_handles, s64 nano_seconds) {
+                                      u64 num_handles, s64 nano_seconds) {
     LOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, num_handles={}, nano_seconds={}",
               handles_address, num_handles, nano_seconds);
 
@@ -427,15 +427,11 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
         R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(objs.data(), handles,
                                                                          num_handles),
                  ResultInvalidHandle);
-        for (const auto& obj : objs) {
-            kernel.RegisterInUseObject(obj);
-        }
     }
 
     // Ensure handles are closed when we're done.
     SCOPE_EXIT({
-        for (s32 i = 0; i < num_handles; ++i) {
-            kernel.UnregisterInUseObject(objs[i]);
+        for (u64 i = 0; i < num_handles; ++i) {
             objs[i]->Close();
         }
     });
@@ -890,24 +886,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
         *result = out_ticks;
         return ResultSuccess;
     }
-    case GetInfoType::IdleTickCount: {
-        if (handle == 0) {
-            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
-                      static_cast<Handle>(handle));
-            return ResultInvalidHandle;
-        }
 
-        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id != system.CurrentCoreIndex()) {
-            LOG_ERROR(Kernel_SVC, "Core is not the current core, got {}", info_sub_id);
-            return ResultInvalidCombination;
-        }
-
-        const auto& scheduler = *system.Kernel().CurrentScheduler();
-        const auto* const idle_thread = scheduler.GetIdleThread();
-
-        *result = idle_thread->GetCpuTime();
-        return ResultSuccess;
-    }
     default:
         LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
         return ResultInvalidEnumValue;
@@ -1565,7 +1544,6 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
 
     // If we succeeded, persist a reference to the thread.
     thread->Open();
-    system.Kernel().RegisterInUseObject(thread.GetPointerUnsafe());
 
     return ResultSuccess;
 }
@@ -1581,7 +1559,6 @@ static void ExitThread(Core::System& system) {
     auto* const current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
     system.GlobalSchedulerContext().RemoveThread(current_thread);
     current_thread->Exit();
-    system.Kernel().UnregisterInUseObject(current_thread);
 }
 
 static void ExitThread32(Core::System& system) {

src/core/hle/kernel/svc_wrap.h

@@ -248,10 +248,10 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by WaitSynchronization
-template <ResultCode func(Core::System&, s32*, u64, s32, s64)>
+template <ResultCode func(Core::System&, s32*, u64, u64, s64)>
 void SvcWrap64(Core::System& system) {
     s32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<s32>(Param(system, 2)),
+    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
                             static_cast<s64>(Param(system, 3)))
                            .raw;
 

src/core/hle/result.h

@@ -4,10 +4,11 @@
 
 #pragma once
 
+#include <new>
+#include <utility>
 #include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "common/expected.h"
 
 // All the constants in this file come from http://switchbrew.org/index.php?title=Error_codes
 
@@ -154,131 +155,184 @@ constexpr ResultCode ResultSuccess(0);
 constexpr ResultCode ResultUnknown(UINT32_MAX);
 
 /**
- * This is an optional value type. It holds a `ResultCode` and, if that code is ResultSuccess, it
- * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
- * to access the inner value with operator* is undefined behavior and will assert with Unwrap().
- * Users of this class must be cognizant to check the status of the ResultVal with operator bool(),
- * Code(), Succeeded() or Failed() prior to accessing the inner value.
+ * This is an optional value type. It holds a `ResultCode` and, if that code is a success code,
+ * also holds a result of type `T`. If the code is an error code then trying to access the inner
+ * value fails, thus ensuring that the ResultCode of functions is always checked properly before
+ * their return value is used.  It is similar in concept to the `std::optional` type
+ * (http://en.cppreference.com/w/cpp/experimental/optional) originally proposed for inclusion in
+ * C++14, or the `Result` type in Rust (http://doc.rust-lang.org/std/result/index.html).
  *
  * An example of how it could be used:
  * \code
  * ResultVal<int> Frobnicate(float strength) {
  *     if (strength < 0.f || strength > 1.0f) {
  *         // Can't frobnicate too weakly or too strongly
- *         return ResultCode{ErrorModule::Common, 1};
+ *         return ResultCode(ErrorDescription::OutOfRange, ErrorModule::Common,
+ *             ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
  *     } else {
  *         // Frobnicated! Give caller a cookie
- *         return 42;
+ *         return MakeResult<int>(42);
  *     }
  * }
  * \endcode
  *
  * \code
- * auto frob_result = Frobnicate(0.75f);
+ * ResultVal<int> frob_result = Frobnicate(0.75f);
  * if (frob_result) {
  *     // Frobbed ok
  *     printf("My cookie is %d\n", *frob_result);
  * } else {
- *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.Code().raw);
+ *     printf("Guess I overdid it. :( Error code: %ux\n", frob_result.code().hex);
  * }
  * \endcode
  */
 template <typename T>
 class ResultVal {
 public:
-    constexpr ResultVal() : expected{} {}
-
-    constexpr ResultVal(ResultCode code) : expected{Common::Unexpected(code)} {}
-
-    template <typename U>
-    constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
+    /// Constructs an empty `ResultVal` with the given error code. The code must not be a success
+    /// code.
+    ResultVal(ResultCode error_code = ResultUnknown) : result_code(error_code) {
+        ASSERT(error_code.IsError());
+    }
 
+    /**
+     * Similar to the non-member function `MakeResult`, with the exception that you can manually
+     * specify the success code. `success_code` must not be an error code.
+     */
     template <typename... Args>
-    constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward<Args>(args)...} {}
-
-    ~ResultVal() = default;
-
-    constexpr ResultVal(const ResultVal&) = default;
-    constexpr ResultVal(ResultVal&&) = default;
-
-    ResultVal& operator=(const ResultVal&) = default;
-    ResultVal& operator=(ResultVal&&) = default;
-
-    [[nodiscard]] constexpr explicit operator bool() const noexcept {
-        return expected.has_value();
+    [[nodiscard]] static ResultVal WithCode(ResultCode success_code, Args&&... args) {
+        ResultVal<T> result;
+        result.emplace(success_code, std::forward<Args>(args)...);
+        return result;
     }
 
-    [[nodiscard]] constexpr ResultCode Code() const {
-        return expected.has_value() ? ResultSuccess : expected.error();
+    ResultVal(const ResultVal& o) : result_code(o.result_code) {
+        if (!o.empty()) {
+            new (&object) T(o.object);
+        }
     }
 
-    [[nodiscard]] constexpr bool Succeeded() const {
-        return expected.has_value();
+    ResultVal(ResultVal&& o) noexcept : result_code(o.result_code) {
+        if (!o.empty()) {
+            new (&object) T(std::move(o.object));
+        }
     }
 
-    [[nodiscard]] constexpr bool Failed() const {
-        return !expected.has_value();
+    ~ResultVal() {
+        if (!empty()) {
+            object.~T();
+        }
     }
 
-    [[nodiscard]] constexpr T* operator->() {
-        return std::addressof(expected.value());
+    ResultVal& operator=(const ResultVal& o) {
+        if (this == &o) {
+            return *this;
+        }
+        if (!empty()) {
+            if (!o.empty()) {
+                object = o.object;
+            } else {
+                object.~T();
+            }
+        } else {
+            if (!o.empty()) {
+                new (&object) T(o.object);
+            }
+        }
+        result_code = o.result_code;
+
+        return *this;
     }
 
-    [[nodiscard]] constexpr const T* operator->() const {
-        return std::addressof(expected.value());
+    /**
+     * Replaces the current result with a new constructed result value in-place. The code must not
+     * be an error code.
+     */
+    template <typename... Args>
+    void emplace(ResultCode success_code, Args&&... args) {
+        ASSERT(success_code.IsSuccess());
+        if (!empty()) {
+            object.~T();
+        }
+        new (&object) T(std::forward<Args>(args)...);
+        result_code = success_code;
     }
 
-    [[nodiscard]] constexpr T& operator*() & {
-        return *expected;
+    /// Returns true if the `ResultVal` contains an error code and no value.
+    [[nodiscard]] bool empty() const {
+        return result_code.IsError();
     }
 
-    [[nodiscard]] constexpr const T& operator*() const& {
-        return *expected;
+    /// Returns true if the `ResultVal` contains a return value.
+    [[nodiscard]] bool Succeeded() const {
+        return result_code.IsSuccess();
+    }
+    /// Returns true if the `ResultVal` contains an error code and no value.
+    [[nodiscard]] bool Failed() const {
+        return empty();
     }
 
-    [[nodiscard]] constexpr T&& operator*() && {
-        return *expected;
+    [[nodiscard]] ResultCode Code() const {
+        return result_code;
     }
 
-    [[nodiscard]] constexpr const T&& operator*() const&& {
-        return *expected;
-    }
-
-    [[nodiscard]] constexpr T& Unwrap() & {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr const T& Unwrap() const& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return expected.value();
-    }
-
-    [[nodiscard]] constexpr T&& Unwrap() && {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
-    }
-
-    [[nodiscard]] constexpr const T&& Unwrap() const&& {
-        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
-        return std::move(expected.value());
+    [[nodiscard]] const T& operator*() const {
+        return object;
+    }
+    [[nodiscard]] T& operator*() {
+        return object;
+    }
+    [[nodiscard]] const T* operator->() const {
+        return &object;
+    }
+    [[nodiscard]] T* operator->() {
+        return &object;
     }
 
+    /// Returns the value contained in this `ResultVal`, or the supplied default if it is missing.
     template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) const& {
-        return expected.value_or(v);
+    [[nodiscard]] T ValueOr(U&& value) const {
+        return !empty() ? object : std::move(value);
     }
 
-    template <typename U>
-    [[nodiscard]] constexpr T ValueOr(U&& v) && {
-        return expected.value_or(v);
+    /// Asserts that the result succeeded and returns a reference to it.
+    [[nodiscard]] T& Unwrap() & {
+        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
+        return **this;
+    }
+
+    [[nodiscard]] T&& Unwrap() && {
+        ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal");
+        return std::move(**this);
     }
 
 private:
-    // TODO: Replace this with std::expected once it is standardized in the STL.
-    Common::Expected<T, ResultCode> expected;
+    // A union is used to allocate the storage for the value, while allowing us to construct and
+    // destruct it at will.
+    union {
+        T object;
+    };
+    ResultCode result_code;
 };
 
+/**
+ * This function is a helper used to construct `ResultVal`s. It receives the arguments to construct
+ * `T` with and creates a success `ResultVal` contained the constructed value.
+ */
+template <typename T, typename... Args>
+[[nodiscard]] ResultVal<T> MakeResult(Args&&... args) {
+    return ResultVal<T>::WithCode(ResultSuccess, std::forward<Args>(args)...);
+}
+
+/**
+ * Deducible overload of MakeResult, allowing the template parameter to be ommited if you're just
+ * copy or move constructing.
+ */
+template <typename Arg>
+[[nodiscard]] ResultVal<std::remove_reference_t<Arg>> MakeResult(Arg&& arg) {
+    return ResultVal<std::remove_reference_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
+}
+
 /**
  * Check for the success of `source` (which must evaluate to a ResultVal). If it succeeds, unwraps
  * the contained value and assigns it to `target`, which can be either an l-value expression or a

src/core/hle/service/acc/acc.cpp

@@ -826,13 +826,6 @@ void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx
     rb.Push(is_locked);
 }
 
-void Module::Interface::InitializeApplicationInfoV2(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     Common::UUID user_id = rp.PopRaw<Common::UUID>();

src/core/hle/service/acc/acc.h

@@ -33,7 +33,6 @@ public:
         void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
         void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);
         void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
-        void InitializeApplicationInfoV2(Kernel::HLERequestContext& ctx);
         void GetProfileEditor(Kernel::HLERequestContext& ctx);
         void ListQualifiedUsers(Kernel::HLERequestContext& ctx);
         void LoadOpenContext(Kernel::HLERequestContext& ctx);

src/core/hle/service/acc/acc_u0.cpp

@@ -34,7 +34,6 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"}, // 6.0.0+
         {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
         {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"}, // 6.0.0+
-        {160, &ACC_U0::InitializeApplicationInfoV2, "InitializeApplicationInfoV2"},
     };
     // clang-format on
 

src/core/hle/service/filesystem/filesystem.cpp

@@ -226,10 +226,11 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
     }
 
     if (mode == FileSys::Mode::Append) {
-        return std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
+        return MakeResult<FileSys::VirtualFile>(
+            std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize()));
     }
 
-    return file;
+    return MakeResult<FileSys::VirtualFile>(file);
 }
 
 ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
@@ -239,7 +240,7 @@ ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const s
         // TODO(DarkLordZach): Find a better error code for this
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir;
+    return MakeResult(dir);
 }
 
 ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
@@ -251,12 +252,12 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
     auto filename = Common::FS::GetFilename(path);
     // TODO(Subv): Some games use the '/' path, find out what this means.
     if (filename.empty())
-        return FileSys::EntryType::Directory;
+        return MakeResult(FileSys::EntryType::Directory);
 
     if (dir->GetFile(filename) != nullptr)
-        return FileSys::EntryType::File;
+        return MakeResult(FileSys::EntryType::File);
     if (dir->GetSubdirectory(filename) != nullptr)
-        return FileSys::EntryType::Directory;
+        return MakeResult(FileSys::EntryType::Directory);
     return FileSys::ERROR_PATH_NOT_FOUND;
 }
 
@@ -269,7 +270,7 @@ ResultVal<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStam
     if (GetEntryType(path).Failed()) {
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
-    return dir->GetFileTimeStamp(Common::FS::GetFilename(path));
+    return MakeResult(dir->GetFileTimeStamp(Common::FS::GetFilename(path)));
 }
 
 FileSystemController::FileSystemController(Core::System& system_) : system{system_} {}
@@ -394,7 +395,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
         return FileSys::ERROR_ENTITY_NOT_FOUND;
     }
 
-    return save_data_factory->GetSaveDataSpaceDirectory(space);
+    return MakeResult(save_data_factory->GetSaveDataSpaceDirectory(space));
 }
 
 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {
@@ -420,7 +421,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    return MakeResult<FileSys::VirtualDir>(std::move(part));
 }
 
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
@@ -436,7 +437,7 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
         return FileSys::ERROR_INVALID_ARGUMENT;
     }
 
-    return part;
+    return MakeResult<FileSys::VirtualFile>(std::move(part));
 }
 
 u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const {

src/core/hle/service/glue/glue_manager.cpp

@@ -26,7 +26,7 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)
         return ERR_NOT_REGISTERED;
     }
 
-    return iter->second.launch;
+    return MakeResult<ApplicationLaunchProperty>(iter->second.launch);
 }
 
 ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
@@ -39,7 +39,7 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
         return ERR_NOT_REGISTERED;
     }
 
-    return iter->second.control;
+    return MakeResult<std::vector<u8>>(iter->second.control);
 }
 
 ResultCode ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,

src/core/hle/service/ldr/ldr.cpp

@@ -335,7 +335,7 @@ public:
             CASCADE_CODE(result);
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                return MakeResult<VAddr>(addr);
             }
         }
 
@@ -371,7 +371,7 @@ public:
             }
 
             if (ValidateRegionForMap(page_table, addr, size)) {
-                return addr;
+                return MakeResult<VAddr>(addr);
             }
         }
 

src/core/hle/service/mii/mii_manager.cpp

@@ -443,14 +443,14 @@ ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_
     std::vector<MiiInfoElement> result;
 
     if ((source_flag & SourceFlag::Default) == SourceFlag::None) {
-        return result;
+        return MakeResult(std::move(result));
     }
 
     for (std::size_t index = BaseMiiCount; index < DefaultMiiCount; index++) {
         result.emplace_back(BuildDefault(index), Source::Default);
     }
 
-    return result;
+    return MakeResult(std::move(result));
 }
 
 ResultCode MiiManager::GetIndex([[maybe_unused]] const MiiInfo& info, u32& index) {

src/core/hle/service/ns/language.cpp

@@ -277,25 +277,6 @@ constexpr ApplicationLanguagePriorityList priority_list_simplified_chinese = {{
     ApplicationLanguage::Korean,
 }};
 
-constexpr ApplicationLanguagePriorityList priority_list_brazilian_portuguese = {{
-    ApplicationLanguage::BrazilianPortuguese,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-}};
-
 const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
     const ApplicationLanguage lang) {
     switch (lang) {
@@ -329,8 +310,6 @@ const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
         return &priority_list_traditional_chinese;
     case ApplicationLanguage::SimplifiedChinese:
         return &priority_list_simplified_chinese;
-    case ApplicationLanguage::BrazilianPortuguese:
-        return &priority_list_brazilian_portuguese;
     default:
         return nullptr;
     }
@@ -360,6 +339,7 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::FR_CA:
         return ApplicationLanguage::CanadianFrench;
     case Set::LanguageCode::PT:
+    case Set::LanguageCode::PT_BR:
         return ApplicationLanguage::Portuguese;
     case Set::LanguageCode::RU:
         return ApplicationLanguage::Russian;
@@ -371,8 +351,6 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::ZH_CN:
     case Set::LanguageCode::ZH_HANS:
         return ApplicationLanguage::SimplifiedChinese;
-    case Set::LanguageCode::PT_BR:
-        return ApplicationLanguage::BrazilianPortuguese;
     default:
         return std::nullopt;
     }
@@ -410,8 +388,6 @@ std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage
         return Set::LanguageCode::ZH_HANT;
     case ApplicationLanguage::SimplifiedChinese:
         return Set::LanguageCode::ZH_HANS;
-    case ApplicationLanguage::BrazilianPortuguese:
-        return Set::LanguageCode::PT_BR;
     default:
         return std::nullopt;
     }

src/core/hle/service/ns/language.h

@@ -30,7 +30,6 @@ enum class ApplicationLanguage : u8 {
     Korean,
     TraditionalChinese,
     SimplifiedChinese,
-    BrazilianPortuguese,
     Count
 };
 using ApplicationLanguagePriorityList =

src/core/hle/service/ns/ns.cpp

@@ -414,7 +414,7 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
     for (const auto lang : *priority_list) {
         const auto supported_flag = GetSupportedLanguageFlag(lang);
         if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return static_cast<u8>(lang);
+            return MakeResult(static_cast<u8>(lang));
         }
     }
 
@@ -448,7 +448,7 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
         return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
 
-    return static_cast<u64>(*language_code);
+    return MakeResult(static_cast<u64>(*language_code));
 }
 
 IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_)

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -69,7 +69,8 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     std::vector<Reloc> relocs(params.relocation_count);
     std::vector<u32> reloc_shifts(params.relocation_count);
     std::vector<SyncptIncr> syncpt_increments(params.syncpoint_count);
-    std::vector<u32> fence_thresholds(params.fence_count);
+    std::vector<SyncptIncr> wait_checks(params.syncpoint_count);
+    std::vector<Fence> fences(params.fence_count);
 
     // Slice input into their respective buffers
     std::size_t offset = sizeof(IoctlSubmit);
@@ -77,13 +78,15 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += SliceVectors(input, relocs, params.relocation_count, offset);
     offset += SliceVectors(input, reloc_shifts, params.relocation_count, offset);
     offset += SliceVectors(input, syncpt_increments, params.syncpoint_count, offset);
-    offset += SliceVectors(input, fence_thresholds, params.fence_count, offset);
+    offset += SliceVectors(input, wait_checks, params.syncpoint_count, offset);
+    offset += SliceVectors(input, fences, params.fence_count, offset);
 
     auto& gpu = system.GPU();
     if (gpu.UseNvdec()) {
         for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
             const SyncptIncr& syncpt_incr = syncpt_increments[i];
-            fence_thresholds[i] =
+            fences[i].id = syncpt_incr.id;
+            fences[i].value =
                 syncpoint_manager.IncreaseSyncpoint(syncpt_incr.id, syncpt_incr.increments);
         }
     }
@@ -95,6 +98,11 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
                                   cmdlist.size() * sizeof(u32));
         gpu.PushCommandBuffer(cmdlist);
     }
+    if (gpu.UseNvdec()) {
+        fences[0].value = syncpoint_manager.IncreaseSyncpoint(fences[0].id, 1);
+        Tegra::ChCommandHeaderList cmdlist{{(4 << 28) | fences[0].id}};
+        gpu.PushCommandBuffer(cmdlist);
+    }
     std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back
     offset = sizeof(IoctlSubmit);
@@ -102,7 +110,8 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += WriteVectors(output, relocs, offset);
     offset += WriteVectors(output, reloc_shifts, offset);
     offset += WriteVectors(output, syncpt_increments, offset);
-    offset += WriteVectors(output, fence_thresholds, offset);
+    offset += WriteVectors(output, wait_checks, offset);
+    offset += WriteVectors(output, fences, offset);
 
     return NvResult::Success;
 }

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -56,16 +56,19 @@ protected:
         s32 target{};
         s32 target_offset{};
     };
-    static_assert(sizeof(Reloc) == 0x10, "Reloc has incorrect size");
+    static_assert(sizeof(Reloc) == 0x10, "CommandBuffer has incorrect size");
 
     struct SyncptIncr {
         u32 id{};
         u32 increments{};
-        u32 unk0{};
-        u32 unk1{};
-        u32 unk2{};
     };
-    static_assert(sizeof(SyncptIncr) == 0x14, "SyncptIncr has incorrect size");
+    static_assert(sizeof(SyncptIncr) == 0x8, "CommandBuffer has incorrect size");
+
+    struct Fence {
+        u32 id{};
+        u32 value{};
+    };
+    static_assert(sizeof(Fence) == 0x8, "CommandBuffer has incorrect size");
 
     struct IoctlGetSyncpoint {
         // Input

src/core/hle/service/sm/sm.cpp

@@ -87,7 +87,7 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
     auto handler = it->second;
     port->GetServerPort().SetSessionHandler(std::move(handler));
 
-    return port;
+    return MakeResult(port);
 }
 
 /**
@@ -165,7 +165,7 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(Kernel::HLERequestContext&
 
     LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
 
-    return session;
+    return MakeResult(session);
 }
 
 void SM::RegisterService(Kernel::HLERequestContext& ctx) {

src/core/hle/service/spl/spl_module.cpp

@@ -120,40 +120,40 @@ ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
         return ResultSecureMonitorNotImplemented;
     case ConfigItem::ExosphereApiVersion:
         // Get information about the current exosphere version.
-        return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
-               (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
-               (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
+        return MakeResult((u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
+                          (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
+                          (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware())));
     case ConfigItem::ExosphereNeedsReboot:
         // We are executing, so we aren't in the process of rebooting.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereNeedsShutdown:
         // We are executing, so we aren't in the process of shutting down.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereGitCommitHash:
         // Get information about the current exosphere git commit hash.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereHasRcmBugPatch:
         // Get information about whether this unit has the RCM bug patched.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereBlankProdInfo:
         // Get whether this unit should simulate a "blanked" PRODINFO.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereAllowCalWrites:
         // Get whether this unit should allow writing to the calibration partition.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereEmummcType:
         // Get what kind of emummc this unit has active.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExospherePayloadAddress:
         // Gets the physical address of the reboot payload buffer, if one exists.
         return ResultSecureMonitorNotInitialized;
     case ConfigItem::ExosphereLogConfiguration:
         // Get the log configuration.
-        return u64{0};
+        return MakeResult(u64{0});
     case ConfigItem::ExosphereForceEnableUsb30:
         // Get whether usb 3.0 should be force-enabled.
-        return u64{0};
+        return MakeResult(u64{0});
     default:
         return ResultSecureMonitorInvalidArgument;
     }

src/core/hle/service/time/time_manager.cpp

@@ -13,19 +13,18 @@
 #include "core/hle/service/time/time_manager.h"
 
 namespace Service::Time {
-namespace {
+
 constexpr Clock::TimeSpanType standard_network_clock_accuracy{0x0009356907420000ULL};
 
-s64 GetSecondsSinceEpoch() {
-    const auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch();
-    return std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch).count() +
+static std::chrono::seconds GetSecondsSinceEpoch() {
+    return std::chrono::duration_cast<std::chrono::seconds>(
+               std::chrono::system_clock::now().time_since_epoch()) +
            Settings::values.custom_rtc_differential;
 }
 
-s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch() + TimeManager::GetExternalTimeZoneOffset();
+static s64 GetExternalRtcValue() {
+    return GetSecondsSinceEpoch().count() + TimeManager::GetExternalTimeZoneOffset();
 }
-} // Anonymous namespace
 
 struct TimeManager::Impl final {
     explicit Impl(Core::System& system)

src/core/hle/service/vi/vi.cpp

@@ -1284,15 +1284,15 @@ private:
     static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
         switch (mode) {
         case NintendoScaleMode::None:
-            return ConvertedScaleMode::None;
+            return MakeResult(ConvertedScaleMode::None);
         case NintendoScaleMode::Freeze:
-            return ConvertedScaleMode::Freeze;
+            return MakeResult(ConvertedScaleMode::Freeze);
         case NintendoScaleMode::ScaleToWindow:
-            return ConvertedScaleMode::ScaleToWindow;
+            return MakeResult(ConvertedScaleMode::ScaleToWindow);
         case NintendoScaleMode::ScaleAndCrop:
-            return ConvertedScaleMode::ScaleAndCrop;
+            return MakeResult(ConvertedScaleMode::ScaleAndCrop);
         case NintendoScaleMode::PreserveAspectRatio:
-            return ConvertedScaleMode::PreserveAspectRatio;
+            return MakeResult(ConvertedScaleMode::PreserveAspectRatio);
         default:
             LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
             return ERR_OPERATION_FAILED;

src/input_common/gcadapter/gc_adapter.cpp

@@ -170,7 +170,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
 
     if (pads[port].buttons != 0) {
         pad_status.button = pads[port].last_button;
-        pad_queue.Push(pad_status);
+        pad_queue.push(pad_status);
     }
 
     // Accounting for a threshold here to ensure an intentional press
@@ -181,7 +181,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
             pad_status.axis = static_cast<PadAxes>(i);
             pad_status.axis_value = value;
             pad_status.axis_threshold = axis_threshold;
-            pad_queue.Push(pad_status);
+            pad_queue.push(pad_status);
         }
     }
 }
@@ -478,20 +478,18 @@ bool Adapter::DeviceConnected(std::size_t port) const {
 }
 
 void Adapter::BeginConfiguration() {
-    pad_queue.Clear();
     configuring = true;
 }
 
 void Adapter::EndConfiguration() {
-    pad_queue.Clear();
     configuring = false;
 }
 
-Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() {
+Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
+const Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
     return pad_queue;
 }
 

src/input_common/gcadapter/gc_adapter.h

@@ -85,8 +85,8 @@ public:
     void BeginConfiguration();
     void EndConfiguration();
 
-    Common::SPSCQueue<GCPadStatus>& GetPadQueue();
-    const Common::SPSCQueue<GCPadStatus>& GetPadQueue() const;
+    Common::MPMCQueue<GCPadStatus>& GetPadQueue();
+    const Common::MPMCQueue<GCPadStatus>& GetPadQueue() const;
 
     GCController& GetPadState(std::size_t port);
     const GCController& GetPadState(std::size_t port) const;
@@ -145,7 +145,7 @@ private:
 
     libusb_device_handle* usb_adapter_handle = nullptr;
     std::array<GCController, 4> pads;
-    Common::SPSCQueue<GCPadStatus> pad_queue;
+    Common::MPMCQueue<GCPadStatus> pad_queue{1024};
 
     std::thread adapter_input_thread;
     std::thread adapter_scan_thread;

src/input_common/gcadapter/gc_poller.cpp

@@ -103,7 +103,7 @@ Common::ParamPackage GCButtonFactory::GetNextInput() const {
     Common::ParamPackage params;
     GCAdapter::GCPadStatus pad;
     auto& queue = adapter->GetPadQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         // This while loop will break on the earliest detected button
         params.Set("engine", "gcpad");
         params.Set("port", static_cast<s32>(pad.port));
@@ -263,7 +263,7 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
     GCAdapter::GCPadStatus pad;
     Common::ParamPackage params;
     auto& queue = adapter->GetPadQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         if (pad.button != GCAdapter::PadButton::Undefined) {
             params.Set("engine", "gcpad");
             params.Set("port", static_cast<s32>(pad.port));

src/input_common/mouse/mouse_input.cpp

@@ -52,7 +52,7 @@ void Mouse::UpdateYuzuSettings() {
         return;
     }
 
-    mouse_queue.Push(MouseStatus{
+    mouse_queue.push(MouseStatus{
         .button = last_button,
     });
 }
@@ -153,7 +153,6 @@ void Mouse::ReleaseAllButtons() {
 void Mouse::BeginConfiguration() {
     buttons = 0;
     last_button = MouseButton::Undefined;
-    mouse_queue.Clear();
     configuring = true;
 }
 
@@ -165,7 +164,6 @@ void Mouse::EndConfiguration() {
         info.data.axis = {0, 0};
     }
     last_button = MouseButton::Undefined;
-    mouse_queue.Clear();
     configuring = false;
 }
 
@@ -205,11 +203,11 @@ bool Mouse::UnlockButton(std::size_t button_) {
     return button_state;
 }
 
-Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() {
+Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() {
     return mouse_queue;
 }
 
-const Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
+const Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
     return mouse_queue;
 }
 

src/input_common/mouse/mouse_input.h

@@ -79,8 +79,8 @@ public:
     [[nodiscard]] bool ToggleButton(std::size_t button_);
     [[nodiscard]] bool UnlockButton(std::size_t button_);
 
-    [[nodiscard]] Common::SPSCQueue<MouseStatus>& GetMouseQueue();
-    [[nodiscard]] const Common::SPSCQueue<MouseStatus>& GetMouseQueue() const;
+    [[nodiscard]] Common::MPMCQueue<MouseStatus>& GetMouseQueue();
+    [[nodiscard]] const Common::MPMCQueue<MouseStatus>& GetMouseQueue() const;
 
     [[nodiscard]] MouseData& GetMouseState(std::size_t button);
     [[nodiscard]] const MouseData& GetMouseState(std::size_t button) const;
@@ -109,7 +109,7 @@ private:
     std::jthread update_thread;
     MouseButton last_button{MouseButton::Undefined};
     std::array<MouseInfo, 7> mouse_info;
-    Common::SPSCQueue<MouseStatus> mouse_queue;
+    Common::MPMCQueue<MouseStatus> mouse_queue{1024};
     bool configuring{false};
     int mouse_panning_timout{};
 };

src/input_common/mouse/mouse_poller.cpp

@@ -52,7 +52,7 @@ Common::ParamPackage MouseButtonFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -184,7 +184,7 @@ Common::ParamPackage MouseAnalogFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -227,7 +227,7 @@ Common::ParamPackage MouseMotionFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -275,7 +275,7 @@ Common::ParamPackage MouseTouchFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");

src/input_common/sdl/sdl_impl.cpp

@@ -46,7 +46,7 @@ static int SDLEventWatcher(void* user_data, SDL_Event* event) {
 
     // Don't handle the event if we are configuring
     if (sdl_state->polling) {
-        sdl_state->event_queue.Push(*event);
+        sdl_state->event_queue.push(*event);
     } else {
         sdl_state->HandleGameControllerEvent(*event);
     }
@@ -1460,7 +1460,6 @@ public:
     explicit SDLPoller(SDLState& state_) : state(state_) {}
 
     void Start([[maybe_unused]] const std::string& device_id) override {
-        state.event_queue.Clear();
         state.polling = true;
     }
 
@@ -1478,7 +1477,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.Pop(event)) {
+        while (state.event_queue.try_pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1550,7 +1549,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.Pop(event)) {
+        while (state.event_queue.try_pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1592,7 +1591,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.Pop(event)) {
+        while (state.event_queue.try_pop(event)) {
             if (event.type != SDL_JOYAXISMOTION) {
                 // Check for a button press
                 auto button_press = button_poller.FromEvent(event);

src/input_common/sdl/sdl_impl.h

@@ -59,7 +59,7 @@ public:
 
     /// Used by the Pollers during config
     std::atomic<bool> polling = false;
-    Common::SPSCQueue<SDL_Event> event_queue;
+    Common::MPMCQueue<SDL_Event> event_queue{1024};
 
     std::vector<Common::ParamPackage> GetInputDevices() override;
 

src/input_common/udp/client.cpp

@@ -338,7 +338,7 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
                   gyro[0], gyro[1], gyro[2], acc[0], acc[1], acc[2]);
     }
     UDPPadStatus pad{
-        .host = clients[client].host,
+        .host = clients[client].host.c_str(),
         .port = clients[client].port,
         .pad_index = pad_index,
     };
@@ -346,12 +346,12 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
         if (gyro[i] > 5.0f || gyro[i] < -5.0f) {
             pad.motion = static_cast<PadMotion>(i);
             pad.motion_value = gyro[i];
-            pad_queue.Push(pad);
+            pad_queue.push(pad);
         }
         if (acc[i] > 1.75f || acc[i] < -1.75f) {
             pad.motion = static_cast<PadMotion>(i + 3);
             pad.motion_value = acc[i];
-            pad_queue.Push(pad);
+            pad_queue.push(pad);
         }
     }
 }
@@ -401,12 +401,10 @@ void Client::UpdateTouchInput(Response::TouchPad& touch_pad, std::size_t client,
 }
 
 void Client::BeginConfiguration() {
-    pad_queue.Clear();
     configuring = true;
 }
 
 void Client::EndConfiguration() {
-    pad_queue.Clear();
     configuring = false;
 }
 
@@ -434,11 +432,11 @@ const Input::TouchStatus& Client::GetTouchState() const {
     return touch_status;
 }
 
-Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() {
+Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() const {
+const Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() const {
     return pad_queue;
 }
 
@@ -471,42 +469,46 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
     std::function<void(u16, u16, u16, u16)> data_callback) {
 
     std::thread([=, this] {
+        constexpr u16 CALIBRATION_THRESHOLD = 100;
+
+        u16 min_x{UINT16_MAX};
+        u16 min_y{UINT16_MAX};
+        u16 max_x{};
+        u16 max_y{};
+
         Status current_status{Status::Initialized};
-        SocketCallback callback{
-            [](Response::Version) {}, [](Response::PortInfo) {},
-            [&](Response::PadData data) {
-                static constexpr u16 CALIBRATION_THRESHOLD = 100;
-                static constexpr u16 MAX_VALUE = UINT16_MAX;
+        SocketCallback callback{[](Response::Version) {}, [](Response::PortInfo) {},
+                                [&](Response::PadData data) {
+                                    if (current_status == Status::Initialized) {
+                                        // Receiving data means the communication is ready now
+                                        current_status = Status::Ready;
+                                        status_callback(current_status);
+                                    }
+                                    if (data.touch[0].is_active == 0) {
+                                        return;
+                                    }
+                                    LOG_DEBUG(Input, "Current touch: {} {}", data.touch[0].x,
+                                              data.touch[0].y);
+                                    min_x = std::min(min_x, static_cast<u16>(data.touch[0].x));
+                                    min_y = std::min(min_y, static_cast<u16>(data.touch[0].y));
+                                    if (current_status == Status::Ready) {
+                                        // First touch - min data (min_x/min_y)
+                                        current_status = Status::Stage1Completed;
+                                        status_callback(current_status);
+                                    }
+                                    if (data.touch[0].x - min_x > CALIBRATION_THRESHOLD &&
+                                        data.touch[0].y - min_y > CALIBRATION_THRESHOLD) {
+                                        // Set the current position as max value and finishes
+                                        // configuration
+                                        max_x = data.touch[0].x;
+                                        max_y = data.touch[0].y;
+                                        current_status = Status::Completed;
+                                        data_callback(min_x, min_y, max_x, max_y);
+                                        status_callback(current_status);
 
-                if (current_status == Status::Initialized) {
-                    // Receiving data means the communication is ready now
-                    current_status = Status::Ready;
-                    status_callback(current_status);
-                }
-                const auto& touchpad_0 = data.touch[0];
-                if (touchpad_0.is_active == 0) {
-                    return;
-                }
-                LOG_DEBUG(Input, "Current touch: {} {}", touchpad_0.x, touchpad_0.y);
-                const u16 min_x = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.x));
-                const u16 min_y = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.y));
-                if (current_status == Status::Ready) {
-                    // First touch - min data (min_x/min_y)
-                    current_status = Status::Stage1Completed;
-                    status_callback(current_status);
-                }
-                if (touchpad_0.x - min_x > CALIBRATION_THRESHOLD &&
-                    touchpad_0.y - min_y > CALIBRATION_THRESHOLD) {
-                    // Set the current position as max value and finishes configuration
-                    const u16 max_x = touchpad_0.x;
-                    const u16 max_y = touchpad_0.y;
-                    current_status = Status::Completed;
-                    data_callback(min_x, min_y, max_x, max_y);
-                    status_callback(current_status);
-
-                    complete_event.Set();
-                }
-            }};
+                                        complete_event.Set();
+                                    }
+                                }};
         Socket socket{host, port, std::move(callback)};
         std::thread worker_thread{SocketLoop, &socket};
         complete_event.Wait();

src/input_common/udp/client.h

@@ -46,7 +46,7 @@ enum class PadTouch {
 };
 
 struct UDPPadStatus {
-    std::string host{"127.0.0.1"};
+    const char* host{"127.0.0.1"};
     u16 port{26760};
     std::size_t pad_index{};
     PadMotion motion{PadMotion::Undefined};
@@ -85,8 +85,8 @@ public:
     bool DeviceConnected(std::size_t pad) const;
     void ReloadSockets();
 
-    Common::SPSCQueue<UDPPadStatus>& GetPadQueue();
-    const Common::SPSCQueue<UDPPadStatus>& GetPadQueue() const;
+    Common::MPMCQueue<UDPPadStatus>& GetPadQueue();
+    const Common::MPMCQueue<UDPPadStatus>& GetPadQueue() const;
 
     DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad);
     const DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad) const;
@@ -146,7 +146,7 @@ private:
     static constexpr std::size_t MAX_TOUCH_FINGERS = MAX_UDP_CLIENTS * 2;
     std::array<PadData, MAX_UDP_CLIENTS * PADS_PER_CLIENT> pads{};
     std::array<ClientConnection, MAX_UDP_CLIENTS> clients{};
-    Common::SPSCQueue<UDPPadStatus> pad_queue{};
+    Common::MPMCQueue<UDPPadStatus> pad_queue{1024};
     Input::TouchStatus touch_status{};
     std::array<std::size_t, MAX_TOUCH_FINGERS> finger_id{};
 };

src/input_common/udp/udp.cpp

@@ -59,7 +59,7 @@ Common::ParamPackage UDPMotionFactory::GetNextInput() {
     Common::ParamPackage params;
     CemuhookUDP::UDPPadStatus pad;
     auto& queue = client->GetPadQueue();
-    while (queue.Pop(pad)) {
+    while (queue.try_pop(pad)) {
         if (pad.motion == CemuhookUDP::PadMotion::Undefined || std::abs(pad.motion_value) < 1) {
             continue;
         }

src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp

@@ -18,7 +18,7 @@ namespace Shader::Backend::GLASM {
 #define NotImplemented() throw NotImplementedException("GLASM instruction {}", __LINE__)
 
 static void DefinePhi(EmitContext& ctx, IR::Inst& phi) {
-    switch (phi.Type()) {
+    switch (phi.Arg(0).Type()) {
     case IR::Type::U1:
     case IR::Type::U32:
     case IR::Type::F32:

src/shader_recompiler/backend/glsl/emit_glsl_special.cpp

@@ -68,7 +68,7 @@ void EmitPhi(EmitContext& ctx, IR::Inst& phi) {
     }
     if (!phi.Definition<Id>().is_valid) {
         // The phi node wasn't forward defined
-        ctx.var_alloc.PhiDefine(phi, phi.Type());
+        ctx.var_alloc.PhiDefine(phi, phi.Arg(0).Type());
     }
 }
 
@@ -80,7 +80,7 @@ void EmitReference(EmitContext& ctx, const IR::Value& value) {
 
 void EmitPhiMove(EmitContext& ctx, const IR::Value& phi_value, const IR::Value& value) {
     IR::Inst& phi{*phi_value.InstRecursive()};
-    const auto phi_type{phi.Type()};
+    const auto phi_type{phi.Arg(0).Type()};
     if (!phi.Definition<Id>().is_valid) {
         // The phi node wasn't forward defined
         ctx.var_alloc.PhiDefine(phi, phi_type);

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -355,22 +355,11 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                   Id coords, Id dref, Id bias_lc, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    if (ctx.stage == Stage::Fragment) {
-        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
-                                     bias_lc, offset);
-        return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
-                    &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
-                    Texture(ctx, info, index), coords, dref, operands.MaskOptional(),
-                    operands.Span());
-    } else {
-        // Implicit lods in compute behave on hardware as if sampling from LOD 0.
-        // This check is to ensure all drivers behave this way.
-        const Id lod{ctx.Const(0.0f)};
-        const ImageOperands operands(ctx, false, true, false, lod, offset);
-        return Emit(&EmitContext::OpImageSparseSampleDrefExplicitLod,
-                    &EmitContext::OpImageSampleDrefExplicitLod, ctx, inst, ctx.F32[1],
-                    Texture(ctx, info, index), coords, dref, operands.Mask(), operands.Span());
-    }
+    const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0, bias_lc,
+                                 offset);
+    return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
+                &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
+                Texture(ctx, info, index), coords, dref, operands.MaskOptional(), operands.Span());
 }
 
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,

src/shader_recompiler/frontend/ir/basic_block.h

@@ -152,17 +152,6 @@ public:
         return instructions.crend();
     }
 
-    // Set the order of the block, it can be set pre order, the user decides
-    void SetOrder(u32 new_order) {
-        order = new_order;
-    }
-
-    // Get the order of the block.
-    // The higher, the closer is the block to the end.
-    [[nodiscard]] u32 GetOrder() const {
-        return order;
-    }
-
 private:
     /// Memory pool for instruction list
     ObjectPool<Inst>* inst_pool;
@@ -182,9 +171,6 @@ private:
 
     /// Intrusively stored host definition of this block.
     u32 definition{};
-
-    /// Order of the block.
-    u32 order{};
 };
 
 using BlockList = std::vector<Block*>;

src/shader_recompiler/frontend/ir/microinstruction.cpp

@@ -6,7 +6,6 @@
 #include <memory>
 
 #include "shader_recompiler/exception.h"
-#include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/type.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
@@ -254,10 +253,6 @@ Inst* Inst::GetAssociatedPseudoOperation(IR::Opcode opcode) {
 }
 
 IR::Type Inst::Type() const {
-    if (op == IR::Opcode::Phi) {
-        // The type of a phi node is stored in its flags
-        return Flags<IR::Type>();
-    }
     return TypeOf(op);
 }
 
@@ -296,16 +291,6 @@ void Inst::AddPhiOperand(Block* predecessor, const Value& value) {
     phi_args.emplace_back(predecessor, value);
 }
 
-void Inst::OrderPhiArgs() {
-    if (op != Opcode::Phi) {
-        throw LogicError("{} is not a Phi instruction", op);
-    }
-    std::sort(phi_args.begin(), phi_args.end(),
-              [](const std::pair<Block*, Value>& a, const std::pair<Block*, Value>& b) {
-                  return a.first->GetOrder() < b.first->GetOrder();
-              });
-}
-
 void Inst::Invalidate() {
     ClearArgs();
     ReplaceOpcode(Opcode::Void);

src/shader_recompiler/frontend/ir/value.h

@@ -182,9 +182,6 @@ public:
     /// Add phi operand to a phi instruction.
     void AddPhiOperand(Block* predecessor, const Value& value);
 
-    /// Orders the Phi arguments from farthest away to nearest.
-    void OrderPhiArgs();
-
     void Invalidate();
     void ClearArgs();
 

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -27,11 +27,9 @@ IR::BlockList GenerateBlocks(const IR::AbstractSyntaxList& syntax_list) {
     }
     IR::BlockList blocks;
     blocks.reserve(num_syntax_blocks);
-    u32 order_index{};
     for (const auto& node : syntax_list) {
         if (node.type == IR::AbstractSyntaxNode::Type::Block) {
             blocks.push_back(node.data.block);
-            blocks.back()->SetOrder(order_index++);
         }
     }
     return blocks;

src/shader_recompiler/ir_opt/ssa_rewrite_pass.cpp

@@ -14,7 +14,6 @@
 //      https://link.springer.com/chapter/10.1007/978-3-642-37051-9_6
 //
 
-#include <deque>
 #include <span>
 #include <variant>
 #include <vector>
@@ -371,26 +370,6 @@ void VisitBlock(Pass& pass, IR::Block* block) {
     }
     pass.SealBlock(block);
 }
-
-IR::Type GetConcreteType(IR::Inst* inst) {
-    std::deque<IR::Inst*> queue;
-    queue.push_back(inst);
-    while (!queue.empty()) {
-        IR::Inst* current = queue.front();
-        queue.pop_front();
-        const size_t num_args{current->NumArgs()};
-        for (size_t i = 0; i < num_args; ++i) {
-            const auto set_type = current->Arg(i).Type();
-            if (set_type != IR::Type::Opaque) {
-                return set_type;
-            }
-            if (!current->Arg(i).IsImmediate()) {
-                queue.push_back(current->Arg(i).Inst());
-            }
-        }
-    }
-    return IR::Type::Opaque;
-}
 } // Anonymous namespace
 
 void SsaRewritePass(IR::Program& program) {
@@ -399,16 +378,6 @@ void SsaRewritePass(IR::Program& program) {
     for (auto block = program.post_order_blocks.rbegin(); block != end; ++block) {
         VisitBlock(pass, *block);
     }
-    for (auto block = program.post_order_blocks.rbegin(); block != end; ++block) {
-        for (IR::Inst& inst : (*block)->Instructions()) {
-            if (inst.GetOpcode() == IR::Opcode::Phi) {
-                if (inst.Type() == IR::Type::Opaque) {
-                    inst.SetFlags(GetConcreteType(&inst));
-                }
-                inst.OrderPhiArgs();
-            }
-        }
-    }
 }
 
 } // namespace Shader::Optimization

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -492,7 +492,7 @@ void TexturePass(Environment& env, IR::Program& program) {
             const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
             IR::IREmitter ir{*texture_inst.block, insert_point};
             const IR::U32 shift{ir.Imm32(std::countr_zero(DESCRIPTOR_SIZE))};
-            inst->SetArg(0, ir.UMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
+            inst->SetArg(0, ir.SMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
                                     ir.Imm32(DESCRIPTOR_SIZE - 1)));
         } else {
             inst->SetArg(0, IR::Value{});

src/video_core/dirty_flags.h

@@ -38,9 +38,6 @@ enum : u8 {
 
     Shaders,
 
-    // Special entries
-    DepthBiasGlobal,
-
     LastCommonEntry,
 };
 

src/video_core/gpu_thread.cpp

@@ -32,7 +32,8 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
     VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
 
     while (!stop_token.stop_requested()) {
-        CommandDataContainer next = state.queue.PopWait(stop_token);
+        CommandDataContainer next;
+        state.queue.pop(next);
         if (stop_token.stop_requested()) {
             break;
         }
@@ -119,7 +120,7 @@ u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
 
     std::unique_lock lk(state.write_lock);
     const u64 fence{++state.last_fence};
-    state.queue.Push(CommandDataContainer(std::move(command_data), fence, block));
+    state.queue.push(CommandDataContainer(std::move(command_data), fence, block));
 
     if (block) {
         state.cv.wait(lk, thread.get_stop_token(), [this, fence] {

src/video_core/gpu_thread.h

@@ -97,9 +97,9 @@ struct CommandDataContainer {
 
 /// Struct used to synchronize the GPU thread
 struct SynchState final {
-    using CommandQueue = Common::SPSCQueue<CommandDataContainer, true>;
+    using CommandQueue = Common::MPMCQueue<CommandDataContainer>;
     std::mutex write_lock;
-    CommandQueue queue;
+    CommandQueue queue{100000};
     u64 last_fence{};
     std::atomic<u64> signaled_fence{};
     std::condition_variable_any cv;

src/video_core/renderer_opengl/gl_device.cpp

@@ -10,7 +10,6 @@
 #include <limits>
 #include <optional>
 #include <span>
-#include <stdexcept>
 #include <vector>
 
 #include <glad/glad.h>
@@ -181,21 +180,6 @@ Device::Device() {
         LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
         shader_backend = Settings::ShaderBackend::GLSL;
     }
-
-    if (shader_backend == Settings::ShaderBackend::GLSL && is_nvidia &&
-        !Settings::values.renderer_debug) {
-        const std::string_view driver_version = version.substr(13);
-        const int version_major =
-            std::atoi(driver_version.substr(0, driver_version.find(".")).data());
-
-        if (version_major >= 495) {
-            LOG_WARNING(Render_OpenGL, "NVIDIA drivers 495 and later causes significant problems "
-                                       "with yuzu. Forcing GLASM as a mitigation.");
-            shader_backend = Settings::ShaderBackend::GLASM;
-            use_assembly_shaders = true;
-        }
-    }
-
     // Blocks AMD and Intel OpenGL drivers on Windows from using asynchronous shader compilation.
     use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue() &&
                                !(is_amd || (is_intel && !is_linux));

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -10,14 +10,16 @@
 #include <string_view>
 #include <tuple>
 #include <utility>
-
 #include <glad/glad.h>
-
+#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/microprofile.h"
+#include "common/scope_exit.h"
 #include "common/settings.h"
+#include "core/core.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/memory.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -627,21 +627,9 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchDepthBias()) {
         return;
     }
-    float units = regs.polygon_offset_units / 2.0f;
-    const bool is_d24 = regs.zeta.format == Tegra::DepthFormat::S8_UINT_Z24_UNORM ||
-                        regs.zeta.format == Tegra::DepthFormat::D24X8_UNORM ||
-                        regs.zeta.format == Tegra::DepthFormat::D24S8_UNORM ||
-                        regs.zeta.format == Tegra::DepthFormat::D24C8_UNORM;
-    if (is_d24 && !device.SupportsD24DepthBuffer()) {
-        // the base formulas can be obtained from here:
-        //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
-        const double rescale_factor =
-            static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
-        units = static_cast<float>(static_cast<double>(units) * rescale_factor);
-    }
-    scheduler.Record([constant = units, clamp = regs.polygon_offset_clamp,
+    scheduler.Record([constant = regs.polygon_offset_units, clamp = regs.polygon_offset_clamp,
                       factor = regs.polygon_offset_factor](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthBias(constant, clamp, factor);
+        cmdbuf.SetDepthBias(constant, clamp, factor / 2.0f);
     });
 }
 

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -54,7 +54,6 @@ void SetupDirtyViewports(Tables& tables) {
     FillBlock(tables[0], OFF(viewport_transform), NUM(viewport_transform), Viewports);
     FillBlock(tables[0], OFF(viewports), NUM(viewports), Viewports);
     tables[0][OFF(viewport_transform_enabled)] = Viewports;
-    tables[1][OFF(screen_y_control)] = Viewports;
 }
 
 void SetupDirtyScissors(Tables& tables) {

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -79,8 +79,7 @@ public:
     }
 
     bool TouchDepthBias() {
-        return Exchange(Dirty::DepthBias, false) ||
-               Exchange(VideoCommon::Dirty::DepthBiasGlobal, false);
+        return Exchange(Dirty::DepthBias, false);
     }
 
     bool TouchBlendConstants() {

src/video_core/texture_cache/texture_cache.h

@@ -221,7 +221,6 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
     }
     const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
-
     PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
 
     for (size_t index = 0; index < NUM_RT; ++index) {
@@ -231,8 +230,6 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         maxwell3d.regs.render_area.width,
         maxwell3d.regs.render_area.height,
     };
-
-    flags[Dirty::DepthBiasGlobal] = true;
 }
 
 template <class P>

src/video_core/vulkan_common/vulkan_device.cpp

@@ -623,10 +623,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         is_float16_supported = false;
     }
 
-    supports_d24_depth =
-        IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
-                          VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
-
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);
 }

src/video_core/vulkan_common/vulkan_device.h

@@ -332,10 +332,6 @@ public:
         return sets_per_pool;
     }
 
-    bool SupportsD24DepthBuffer() const {
-        return supports_d24_depth;
-    }
-
 private:
     /// Checks if the physical device is suitable.
     void CheckSuitability(bool requires_swapchain) const;
@@ -429,7 +425,6 @@ private:
     bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
     bool has_renderdoc{};                   ///< Has RenderDoc attached
     bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
-    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
 
     // Telemetry parameters
     std::string vendor_name;                       ///< Device's driver name.

src/yuzu/CMakeLists.txt

@@ -299,11 +299,6 @@ if (YUZU_USE_BUNDLED_QT)
     copy_yuzu_Qt5_deps(yuzu)
 endif()
 
-if (ENABLE_SDL2)
-    target_link_libraries(yuzu PRIVATE SDL2)
-    target_compile_definitions(yuzu PRIVATE HAVE_SDL2)
-endif()
-
 if (MSVC)
     include(CopyYuzuSDLDeps)
     include(CopyYuzuFFmpegDeps)

src/yuzu/configuration/config.cpp

@@ -918,7 +918,8 @@ void Config::ReadSystemValues() {
         const auto custom_rtc_enabled =
             ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
         if (custom_rtc_enabled) {
-            Settings::values.custom_rtc = ReadSetting(QStringLiteral("custom_rtc"), 0).toLongLong();
+            Settings::values.custom_rtc =
+                std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
         } else {
             Settings::values.custom_rtc = std::nullopt;
         }
@@ -1449,7 +1450,9 @@ void Config::SaveSystemValues() {
         WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
                      false);
         WriteSetting(QStringLiteral("custom_rtc"),
-                     QVariant::fromValue<long long>(Settings::values.custom_rtc.value_or(0)), 0);
+                     QVariant::fromValue<long long>(
+                         Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
+                     0);
     }
 
     WriteGlobalSetting(Settings::values.sound_index);

src/yuzu/configuration/configure_dialog.cpp

@@ -81,11 +81,8 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     SetConfiguration();
     PopulateSelectionList();
 
-    connect(ui->tabWidget, &QTabWidget::currentChanged, this, [this](int index) {
-        if (index != -1) {
-            debug_tab_tab->SetCurrentIndex(0);
-        }
-    });
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this,
+            [this]() { debug_tab_tab->SetCurrentIndex(0); });
     connect(ui_tab.get(), &ConfigureUi::LanguageChanged, this, &ConfigureDialog::OnLanguageChanged);
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);

src/yuzu/configuration/configure_per_game.cpp

@@ -66,7 +66,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id, const std::str
     ui->tabWidget->addTab(system_tab.get(), tr("System"));
     ui->tabWidget->addTab(cpu_tab.get(), tr("CPU"));
     ui->tabWidget->addTab(graphics_tab.get(), tr("Graphics"));
-    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("Adv. Graphics"));
+    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("GraphicsAdvanced"));
     ui->tabWidget->addTab(audio_tab.get(), tr("Audio"));
 
     setFocusPolicy(Qt::ClickFocus);

src/yuzu/configuration/configure_per_game.ui

@@ -2,6 +2,14 @@
 <ui version="4.0">
  <class>ConfigurePerGame</class>
  <widget class="QDialog" name="ConfigurePerGame">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>900</width>
+    <height>630</height>
+   </rect>
+  </property>
   <property name="minimumSize">
    <size>
     <width>900</width>

src/yuzu/configuration/configure_profile_manager.cpp

@@ -306,17 +306,6 @@ void ConfigureProfileManager::SetUserImage() {
         return;
     }
 
-    // Some games crash when the profile image is too big. Resize any image bigger than 256x256
-    QImage image(image_path);
-    if (image.width() > 256 || image.height() > 256) {
-        image = image.scaled(256, 256, Qt::KeepAspectRatio);
-        if (!image.save(image_path)) {
-            QMessageBox::warning(this, tr("Error resizing user image"),
-                                 tr("Unable to resize image"));
-            return;
-        }
-    }
-
     const auto username = GetAccountUsername(*profile_manager, *uuid);
     item_model->setItem(index, 0,
                         new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});

src/yuzu/configuration/configure_system.cpp

@@ -65,7 +65,8 @@ void ConfigureSystem::SetConfiguration() {
         QStringLiteral("%1")
             .arg(Settings::values.rng_seed.GetValue().value_or(0), 8, 16, QLatin1Char{'0'})
             .toUpper();
-    const auto rtc_time = Settings::values.custom_rtc.value_or(QDateTime::currentSecsSinceEpoch());
+    const auto rtc_time = Settings::values.custom_rtc.value_or(
+        std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
 
     ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
     ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
@@ -74,7 +75,7 @@ void ConfigureSystem::SetConfiguration() {
 
     ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.has_value());
     ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.has_value());
-    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time));
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
 
     if (Settings::IsConfiguringGlobal()) {
         ui->combo_language->setCurrentIndex(Settings::values.language_index.GetValue());
@@ -107,9 +108,10 @@ void ConfigureSystem::ApplyConfiguration() {
     // to allow in-game time to be fast forwarded
     if (Settings::IsConfiguringGlobal()) {
         if (ui->custom_rtc_checkbox->isChecked()) {
-            Settings::values.custom_rtc = ui->custom_rtc_edit->dateTime().toSecsSinceEpoch();
+            Settings::values.custom_rtc =
+                std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
             if (system.IsPoweredOn()) {
-                const s64 posix_time{*Settings::values.custom_rtc +
+                const s64 posix_time{Settings::values.custom_rtc->count() +
                                      Service::Time::TimeManager::GetExternalTimeZoneOffset()};
                 system.GetTimeManager().UpdateLocalSystemClockTime(posix_time);
             }