Address issues

Fixes random swkbd popups in monster hunter

.ci/scripts/linux/docker.sh

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
 
 ninja
 

.ci/scripts/windows/docker.sh

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
 ninja
 
 ccache -s

CMakeLists.txt

@@ -13,6 +13,7 @@ project(yuzu)
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
+option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
@@ -118,8 +119,17 @@ message(STATUS "Target architecture: ${ARCHITECTURE}")
 # Configure C++ standard
 # ===========================
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# boost asio's concept usage doesn't play nicely with some compilers yet.
+add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
+if (MSVC)
+    add_compile_options(/std:c++latest)
+
+    # cubeb and boost still make use of deprecated result_of.
+    add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
+else()
+    set(CMAKE_CXX_STANDARD 20)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
 
 # Output binaries to bin/
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
@@ -151,7 +161,7 @@ macro(yuzu_find_packages)
     #    Cmake Pkg Prefix  Version     Conan Pkg
         "Boost             1.71        boost/1.72.0"
         "Catch2            2.11        catch2/2.11.0"
-        "fmt               6.2         fmt/6.2.0"
+        "fmt               7.0         fmt/7.0.1"
     # can't use until https://github.com/bincrafters/community/issues/1173
         #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
         "lz4               1.8         lz4/1.9.2"
@@ -211,10 +221,14 @@ if(ENABLE_QT)
 
         set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
     endif()
-    find_package(Qt5 5.9 COMPONENTS Widgets OpenGL ${QT_PREFIX_HINT})
+    find_package(Qt5 5.9 COMPONENTS Widgets ${QT_PREFIX_HINT})
     if (YUZU_USE_QT_WEB_ENGINE)
         find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
+	
+    if (ENABLE_QT_TRANSLATION)
+        find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
+    endif()
     if (NOT Qt5_FOUND)
         list(APPEND CONAN_REQUIRED_LIBS "qt/5.14.1@bincrafters/stable")
     endif()
@@ -287,7 +301,7 @@ if (CONAN_REQUIRED_LIBS)
     if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
         list(APPEND CMAKE_PREFIX_PATH "${CONAN_QT_ROOT_RELEASE}")
-        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets OpenGL)
+        find_package(Qt5 5.9 REQUIRED COMPONENTS Widgets)
         if (YUZU_USE_QT_WEB_ENGINE)
             find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
         endif()
@@ -330,13 +344,16 @@ elseif(SDL2_FOUND)
 endif()
 
 # Ensure libusb is properly configured (based on dolphin libusb include)
-find_package(LibUSB)
+if(NOT APPLE)
+    include(FindPkgConfig)
+    find_package(LibUSB)
+endif()
 if (NOT LIBUSB_FOUND)
     add_subdirectory(externals/libusb)
+    set(LIBUSB_INCLUDE_DIR "")
     set(LIBUSB_LIBRARIES usb)
 endif()
 
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -15,7 +15,6 @@ function(copy_yuzu_Qt5_deps target_dir)
         icuuc*.dll
         Qt5Core$<$<CONFIG:Debug>:d>.*
         Qt5Gui$<$<CONFIG:Debug>:d>.*
-        Qt5OpenGL$<$<CONFIG:Debug>:d>.*
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
 

README.md

@@ -2,7 +2,7 @@ yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
-[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.gg/XQV6dn9)
+[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.com/invite/u77vRWY)
 
 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
 
@@ -16,7 +16,7 @@ yuzu is licensed under the GPLv2 (or any later version). Refer to the license.tx
 
 Check out our [website](https://yuzu-emu.org/)!
 
-For development discussion, please join us on [Discord](https://discord.gg/XQV6dn9).
+For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
 
 ### Development
 
@@ -24,6 +24,8 @@ Most of the development happens on GitHub. It's also where [our central reposito
 
 If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
 
+If you want to contribute to the user interface translation, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
+
 ### Building
 
 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)

dist/languages/.gitignore

@@ -0,0 +1,2 @@
+# Ignore the source language file
+en.ts

dist/languages/.tx/config

@@ -0,0 +1,8 @@
+[main]
+host = https://www.transifex.com
+
+[yuzu.emulator]
+file_filter = <lang>.ts
+source_file = en.ts
+source_lang = en
+type = QT

dist/languages/README.md

@@ -0,0 +1 @@
+This directory stores translation patches (TS files) for yuzu Qt frontend. This directory is linked with [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu), so you can update the translation by executing `tx pull -a`. If you want to contribute to the translation, please go the transifex link and submit your translation there. This directory on the main repo will be synchronized with transifex periodically. Do not directly open PRs on github to modify the translation.

src/audio_core/cubeb_sink.cpp

@@ -193,7 +193,7 @@ long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const
     const std::size_t samples_to_write = num_channels * num_frames;
     std::size_t samples_written;
 
-    if (Settings::values.enable_audio_stretching) {
+    if (Settings::values.enable_audio_stretching.GetValue()) {
         const std::vector<s16> in{impl->queue.Pop()};
         const std::size_t num_in{in.size() / num_channels};
         s16* const out{reinterpret_cast<s16*>(buffer)};

src/audio_core/stream.cpp

@@ -38,7 +38,7 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format fo
       sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
 
     release_event = Core::Timing::CreateEvent(
-        name, [this](u64 userdata, s64 cycles_late) { ReleaseActiveBuffer(cycles_late); });
+        name, [this](u64, std::chrono::nanoseconds ns_late) { ReleaseActiveBuffer(ns_late); });
 }
 
 void Stream::Play() {
@@ -59,11 +59,9 @@ Stream::State Stream::GetState() const {
     return state;
 }
 
-s64 Stream::GetBufferReleaseNS(const Buffer& buffer) const {
+std::chrono::nanoseconds Stream::GetBufferReleaseNS(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const auto ns =
-        std::chrono::nanoseconds((static_cast<u64>(num_samples) * 1000000000ULL) / sample_rate);
-    return ns.count();
+    return std::chrono::nanoseconds((static_cast<u64>(num_samples) * 1000000000ULL) / sample_rate);
 }
 
 static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
@@ -80,7 +78,7 @@ static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
     }
 }
 
-void Stream::PlayNextBuffer(s64 cycles_late) {
+void Stream::PlayNextBuffer(std::chrono::nanoseconds ns_late) {
     if (!IsPlaying()) {
         // Ensure we are in playing state before playing the next buffer
         sink_stream.Flush();
@@ -105,16 +103,18 @@ void Stream::PlayNextBuffer(s64 cycles_late) {
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    core_timing.ScheduleEvent(GetBufferReleaseNS(*active_buffer) -
-                                  (Settings::values.enable_audio_stretching ? 0 : cycles_late),
-                              release_event, {});
+    const auto time_stretch_delta = Settings::values.enable_audio_stretching.GetValue()
+                                        ? std::chrono::nanoseconds::zero()
+                                        : ns_late;
+    const auto future_time = GetBufferReleaseNS(*active_buffer) - time_stretch_delta;
+    core_timing.ScheduleEvent(future_time, release_event, {});
 }
 
-void Stream::ReleaseActiveBuffer(s64 cycles_late) {
+void Stream::ReleaseActiveBuffer(std::chrono::nanoseconds ns_late) {
     ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();
-    PlayNextBuffer(cycles_late);
+    PlayNextBuffer(ns_late);
 }
 
 bool Stream::QueueBuffer(BufferPtr&& buffer) {

src/audio_core/stream.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <functional>
 #include <memory>
 #include <string>
@@ -90,16 +91,13 @@ public:
 
 private:
     /// Plays the next queued buffer in the audio stream, starting playback if necessary
-    void PlayNextBuffer(s64 cycles_late = 0);
+    void PlayNextBuffer(std::chrono::nanoseconds ns_late = {});
 
     /// Releases the actively playing buffer, signalling that it has been completed
-    void ReleaseActiveBuffer(s64 cycles_late = 0);
+    void ReleaseActiveBuffer(std::chrono::nanoseconds ns_late = {});
 
     /// Gets the number of core cycles when the specified buffer will be released
-    s64 GetBufferReleaseNS(const Buffer& buffer) const;
-
-    /// Gets the number of core cycles when the specified buffer will be released
-    s64 GetBufferReleaseNSHostTiming(const Buffer& buffer) const;
+    std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
 
     u32 sample_rate;                  ///< Sample rate of the stream
     Format format;                    ///< Format of the stream

src/common/CMakeLists.txt

@@ -191,9 +191,5 @@ endif()
 create_target_directory_groups(common)
 find_package(Boost 1.71 COMPONENTS context headers REQUIRED)
 
-if (fmt_FOUND)
-    target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt microprofile)
-else()
-    target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
-endif()
+target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd xbyak)

src/common/alignment.h

@@ -3,7 +3,7 @@
 #pragma once
 
 #include <cstddef>
-#include <memory>
+#include <new>
 #include <type_traits>
 
 namespace Common {
@@ -11,7 +11,9 @@ namespace Common {
 template <typename T>
 constexpr T AlignUp(T value, std::size_t size) {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    return static_cast<T>(value + (size - value % size) % size);
+    auto mod{static_cast<T>(value % size)};
+    value -= mod;
+    return static_cast<T>(mod == T{0} ? value : value + size);
 }
 
 template <typename T>
@@ -52,66 +54,28 @@ public:
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
 
-    using pointer = T*;
-    using const_pointer = const T*;
-
-    using reference = T&;
-    using const_reference = const T&;
-
     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::true_type;
 
-public:
     constexpr AlignmentAllocator() noexcept = default;
 
     template <typename T2>
     constexpr AlignmentAllocator(const AlignmentAllocator<T2, Align>&) noexcept {}
 
-    pointer address(reference r) noexcept {
-        return std::addressof(r);
+    T* allocate(size_type n) {
+        return static_cast<T*>(::operator new (n * sizeof(T), std::align_val_t{Align}));
     }
 
-    const_pointer address(const_reference r) const noexcept {
-        return std::addressof(r);
-    }
-
-    pointer allocate(size_type n) {
-        return static_cast<pointer>(::operator new (n, std::align_val_t{Align}));
-    }
-
-    void deallocate(pointer p, size_type) {
-        ::operator delete (p, std::align_val_t{Align});
-    }
-
-    void construct(pointer p, const value_type& wert) {
-        new (p) value_type(wert);
-    }
-
-    void destroy(pointer p) {
-        p->~value_type();
-    }
-
-    size_type max_size() const noexcept {
-        return size_type(-1) / sizeof(value_type);
+    void deallocate(T* p, size_type n) {
+        ::operator delete (p, n * sizeof(T), std::align_val_t{Align});
     }
 
     template <typename T2>
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
-
-    bool operator!=(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return !(*this == other);
-    }
-
-    // Returns true if and only if storage allocated from *this
-    // can be deallocated from other, and vice versa.
-    // Always returns true for stateless allocators.
-    bool operator==(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return true;
-    }
 };
 
 } // namespace Common

src/common/swap.h

@@ -17,43 +17,14 @@
 
 #pragma once
 
-#include <type_traits>
-
 #if defined(_MSC_VER)
 #include <cstdlib>
 #endif
+#include <bit>
 #include <cstring>
+#include <type_traits>
 #include "common/common_types.h"
 
-// GCC
-#ifdef __GNUC__
-
-#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN)
-#define COMMON_LITTLE_ENDIAN 1
-#elif __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) && !defined(COMMON_BIG_ENDIAN)
-#define COMMON_BIG_ENDIAN 1
-#endif
-
-// LLVM/clang
-#elif defined(__clang__)
-
-#if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN)
-#define COMMON_LITTLE_ENDIAN 1
-#elif __BIG_ENDIAN__ && !defined(COMMON_BIG_ENDIAN)
-#define COMMON_BIG_ENDIAN 1
-#endif
-
-// MSVC
-#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN)
-
-#define COMMON_LITTLE_ENDIAN 1
-#endif
-
-// Worst case, default to little endian.
-#if !COMMON_BIG_ENDIAN && !COMMON_LITTLE_ENDIAN
-#define COMMON_LITTLE_ENDIAN 1
-#endif
-
 namespace Common {
 
 #ifdef _MSC_VER
@@ -675,17 +646,8 @@ struct AddEndian<T, SwapTag> {
 };
 
 // Alias LETag/BETag as KeepTag/SwapTag depending on the system
-#if COMMON_LITTLE_ENDIAN
-
-using LETag = KeepTag;
-using BETag = SwapTag;
-
-#else
-
-using BETag = KeepTag;
-using LETag = SwapTag;
-
-#endif
+using LETag = std::conditional_t<std::endian::native == std::endian::little, KeepTag, SwapTag>;
+using BETag = std::conditional_t<std::endian::native == std::endian::big, KeepTag, SwapTag>;
 
 // Aliases for LE types
 using u16_le = AddEndian<u16, LETag>::type;

src/core/CMakeLists.txt

@@ -185,6 +185,7 @@ add_library(core STATIC
     hle/kernel/object.h
     hle/kernel/physical_core.cpp
     hle/kernel/physical_core.h
+    hle/kernel/physical_memory.h
     hle/kernel/process.cpp
     hle/kernel/process.h
     hle/kernel/process_capability.cpp
@@ -398,10 +399,13 @@ add_library(core STATIC
     hle/service/lm/manager.h
     hle/service/mig/mig.cpp
     hle/service/mig/mig.h
+    hle/service/mii/manager.cpp
+    hle/service/mii/manager.h
     hle/service/mii/mii.cpp
     hle/service/mii/mii.h
-    hle/service/mii/mii_manager.cpp
-    hle/service/mii/mii_manager.h
+    hle/service/mii/raw_data.cpp
+    hle/service/mii/raw_data.h
+    hle/service/mii/types.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
     hle/service/ncm/ncm.cpp

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -142,10 +142,32 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
     // Timing
     config.wall_clock_cntpct = uses_wall_clock;
 
-    // Optimizations
-    if (Settings::values.disable_cpu_opt) {
-        config.enable_optimizations = false;
-        config.enable_fast_dispatch = false;
+    // Safe optimizations
+    if (Settings::values.cpu_accuracy != Settings::CPUAccuracy::Accurate) {
+        if (!Settings::values.cpuopt_page_tables) {
+            config.page_table = nullptr;
+        }
+        if (!Settings::values.cpuopt_block_linking) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::BlockLinking;
+        }
+        if (!Settings::values.cpuopt_return_stack_buffer) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::ReturnStackBuffer;
+        }
+        if (!Settings::values.cpuopt_fast_dispatcher) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::FastDispatch;
+        }
+        if (!Settings::values.cpuopt_context_elimination) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::GetSetElimination;
+        }
+        if (!Settings::values.cpuopt_const_prop) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::ConstProp;
+        }
+        if (!Settings::values.cpuopt_misc_ir) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::MiscIROpt;
+        }
+        if (!Settings::values.cpuopt_reduce_misalign_checks) {
+            config.only_detect_misalignment_via_page_table_on_page_boundary = false;
+        }
     }
 
     return std::make_unique<Dynarmic::A32::Jit>(config);

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -191,15 +191,37 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
     // Unpredictable instructions
     config.define_unpredictable_behaviour = true;
 
-    // Optimizations
-    if (Settings::values.disable_cpu_opt) {
-        config.enable_optimizations = false;
-        config.enable_fast_dispatch = false;
-    }
-
     // Timing
     config.wall_clock_cntpct = uses_wall_clock;
 
+    // Safe optimizations
+    if (Settings::values.cpu_accuracy != Settings::CPUAccuracy::Accurate) {
+        if (!Settings::values.cpuopt_page_tables) {
+            config.page_table = nullptr;
+        }
+        if (!Settings::values.cpuopt_block_linking) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::BlockLinking;
+        }
+        if (!Settings::values.cpuopt_return_stack_buffer) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::ReturnStackBuffer;
+        }
+        if (!Settings::values.cpuopt_fast_dispatcher) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::FastDispatch;
+        }
+        if (!Settings::values.cpuopt_context_elimination) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::GetSetElimination;
+        }
+        if (!Settings::values.cpuopt_const_prop) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::ConstProp;
+        }
+        if (!Settings::values.cpuopt_misc_ir) {
+            config.optimizations &= ~Dynarmic::OptimizationFlag::MiscIROpt;
+        }
+        if (!Settings::values.cpuopt_reduce_misalign_checks) {
+            config.only_detect_misalignment_via_page_table_on_page_boundary = false;
+        }
+    }
+
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
 

src/core/constants.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <array>
 #include "common/common_types.h"
 
 // This is to consolidate system-wide constants that are used by multiple components of yuzu.

src/core/core.cpp

@@ -147,8 +147,8 @@ struct System::Impl {
 
         device_memory = std::make_unique<Core::DeviceMemory>(system);
 
-        is_multicore = Settings::values.use_multi_core;
-        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation;
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation.GetValue();
 
         kernel.SetMulticore(is_multicore);
         cpu_manager.SetMulticore(is_multicore);
@@ -162,7 +162,7 @@ struct System::Impl {
         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;
+            Settings::values.custom_rtc.GetValue().value_or(current_time) - current_time;
 
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr)

src/core/core_timing.cpp

@@ -53,12 +53,12 @@ void CoreTiming::ThreadEntry(CoreTiming& instance) {
     instance.ThreadLoop();
 }
 
-void CoreTiming::Initialize(std::function<void(void)>&& on_thread_init_) {
+void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
     on_thread_init = std::move(on_thread_init_);
     event_fifo_id = 0;
     shutting_down = false;
     ticks = 0;
-    const auto empty_timed_callback = [](u64, s64) {};
+    const auto empty_timed_callback = [](u64, std::chrono::nanoseconds) {};
     ev_lost = CreateEvent("_lost_event", empty_timed_callback);
     if (is_multicore) {
         timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
@@ -106,11 +106,11 @@ bool CoreTiming::HasPendingEvents() const {
     return !(wait_set && event_queue.empty());
 }
 
-void CoreTiming::ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type,
-                               u64 userdata) {
+void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
+                               const std::shared_ptr<EventType>& event_type, u64 userdata) {
     {
         std::scoped_lock scope{basic_lock};
-        const u64 timeout = static_cast<u64>(GetGlobalTimeNs().count() + ns_into_future);
+        const u64 timeout = static_cast<u64>((GetGlobalTimeNs() + ns_into_future).count());
 
         event_queue.emplace_back(Event{timeout, event_fifo_id++, userdata, event_type});
 
@@ -172,7 +172,7 @@ void CoreTiming::ClearPendingEvents() {
 }
 
 void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
-    basic_lock.lock();
+    std::scoped_lock lock{basic_lock};
 
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
         return e.type.lock().get() == event_type.get();
@@ -183,12 +183,10 @@ void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
         event_queue.erase(itr, event_queue.end());
         std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
     }
-    basic_lock.unlock();
 }
 
 std::optional<s64> CoreTiming::Advance() {
-    std::scoped_lock advance_scope{advance_lock};
-    std::scoped_lock basic_scope{basic_lock};
+    std::scoped_lock lock{advance_lock, basic_lock};
     global_timer = GetGlobalTimeNs().count();
 
     while (!event_queue.empty() && event_queue.front().time <= global_timer) {
@@ -197,8 +195,9 @@ std::optional<s64> CoreTiming::Advance() {
         event_queue.pop_back();
         basic_lock.unlock();
 
-        if (auto event_type{evt.type.lock()}) {
-            event_type->callback(evt.userdata, global_timer - evt.time);
+        if (const auto event_type{evt.type.lock()}) {
+            event_type->callback(
+                evt.userdata, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
         }
 
         basic_lock.lock();

src/core/core_timing.h

@@ -17,14 +17,12 @@
 #include "common/common_types.h"
 #include "common/spin_lock.h"
 #include "common/thread.h"
-#include "common/threadsafe_queue.h"
 #include "common/wall_clock.h"
-#include "core/hardware_properties.h"
 
 namespace Core::Timing {
 
 /// A callback that may be scheduled for a particular core timing event.
-using TimedCallback = std::function<void(u64 userdata, s64 cycles_late)>;
+using TimedCallback = std::function<void(u64 userdata, std::chrono::nanoseconds ns_late)>;
 
 /// Contains the characteristics of a particular event.
 struct EventType {
@@ -42,12 +40,12 @@ struct EventType {
  * in main CPU clock cycles.
  *
  * To schedule an event, you first have to register its type. This is where you pass in the
- * callback. You then schedule events using the type id you get back.
+ * callback. You then schedule events using the type ID you get back.
  *
- * The int cyclesLate that the callbacks get is how many cycles late it was.
+ * The s64 ns_late that the callbacks get is how many ns late it was.
  * So to schedule a new event on a regular basis:
  * inside callback:
- *   ScheduleEvent(periodInCycles - cyclesLate, callback, "whatever")
+ *   ScheduleEvent(period_in_ns - ns_late, callback, "whatever")
  */
 class CoreTiming {
 public:
@@ -62,7 +60,7 @@ public:
 
     /// CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
     /// required to end slice - 1 and start slice 0 before the first cycle of code is executed.
-    void Initialize(std::function<void(void)>&& on_thread_init_);
+    void Initialize(std::function<void()>&& on_thread_init_);
 
     /// Tears down all timing related functionality.
     void Shutdown();
@@ -95,8 +93,8 @@ public:
     bool HasPendingEvents() const;
 
     /// Schedules an event in core timing
-    void ScheduleEvent(s64 ns_into_future, const std::shared_ptr<EventType>& event_type,
-                       u64 userdata = 0);
+    void ScheduleEvent(std::chrono::nanoseconds ns_into_future,
+                       const std::shared_ptr<EventType>& event_type, u64 userdata = 0);
 
     void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, u64 userdata);
 
@@ -141,8 +139,6 @@ private:
 
     u64 global_timer = 0;
 
-    std::chrono::nanoseconds start_point;
-
     // The queue is a min-heap using std::make_heap/push_heap/pop_heap.
     // We don't use std::priority_queue because we need to be able to serialize, unserialize and
     // erase arbitrary events (RemoveEvent()) regardless of the queue order. These aren't
@@ -161,7 +157,7 @@ private:
     std::atomic<bool> wait_set{};
     std::atomic<bool> shutting_down{};
     std::atomic<bool> has_started{};
-    std::function<void(void)> on_thread_init{};
+    std::function<void()> on_thread_init{};
 
     bool is_multicore{};
 

src/core/cpu_manager.h

@@ -9,6 +9,9 @@
 #include <functional>
 #include <memory>
 #include <thread>
+
+#include "common/fiber.h"
+#include "common/thread.h"
 #include "core/hardware_properties.h"
 
 namespace Common {
@@ -46,9 +49,9 @@ public:
 
     void Pause(bool paused);
 
-    std::function<void(void*)> GetGuestThreadStartFunc();
-    std::function<void(void*)> GetIdleThreadStartFunc();
-    std::function<void(void*)> GetSuspendThreadStartFunc();
+    static std::function<void(void*)> GetGuestThreadStartFunc();
+    static std::function<void(void*)> GetIdleThreadStartFunc();
+    static std::function<void(void*)> GetSuspendThreadStartFunc();
     void* GetStartFuncParamater();
 
     void PreemptSingleCore(bool from_running_enviroment = true);
@@ -97,7 +100,6 @@ private:
     bool is_async_gpu{};
     bool is_multicore{};
     std::atomic<std::size_t> current_core{};
-    std::size_t preemption_count{};
     std::size_t idle_count{};
     static constexpr std::size_t max_cycle_runs = 5;
 

src/core/crypto/key_manager.cpp

@@ -695,8 +695,9 @@ void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
 }
 
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    if (s128_keys.find({id, field1, field2}) != s128_keys.end())
+    if (s128_keys.find({id, field1, field2}) != s128_keys.end() || key == Key128{}) {
         return;
+    }
     if (id == S128KeyType::Titlekey) {
         Key128 rights_id;
         std::memcpy(rights_id.data(), &field2, sizeof(u64));
@@ -716,8 +717,9 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
             return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
                    std::tie(id, field1, field2);
         });
-    if (iter2 != s128_file_id.end())
+    if (iter2 != s128_file_id.end()) {
         WriteKeyToFile(category, iter2->first, key);
+    }
 
     // Variable cases
     if (id == S128KeyType::KeyArea) {
@@ -745,16 +747,18 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
 }
 
 void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    if (s256_keys.find({id, field1, field2}) != s256_keys.end())
+    if (s256_keys.find({id, field1, field2}) != s256_keys.end() || key == Key256{}) {
         return;
+    }
     const auto iter = std::find_if(
         s256_file_id.begin(), s256_file_id.end(),
         [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S256KeyType>> elem) {
             return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
                    std::tie(id, field1, field2);
         });
-    if (iter != s256_file_id.end())
+    if (iter != s256_file_id.end()) {
         WriteKeyToFile(KeyCategory::Standard, iter->first, key);
+    }
     s256_keys[{id, field1, field2}] = key;
 }
 

src/core/file_sys/bis_factory.cpp

@@ -12,6 +12,10 @@
 
 namespace FileSys {
 
+constexpr u64 NAND_USER_SIZE = 0x680000000;  // 26624 MiB
+constexpr u64 NAND_SYSTEM_SIZE = 0xA0000000; // 2560 MiB
+constexpr u64 NAND_TOTAL_SIZE = 0x747C00000; // 29820 MiB
+
 BISFactory::BISFactory(VirtualDir nand_root_, VirtualDir load_root_, VirtualDir dump_root_)
     : nand_root(std::move(nand_root_)), load_root(std::move(load_root_)),
       dump_root(std::move(dump_root_)),
@@ -110,30 +114,29 @@ VirtualDir BISFactory::GetImageDirectory() const {
 
 u64 BISFactory::GetSystemNANDFreeSpace() const {
     const auto sys_dir = GetOrCreateDirectoryRelative(nand_root, "/system");
-    if (sys_dir == nullptr)
-        return 0;
+    if (sys_dir == nullptr) {
+        return GetSystemNANDTotalSpace();
+    }
 
     return GetSystemNANDTotalSpace() - sys_dir->GetSize();
 }
 
 u64 BISFactory::GetSystemNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_system_size);
+    return NAND_SYSTEM_SIZE;
 }
 
 u64 BISFactory::GetUserNANDFreeSpace() const {
-    const auto usr_dir = GetOrCreateDirectoryRelative(nand_root, "/user");
-    if (usr_dir == nullptr)
-        return 0;
-
-    return GetUserNANDTotalSpace() - usr_dir->GetSize();
+    // For some reason games such as BioShock 1 checks whether this is exactly 0x680000000 bytes.
+    // Set the free space to be 1 MiB less than the total as a workaround to this issue.
+    return GetUserNANDTotalSpace() - 0x100000;
 }
 
 u64 BISFactory::GetUserNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_user_size);
+    return NAND_USER_SIZE;
 }
 
 u64 BISFactory::GetFullNANDTotalSpace() const {
-    return static_cast<u64>(Settings::values.nand_total_size);
+    return NAND_TOTAL_SIZE;
 }
 
 VirtualDir BISFactory::GetBCATDirectory(u64 title_id) const {

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -240,7 +240,7 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
 
 RomFSBuildContext::~RomFSBuildContext() = default;
 
-std::map<u64, VirtualFile> RomFSBuildContext::Build() {
+std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
     const u64 dir_hash_table_entry_count = romfs_get_hash_table_count(num_dirs);
     const u64 file_hash_table_entry_count = romfs_get_hash_table_count(num_files);
     dir_hash_table_size = 4 * dir_hash_table_entry_count;
@@ -294,7 +294,7 @@ std::map<u64, VirtualFile> RomFSBuildContext::Build() {
         cur_dir->parent->child = cur_dir;
     }
 
-    std::map<u64, VirtualFile> out;
+    std::multimap<u64, VirtualFile> out;
 
     // Populate file tables.
     for (const auto& it : files) {

src/core/file_sys/fsmitm_romfsbuild.h

@@ -43,7 +43,7 @@ public:
     ~RomFSBuildContext();
 
     // This finalizes the context.
-    std::map<u64, VirtualFile> Build();
+    std::multimap<u64, VirtualFile> Build();
 
 private:
     VirtualDir base;

src/core/file_sys/registered_cache.cpp

@@ -547,6 +547,56 @@ InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_ex
     return InstallEntry(*xci.GetSecurePartitionNSP(), overwrite_if_exists, copy);
 }
 
+bool RegisteredCache::RemoveExistingEntry(u64 title_id) {
+    const auto delete_nca = [this](const NcaID& id) {
+        const auto path = GetRelativePathFromNcaID(id, false, true, false);
+
+        if (dir->GetFileRelative(path) == nullptr) {
+            return false;
+        }
+
+        Core::Crypto::SHA256Hash hash{};
+        mbedtls_sha256_ret(id.data(), id.size(), hash.data(), 0);
+        const auto dirname = fmt::format("000000{:02X}", hash[0]);
+
+        const auto dir2 = GetOrCreateDirectoryRelative(dir, dirname);
+
+        const auto res = dir2->DeleteFile(fmt::format("{}.nca", Common::HexToString(id, false)));
+
+        return res;
+    };
+
+    // If an entry exists in the registered cache, remove it
+    if (HasEntry(title_id, ContentRecordType::Meta)) {
+        LOG_INFO(Loader,
+                 "Previously installed entry (v{}) for title_id={:016X} detected! "
+                 "Attempting to remove...",
+                 GetEntryVersion(title_id).value_or(0), title_id);
+        // Get all the ncas associated with the current CNMT and delete them
+        const auto meta_old_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Meta).value_or(NcaID{});
+        const auto program_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Program).value_or(NcaID{});
+        const auto data_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Data).value_or(NcaID{});
+        const auto control_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::Control).value_or(NcaID{});
+        const auto html_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::HtmlDocument).value_or(NcaID{});
+        const auto legal_id =
+            GetNcaIDFromMetadata(title_id, ContentRecordType::LegalInformation).value_or(NcaID{});
+
+        delete_nca(meta_old_id);
+        delete_nca(program_id);
+        delete_nca(data_id);
+        delete_nca(control_id);
+        delete_nca(html_id);
+        delete_nca(legal_id);
+        return true;
+    }
+    return false;
+}
+
 InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_exists,
                                             const VfsCopyFunction& copy) {
     const auto ncas = nsp.GetNCAsCollapsed();
@@ -560,31 +610,57 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
         return InstallResult::ErrorMetaFailed;
     }
 
-    // Install Metadata File
     const auto meta_id_raw = (*meta_iter)->GetName().substr(0, 32);
     const auto meta_id = Common::HexStringToArray<16>(meta_id_raw);
 
-    const auto res = RawInstallNCA(**meta_iter, copy, overwrite_if_exists, meta_id);
-    if (res != InstallResult::Success)
-        return res;
+    if ((*meta_iter)->GetSubdirectories().empty()) {
+        LOG_ERROR(Loader,
+                  "The file you are attempting to install does not contain a section0 within the "
+                  "metadata NCA and is therefore malformed. Verify that the file is valid.");
+        return InstallResult::ErrorMetaFailed;
+    }
 
-    // Install all the other NCAs
     const auto section0 = (*meta_iter)->GetSubdirectories()[0];
+
+    if (section0->GetFiles().empty()) {
+        LOG_ERROR(Loader,
+                  "The file you are attempting to install does not contain a CNMT within the "
+                  "metadata NCA and is therefore malformed. Verify that the file is valid.");
+        return InstallResult::ErrorMetaFailed;
+    }
+
     const auto cnmt_file = section0->GetFiles()[0];
     const CNMT cnmt(cnmt_file);
+
+    const auto title_id = cnmt.GetTitleID();
+    const auto result = RemoveExistingEntry(title_id);
+
+    // Install Metadata File
+    const auto res = RawInstallNCA(**meta_iter, copy, overwrite_if_exists, meta_id);
+    if (res != InstallResult::Success) {
+        return res;
+    }
+
+    // Install all the other NCAs
     for (const auto& record : cnmt.GetContentRecords()) {
         // Ignore DeltaFragments, they are not useful to us
-        if (record.type == ContentRecordType::DeltaFragment)
+        if (record.type == ContentRecordType::DeltaFragment) {
             continue;
+        }
         const auto nca = GetNCAFromNSPForID(nsp, record.nca_id);
-        if (nca == nullptr)
+        if (nca == nullptr) {
             return InstallResult::ErrorCopyFailed;
+        }
         const auto res2 = RawInstallNCA(*nca, copy, overwrite_if_exists, record.nca_id);
-        if (res2 != InstallResult::Success)
+        if (res2 != InstallResult::Success) {
             return res2;
+        }
     }
 
     Refresh();
+    if (result) {
+        return InstallResult::OverwriteExisting;
+    }
     return InstallResult::Success;
 }
 
@@ -610,8 +686,9 @@ InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
     mbedtls_sha256_ret(data.data(), data.size(), c_rec.hash.data(), 0);
     memcpy(&c_rec.nca_id, &c_rec.hash, 16);
     const CNMT new_cnmt(header, opt_header, {c_rec}, {});
-    if (!RawInstallYuzuMeta(new_cnmt))
+    if (!RawInstallYuzuMeta(new_cnmt)) {
         return InstallResult::ErrorMetaFailed;
+    }
     return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
 }
 
@@ -649,8 +726,9 @@ InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFuncti
     }
 
     auto out = dir->CreateFileRelative(path);
-    if (out == nullptr)
+    if (out == nullptr) {
         return InstallResult::ErrorCopyFailed;
+    }
     return copy(in, out, VFS_RC_LARGE_COPY_BLOCK) ? InstallResult::Success
                                                   : InstallResult::ErrorCopyFailed;
 }

src/core/file_sys/registered_cache.h

@@ -34,6 +34,7 @@ using VfsCopyFunction = std::function<bool(const VirtualFile&, const VirtualFile
 
 enum class InstallResult {
     Success,
+    OverwriteExisting,
     ErrorAlreadyExists,
     ErrorCopyFailed,
     ErrorMetaFailed,
@@ -154,6 +155,9 @@ public:
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const override;
 
+    // Removes an existing entry based on title id
+    bool RemoveExistingEntry(u64 title_id);
+
     // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
     // there is a meta NCA and all of them are accessible.
     InstallResult InstallEntry(const XCI& xci, bool overwrite_if_exists = false,

src/core/file_sys/sdmc_factory.cpp

@@ -10,6 +10,8 @@
 
 namespace FileSys {
 
+constexpr u64 SDMC_TOTAL_SIZE = 0x10000000000; // 1 TiB
+
 SDMCFactory::SDMCFactory(VirtualDir dir_)
     : dir(std::move(dir_)), contents(std::make_unique<RegisteredCache>(
                                 GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
@@ -46,7 +48,7 @@ u64 SDMCFactory::GetSDMCFreeSpace() const {
 }
 
 u64 SDMCFactory::GetSDMCTotalSpace() const {
-    return static_cast<u64>(Settings::values.sdmc_size);
+    return SDMC_TOTAL_SIZE;
 }
 
 } // namespace FileSys

src/core/file_sys/vfs_concat.cpp

@@ -11,7 +11,7 @@
 
 namespace FileSys {
 
-static bool VerifyConcatenationMapContinuity(const std::map<u64, VirtualFile>& map) {
+static bool VerifyConcatenationMapContinuity(const std::multimap<u64, VirtualFile>& map) {
     const auto last_valid = --map.end();
     for (auto iter = map.begin(); iter != last_valid;) {
         const auto old = iter++;
@@ -27,12 +27,12 @@ ConcatenatedVfsFile::ConcatenatedVfsFile(std::vector<VirtualFile> files_, std::s
     : name(std::move(name)) {
     std::size_t next_offset = 0;
     for (const auto& file : files_) {
-        files[next_offset] = file;
+        files.emplace(next_offset, file);
         next_offset += file->GetSize();
     }
 }
 
-ConcatenatedVfsFile::ConcatenatedVfsFile(std::map<u64, VirtualFile> files_, std::string name)
+ConcatenatedVfsFile::ConcatenatedVfsFile(std::multimap<u64, VirtualFile> files_, std::string name)
     : files(std::move(files_)), name(std::move(name)) {
     ASSERT(VerifyConcatenationMapContinuity(files));
 }
@@ -50,7 +50,7 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::vector<VirtualFile> f
 }
 
 VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
-                                                      std::map<u64, VirtualFile> files,
+                                                      std::multimap<u64, VirtualFile> files,
                                                       std::string name) {
     if (files.empty())
         return nullptr;

src/core/file_sys/vfs_concat.h

@@ -15,7 +15,7 @@ namespace FileSys {
 // read-only.
 class ConcatenatedVfsFile : public VfsFile {
     ConcatenatedVfsFile(std::vector<VirtualFile> files, std::string name);
-    ConcatenatedVfsFile(std::map<u64, VirtualFile> files, std::string name);
+    ConcatenatedVfsFile(std::multimap<u64, VirtualFile> files, std::string name);
 
 public:
     ~ConcatenatedVfsFile() override;
@@ -25,7 +25,7 @@ public:
 
     /// Convenience function that turns a map of offsets to files into a concatenated file, filling
     /// gaps with a given filler byte.
-    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::map<u64, VirtualFile> files,
+    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::multimap<u64, VirtualFile> files,
                                             std::string name);
 
     std::string GetName() const override;
@@ -40,7 +40,7 @@ public:
 
 private:
     // Maps starting offset to file -- more efficient.
-    std::map<u64, VirtualFile> files;
+    std::multimap<u64, VirtualFile> files;
     std::string name;
 };
 

src/core/file_sys/vfs_real.cpp

@@ -112,19 +112,26 @@ VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_
     const auto new_path =
         FileUtil::SanitizePath(new_path_, FileUtil::DirectorySeparator::PlatformDefault);
 
-    if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
-        FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path))
-        return nullptr;
-
     if (cache.find(old_path) != cache.end()) {
-        auto cached = cache[old_path];
-        if (!cached.expired()) {
-            auto file = cached.lock();
-            file->Open(new_path, "r+b");
-            cache.erase(old_path);
-            cache[new_path] = file;
+        auto file = cache[old_path].lock();
+
+        if (!cache[old_path].expired()) {
+            file->Close();
         }
+
+        if (!FileUtil::Exists(old_path) || FileUtil::Exists(new_path) ||
+            FileUtil::IsDirectory(old_path) || !FileUtil::Rename(old_path, new_path)) {
+            return nullptr;
+        }
+
+        cache.erase(old_path);
+        file->Open(new_path, "r+b");
+        cache[new_path] = file;
+    } else {
+        UNREACHABLE();
+        return nullptr;
     }
+
     return OpenFile(new_path, Mode::ReadWrite);
 }
 

src/core/frontend/framebuffer_layout.cpp

@@ -29,7 +29,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
 
     const float window_aspect_ratio = static_cast<float>(height) / width;
     const float emulation_aspect_ratio = EmulationAspectRatio(
-        static_cast<AspectRatio>(Settings::values.aspect_ratio), window_aspect_ratio);
+        static_cast<AspectRatio>(Settings::values.aspect_ratio.GetValue()), window_aspect_ratio);
 
     const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
     Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);

src/core/hardware_interrupt_manager.cpp

@@ -11,19 +11,20 @@
 namespace Core::Hardware {
 
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event = Core::Timing::CreateEvent("GPUInterrupt", [this](u64 message, s64) {
-        auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
-        const u32 syncpt = static_cast<u32>(message >> 32);
-        const u32 value = static_cast<u32>(message);
-        nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
-    });
+    gpu_interrupt_event =
+        Core::Timing::CreateEvent("GPUInterrupt", [this](u64 message, std::chrono::nanoseconds) {
+            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
+            const u32 syncpt = static_cast<u32>(message >> 32);
+            const u32 value = static_cast<u32>(message);
+            nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
+        });
 }
 
 InterruptManager::~InterruptManager() = default;
 
 void InterruptManager::GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
     const u64 msg = (static_cast<u64>(syncpoint_id) << 32ULL) | value;
-    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, msg);
+    system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds{10}, gpu_interrupt_event, msg);
 }
 
 } // namespace Core::Hardware

src/core/hle/kernel/address_arbiter.cpp

@@ -24,7 +24,6 @@ namespace Kernel {
 // Wake up num_to_wake (or all) threads in a vector.
 void AddressArbiter::WakeThreads(const std::vector<std::shared_ptr<Thread>>& waiting_threads,
                                  s32 num_to_wake) {
-    auto& time_manager = system.Kernel().TimeManager();
     // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
     // them all.
     std::size_t last = waiting_threads.size();

src/core/hle/kernel/handle_table.cpp

@@ -8,7 +8,9 @@
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 
 namespace Kernel {
@@ -22,7 +24,7 @@ constexpr u16 GetGeneration(Handle handle) {
 }
 } // Anonymous namespace
 
-HandleTable::HandleTable() {
+HandleTable::HandleTable(KernelCore& kernel) : kernel{kernel} {
     Clear();
 }
 
@@ -103,9 +105,9 @@ bool HandleTable::IsValid(Handle handle) const {
 
 std::shared_ptr<Object> HandleTable::GetGeneric(Handle handle) const {
     if (handle == CurrentThread) {
-        return SharedFrom(GetCurrentThread());
+        return SharedFrom(kernel.CurrentScheduler().GetCurrentThread());
     } else if (handle == CurrentProcess) {
-        return SharedFrom(Core::System::GetInstance().CurrentProcess());
+        return SharedFrom(kernel.CurrentProcess());
     }
 
     if (!IsValid(handle)) {

src/core/hle/kernel/handle_table.h

@@ -14,6 +14,8 @@
 
 namespace Kernel {
 
+class KernelCore;
+
 enum KernelHandle : Handle {
     InvalidHandle = 0,
     CurrentThread = 0xFFFF8000,
@@ -48,7 +50,7 @@ public:
     /// This is the maximum limit of handles allowed per process in Horizon
     static constexpr std::size_t MAX_COUNT = 1024;
 
-    HandleTable();
+    explicit HandleTable(KernelCore& kernel);
     ~HandleTable();
 
     /**
@@ -134,6 +136,9 @@ private:
 
     /// Head of the free slots linked list.
     u16 next_free_slot = 0;
+
+    /// Underlying kernel instance that this handle table operates under.
+    KernelCore& kernel;
 };
 
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -50,7 +50,8 @@ namespace Kernel {
 
 struct KernelCore::Impl {
     explicit Impl(Core::System& system, KernelCore& kernel)
-        : global_scheduler{kernel}, synchronization{system}, time_manager{system}, system{system} {}
+        : global_scheduler{kernel}, synchronization{system}, time_manager{system},
+          global_handle_table{kernel}, system{system} {}
 
     void SetMulticore(bool is_multicore) {
         this->is_multicore = is_multicore;
@@ -144,29 +145,32 @@ struct KernelCore::Impl {
 
     void InitializePreemption(KernelCore& kernel) {
         preemption_event = Core::Timing::CreateEvent(
-            "PreemptionCallback", [this, &kernel](u64 userdata, s64 cycles_late) {
+            "PreemptionCallback", [this, &kernel](u64, std::chrono::nanoseconds) {
                 {
                     SchedulerLock lock(kernel);
                     global_scheduler.PreemptThreads();
                 }
-                s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
+                const auto time_interval = std::chrono::nanoseconds{
+                    Core::Timing::msToCycles(std::chrono::milliseconds(10))};
                 system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
             });
 
-        s64 time_interval = Core::Timing::msToCycles(std::chrono::milliseconds(10));
+        const auto time_interval =
+            std::chrono::nanoseconds{Core::Timing::msToCycles(std::chrono::milliseconds(10))};
         system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
     }
 
     void InitializeSuspendThreads() {
         for (std::size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) {
             std::string name = "Suspend Thread Id:" + std::to_string(i);
-            std::function<void(void*)> init_func =
-                system.GetCpuManager().GetSuspendThreadStartFunc();
+            std::function<void(void*)> init_func = Core::CpuManager::GetSuspendThreadStartFunc();
             void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
-            ThreadType type =
+            const auto type =
                 static_cast<ThreadType>(THREADTYPE_KERNEL | THREADTYPE_HLE | THREADTYPE_SUSPEND);
-            auto thread_res = Thread::Create(system, type, name, 0, 0, 0, static_cast<u32>(i), 0,
-                                             nullptr, std::move(init_func), init_func_parameter);
+            auto thread_res =
+                Thread::Create(system, type, std::move(name), 0, 0, 0, static_cast<u32>(i), 0,
+                               nullptr, std::move(init_func), init_func_parameter);
+
             suspend_threads[i] = std::move(thread_res).Unwrap();
         }
     }
@@ -307,7 +311,7 @@ struct KernelCore::Impl {
 
     // This is the kernel's handle table or supervisor handle table which
     // stores all the objects in place.
-    Kernel::HandleTable global_handle_table;
+    HandleTable global_handle_table;
 
     /// Map of named ports managed by the kernel, which can be retrieved using
     /// the ConnectToPort SVC.

src/core/hle/kernel/kernel.h

@@ -9,6 +9,7 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
+#include "core/arm/cpu_interrupt_handler.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/memory/memory_types.h"
 #include "core/hle/kernel/object.h"

src/core/hle/kernel/memory/address_space_info.cpp

@@ -29,40 +29,39 @@ enum : u64 {
 
 // clang-format off
 constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{
-   { 32 /*bit_width*/, Size_2_MB   /*addr*/, Size_1_GB   - Size_2_MB   /*size*/, AddressSpaceInfo::Type::Is32Bit,    },
-   { 32 /*bit_width*/, Size_1_GB   /*addr*/, Size_4_GB   - Size_1_GB   /*size*/, AddressSpaceInfo::Type::Small64Bit, },
-   { 32 /*bit_width*/, Invalid     /*addr*/, Size_1_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 32 /*bit_width*/, Invalid     /*addr*/, Size_1_GB                 /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 36 /*bit_width*/, Size_128_MB /*addr*/, Size_2_GB   - Size_128_MB /*size*/, AddressSpaceInfo::Type::Is32Bit,    },
-   { 36 /*bit_width*/, Size_2_GB   /*addr*/, Size_64_GB  - Size_2_GB   /*size*/, AddressSpaceInfo::Type::Small64Bit, },
-   { 36 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 36 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 39 /*bit_width*/, Size_128_MB /*addr*/, Size_512_GB - Size_128_MB /*size*/, AddressSpaceInfo::Type::Large64Bit, },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_64_GB                /*size*/, AddressSpaceInfo::Type::Is32Bit     },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_64_GB                /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_2_GB                 /*size*/, AddressSpaceInfo::Type::Stack,      },
+   { .bit_width = 32, .address = Size_2_MB  , .size = Size_1_GB   - Size_2_MB  , .type = AddressSpaceInfo::Type::Is32Bit,    },
+   { .bit_width = 32, .address = Size_1_GB  , .size = Size_4_GB   - Size_1_GB  , .type = AddressSpaceInfo::Type::Small64Bit, },
+   { .bit_width = 32, .address = Invalid    , .size = Size_1_GB                , .type = AddressSpaceInfo::Type::Heap,       },
+   { .bit_width = 32, .address = Invalid    , .size = Size_1_GB                , .type = AddressSpaceInfo::Type::Alias,      },
+   { .bit_width = 36, .address = Size_128_MB, .size = Size_2_GB   - Size_128_MB, .type = AddressSpaceInfo::Type::Is32Bit,    },
+   { .bit_width = 36, .address = Size_2_GB  , .size = Size_64_GB  - Size_2_GB  , .type = AddressSpaceInfo::Type::Small64Bit, },
+   { .bit_width = 36, .address = Invalid    , .size = Size_6_GB                , .type = AddressSpaceInfo::Type::Heap,       },
+   { .bit_width = 36, .address = Invalid    , .size = Size_6_GB                , .type = AddressSpaceInfo::Type::Alias,      },
+   { .bit_width = 39, .address = Size_128_MB, .size = Size_512_GB - Size_128_MB, .type = AddressSpaceInfo::Type::Large64Bit, },
+   { .bit_width = 39, .address = Invalid    , .size = Size_64_GB               , .type = AddressSpaceInfo::Type::Is32Bit     },
+   { .bit_width = 39, .address = Invalid    , .size = Size_6_GB                , .type = AddressSpaceInfo::Type::Heap,       },
+   { .bit_width = 39, .address = Invalid    , .size = Size_64_GB               , .type = AddressSpaceInfo::Type::Alias,      },
+   { .bit_width = 39, .address = Invalid    , .size = Size_2_GB                , .type = AddressSpaceInfo::Type::Stack,      },
 }};
 // clang-format on
 
 constexpr bool IsAllowedIndexForAddress(std::size_t index) {
-    return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid;
+    return index < AddressSpaceInfos.size() && AddressSpaceInfos[index].address != Invalid;
 }
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices32Bit{
-        0, 1, 0, 2, 0, 3,
-    };
+using IndexArray = std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>;
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices36Bit{
-        4, 5, 4, 6, 4, 7,
-    };
+constexpr IndexArray AddressSpaceIndices32Bit{
+    0, 1, 0, 2, 0, 3,
+};
 
-constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
-    AddressSpaceIndices39Bit{
-        9, 8, 8, 10, 12, 11,
-    };
+constexpr IndexArray AddressSpaceIndices36Bit{
+    4, 5, 4, 6, 4, 7,
+};
+
+constexpr IndexArray AddressSpaceIndices39Bit{
+    9, 8, 8, 10, 12, 11,
+};
 
 constexpr bool IsAllowed32BitType(AddressSpaceInfo::Type type) {
     return type < AddressSpaceInfo::Type::Count && type != AddressSpaceInfo::Type::Large64Bit &&
@@ -80,37 +79,37 @@ constexpr bool IsAllowed39BitType(AddressSpaceInfo::Type type) {
 
 } // namespace
 
-u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, AddressSpaceInfo::Type type) {
+u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, Type type) {
     const std::size_t index{static_cast<std::size_t>(type)};
     switch (width) {
     case 32:
         ASSERT(IsAllowed32BitType(type));
         ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices32Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetAddress();
+        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].address;
     case 36:
         ASSERT(IsAllowed36BitType(type));
         ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices36Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetAddress();
+        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].address;
     case 39:
         ASSERT(IsAllowed39BitType(type));
         ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices39Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetAddress();
+        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].address;
     }
     UNREACHABLE();
 }
 
-std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, AddressSpaceInfo::Type type) {
+std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type) {
     const std::size_t index{static_cast<std::size_t>(type)};
     switch (width) {
     case 32:
         ASSERT(IsAllowed32BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetSize();
+        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].size;
     case 36:
         ASSERT(IsAllowed36BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetSize();
+        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].size;
     case 39:
         ASSERT(IsAllowed39BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetSize();
+        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].size;
     }
     UNREACHABLE();
 }

src/core/hle/kernel/memory/address_space_info.h

@@ -11,8 +11,7 @@
 
 namespace Kernel::Memory {
 
-class AddressSpaceInfo final : NonCopyable {
-public:
+struct AddressSpaceInfo final {
     enum class Type : u32 {
         Is32Bit = 0,
         Small64Bit = 1,
@@ -23,31 +22,13 @@ public:
         Count,
     };
 
-private:
-    std::size_t bit_width{};
-    std::size_t addr{};
-    std::size_t size{};
-    Type type{};
-
-public:
     static u64 GetAddressSpaceStart(std::size_t width, Type type);
     static std::size_t GetAddressSpaceSize(std::size_t width, Type type);
 
-    constexpr AddressSpaceInfo(std::size_t bit_width, std::size_t addr, std::size_t size, Type type)
-        : bit_width{bit_width}, addr{addr}, size{size}, type{type} {}
-
-    constexpr std::size_t GetWidth() const {
-        return bit_width;
-    }
-    constexpr std::size_t GetAddress() const {
-        return addr;
-    }
-    constexpr std::size_t GetSize() const {
-        return size;
-    }
-    constexpr Type GetType() const {
-        return type;
-    }
+    const std::size_t bit_width{};
+    const std::size_t address{};
+    const std::size_t size{};
+    const Type type{};
 };
 
 } // namespace Kernel::Memory

src/core/hle/kernel/memory/memory_layout.h

@@ -66,8 +66,6 @@ private:
     const MemoryRegion application;
     const MemoryRegion applet;
     const MemoryRegion system;
-
-    const PAddr start_address{};
 };
 
 } // namespace Kernel::Memory

src/core/hle/kernel/process.cpp

@@ -123,7 +123,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,
                                                               : kernel.CreateNewUserProcessID();
     process->capabilities.InitializeForMetadatalessProcess();
 
-    std::mt19937 rng(Settings::values.rng_seed.value_or(0));
+    std::mt19937 rng(Settings::values.rng_seed.GetValue().value_or(0));
     std::uniform_int_distribution<u64> distribution;
     std::generate(process->random_entropy.begin(), process->random_entropy.end(),
                   [&] { return distribution(rng); });
@@ -408,7 +408,7 @@ void Process::LoadModule(CodeSet code_set, VAddr base_addr) {
 Process::Process(Core::System& system)
     : SynchronizationObject{system.Kernel()}, page_table{std::make_unique<Memory::PageTable>(
                                                   system)},
-      address_arbiter{system}, mutex{system}, system{system} {}
+      handle_table{system.Kernel()}, address_arbiter{system}, mutex{system}, system{system} {}
 
 Process::~Process() = default;
 

src/core/hle/kernel/process.h

@@ -382,12 +382,6 @@ private:
     /// List of threads waiting for a condition variable
     std::unordered_map<VAddr, std::list<std::shared_ptr<Thread>>> cond_var_threads;
 
-    /// System context
-    Core::System& system;
-
-    /// Name of this process
-    std::string name;
-
     /// Address of the top of the main thread's stack
     VAddr main_thread_stack_top{};
 
@@ -399,6 +393,12 @@ private:
 
     /// Process total image size
     std::size_t image_size{};
+
+    /// Name of this process
+    std::string name;
+
+    /// System context
+    Core::System& system;
 };
 
 } // namespace Kernel

src/core/hle/kernel/scheduler.cpp

@@ -6,6 +6,7 @@
 // licensed under GPLv2 or later under exception provided by the author.
 
 #include <algorithm>
+#include <mutex>
 #include <set>
 #include <unordered_set>
 #include <utility>
@@ -31,22 +32,20 @@ GlobalScheduler::GlobalScheduler(KernelCore& kernel) : kernel{kernel} {}
 GlobalScheduler::~GlobalScheduler() = default;
 
 void GlobalScheduler::AddThread(std::shared_ptr<Thread> thread) {
-    global_list_guard.lock();
+    std::scoped_lock lock{global_list_guard};
     thread_list.push_back(std::move(thread));
-    global_list_guard.unlock();
 }
 
 void GlobalScheduler::RemoveThread(std::shared_ptr<Thread> thread) {
-    global_list_guard.lock();
+    std::scoped_lock lock{global_list_guard};
     thread_list.erase(std::remove(thread_list.begin(), thread_list.end(), thread),
                       thread_list.end());
-    global_list_guard.unlock();
 }
 
 u32 GlobalScheduler::SelectThreads() {
     ASSERT(is_locked);
     const auto update_thread = [](Thread* thread, Scheduler& sched) {
-        sched.guard.lock();
+        std::scoped_lock lock{sched.guard};
         if (thread != sched.selected_thread_set.get()) {
             if (thread == nullptr) {
                 ++sched.idle_selection_count;
@@ -57,7 +56,6 @@ u32 GlobalScheduler::SelectThreads() {
             sched.is_context_switch_pending || (sched.selected_thread_set != sched.current_thread);
         sched.is_context_switch_pending = reschedule_pending;
         std::atomic_thread_fence(std::memory_order_seq_cst);
-        sched.guard.unlock();
         return reschedule_pending;
     };
     if (!is_reselection_pending.load()) {
@@ -757,11 +755,12 @@ void Scheduler::OnSwitch(void* this_scheduler) {
 
 void Scheduler::SwitchToCurrent() {
     while (true) {
-        guard.lock();
-        selected_thread = selected_thread_set;
-        current_thread = selected_thread;
-        is_context_switch_pending = false;
-        guard.unlock();
+        {
+            std::scoped_lock lock{guard};
+            selected_thread = selected_thread_set;
+            current_thread = selected_thread;
+            is_context_switch_pending = false;
+        }
         while (!is_context_switch_pending) {
             if (current_thread != nullptr && !current_thread->IsHLEThread()) {
                 current_thread->context_guard.lock();
@@ -803,7 +802,7 @@ void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
 
 void Scheduler::Initialize() {
     std::string name = "Idle Thread Id:" + std::to_string(core_id);
-    std::function<void(void*)> init_func = system.GetCpuManager().GetIdleThreadStartFunc();
+    std::function<void(void*)> init_func = Core::CpuManager::GetIdleThreadStartFunc();
     void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
     ThreadType type = static_cast<ThreadType>(THREADTYPE_KERNEL | THREADTYPE_HLE | THREADTYPE_IDLE);
     auto thread_res = Thread::Create(system, type, name, 0, 64, 0, static_cast<u32>(core_id), 0,

src/core/hle/kernel/server_session.cpp

@@ -34,7 +34,7 @@ ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kern
     std::shared_ptr<ServerSession> session{std::make_shared<ServerSession>(kernel)};
 
     session->request_event = Core::Timing::CreateEvent(
-        name, [session](u64 userdata, s64 cycles_late) { session->CompleteSyncRequest(); });
+        name, [session](u64, std::chrono::nanoseconds) { session->CompleteSyncRequest(); });
     session->name = std::move(name);
     session->parent = std::move(parent);
 
@@ -184,8 +184,8 @@ ResultCode ServerSession::CompleteSyncRequest() {
 
 ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread,
                                             Core::Memory::Memory& memory) {
-    ResultCode result = QueueSyncRequest(std::move(thread), memory);
-    const u64 delay = kernel.IsMulticore() ? 0U : 20000U;
+    const ResultCode result = QueueSyncRequest(std::move(thread), memory);
+    const auto delay = std::chrono::nanoseconds{kernel.IsMulticore() ? 0 : 20000};
     Core::System::GetInstance().CoreTiming().ScheduleEvent(delay, request_event, {});
     return result;
 }

src/core/hle/kernel/svc.cpp

@@ -458,9 +458,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
         return ERR_OUT_OF_RANGE;
     }
 
-    auto* const thread = system.CurrentScheduler().GetCurrentThread();
     auto& kernel = system.Kernel();
-    using ObjectPtr = Thread::ThreadSynchronizationObjects::value_type;
     Thread::ThreadSynchronizationObjects objects(handle_count);
     const auto& handle_table = kernel.CurrentProcess()->GetHandleTable();
 
@@ -1750,9 +1748,9 @@ static void SignalProcessWideKey(Core::System& system, VAddr condition_variable_
     // Only process up to 'target' threads, unless 'target' is less equal 0, in which case process
     // them all.
     std::size_t last = waiting_threads.size();
-    if (target > 0)
+    if (target > 0) {
         last = std::min(waiting_threads.size(), static_cast<std::size_t>(target));
-    auto& time_manager = kernel.TimeManager();
+    }
     for (std::size_t index = 0; index < last; ++index) {
         auto& thread = waiting_threads[index];
 
@@ -1763,7 +1761,6 @@ static void SignalProcessWideKey(Core::System& system, VAddr condition_variable_
 
         const std::size_t current_core = system.CurrentCoreIndex();
         auto& monitor = system.Monitor();
-        auto& memory = system.Memory();
 
         // Atomically read the value of the mutex.
         u32 mutex_val = 0;

src/core/hle/kernel/synchronization.cpp

@@ -19,7 +19,6 @@ Synchronization::Synchronization(Core::System& system) : system{system} {}
 void Synchronization::SignalObject(SynchronizationObject& obj) const {
     auto& kernel = system.Kernel();
     SchedulerLock lock(kernel);
-    auto& time_manager = kernel.TimeManager();
     if (obj.IsSignaled()) {
         for (auto thread : obj.GetWaitingThreads()) {
             if (thread->GetSchedulingStatus() == ThreadSchedStatus::Paused) {

src/core/hle/kernel/thread.cpp

@@ -13,16 +13,8 @@
 #include "common/logging/log.h"
 #include "common/thread_queue_list.h"
 #include "core/arm/arm_interface.h"
-#ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#endif
-#include "core/arm/cpu_interrupt_handler.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"
 #include "core/cpu_manager.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/errors.h"
@@ -36,6 +28,11 @@
 #include "core/hle/result.h"
 #include "core/memory.h"
 
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic_32.h"
+#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#endif
+
 namespace Kernel {
 
 bool Thread::ShouldWait(const Thread* thread) const {
@@ -158,7 +155,7 @@ ResultVal<std::shared_ptr<Thread>> Thread::Create(Core::System& system, ThreadTy
                                                   std::string name, VAddr entry_point, u32 priority,
                                                   u64 arg, s32 processor_id, VAddr stack_top,
                                                   Process* owner_process) {
-    std::function<void(void*)> init_func = system.GetCpuManager().GetGuestThreadStartFunc();
+    std::function<void(void*)> init_func = Core::CpuManager::GetGuestThreadStartFunc();
     void* init_func_parameter = system.GetCpuManager().GetStartFuncParamater();
     return Create(system, type_flags, name, entry_point, priority, arg, processor_id, stack_top,
                   owner_process, std::move(init_func), init_func_parameter);
@@ -540,13 +537,4 @@ ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
     return RESULT_SUCCESS;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Gets the current thread
- */
-Thread* GetCurrentThread() {
-    return Core::System::GetInstance().CurrentScheduler().GetCurrentThread();
-}
-
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -583,8 +583,6 @@ private:
 
     void SetCurrentPriority(u32 new_priority);
 
-    void AdjustSchedulingOnAffinity(u64 old_affinity_mask, s32 old_core);
-
     Common::SpinLock context_guard{};
     ThreadContext32 context_32{};
     ThreadContext64 context_64{};
@@ -680,9 +678,4 @@ private:
     std::string name;
 };
 
-/**
- * Gets the current thread
- */
-Thread* GetCurrentThread();
-
 } // namespace Kernel

src/core/hle/kernel/time_manager.cpp

@@ -16,7 +16,7 @@ namespace Kernel {
 
 TimeManager::TimeManager(Core::System& system_) : system{system_} {
     time_manager_event_type = Core::Timing::CreateEvent(
-        "Kernel::TimeManagerCallback", [this](u64 thread_handle, [[maybe_unused]] s64 cycles_late) {
+        "Kernel::TimeManagerCallback", [this](u64 thread_handle, std::chrono::nanoseconds) {
             SchedulerLock lock(system.Kernel());
             Handle proper_handle = static_cast<Handle>(thread_handle);
             if (cancelled_events[proper_handle]) {
@@ -34,7 +34,8 @@ void TimeManager::ScheduleTimeEvent(Handle& event_handle, Thread* timetask, s64
         ASSERT(timetask);
         ASSERT(timetask->GetStatus() != ThreadStatus::Ready);
         ASSERT(timetask->GetStatus() != ThreadStatus::WaitMutex);
-        system.CoreTiming().ScheduleEvent(nanoseconds, time_manager_event_type, event_handle);
+        system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds{nanoseconds},
+                                          time_manager_event_type, event_handle);
     } else {
         event_handle = InvalidHandle;
     }

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

@@ -272,7 +272,7 @@ ISelfController::ISelfController(Core::System& system,
         {41, nullptr, "IsSystemBufferSharingEnabled"},
         {42, nullptr, "GetSystemSharedLayerHandle"},
         {43, nullptr, "GetSystemSharedBufferHandle"},
-        {44, nullptr, "CreateManagedDisplaySeparableLayer"},
+        {44, &ISelfController::CreateManagedDisplaySeparableLayer, "CreateManagedDisplaySeparableLayer"},
         {45, nullptr, "SetManagedDisplayLayerSeparationMode"},
         {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
         {51, nullptr, "ApproveToDisplay"},
@@ -462,6 +462,24 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
     rb.Push(*layer_id);
 }
 
+void ISelfController::CreateManagedDisplaySeparableLayer(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    // TODO(Subv): Find out how AM determines the display to use, for now just
+    // create the layer in the Default display.
+    // This calls nn::vi::CreateRecordingLayer() which creates another layer.
+    // Currently we do not support more than 1 layer per display, output 1 layer id for now.
+    // Outputting 1 layer id instead of the expected 2 has not been observed to cause any adverse
+    // side effects.
+    // TODO: Support multiple layers
+    const auto display_id = nvflinger->OpenDisplay("Default");
+    const auto layer_id = nvflinger->CreateLayer(*display_id);
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(*layer_id);
+}
+
 void ISelfController::SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
@@ -731,14 +749,14 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
 
     if (Settings::values.use_docked_mode) {
         rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
         rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
     } else {
         rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
         rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
     }
 }
 
@@ -1389,7 +1407,19 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     u32 supported_languages = 0;
     FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
 
-    const auto res = pm.GetControlMetadata();
+    const auto res = [this] {
+        const auto title_id = system.CurrentProcess()->GetTitleID();
+
+        FileSys::PatchManager pm{title_id};
+        auto res = pm.GetControlMetadata();
+        if (res.first != nullptr) {
+            return res;
+        }
+
+        FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(title_id)};
+        return pm_update.GetControlMetadata();
+    }();
+
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();
     }

src/core/hle/service/am/am.h

@@ -140,6 +140,7 @@ private:
     void SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx);
     void SetAlbumImageOrientation(Kernel::HLERequestContext& ctx);
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
+    void CreateManagedDisplaySeparableLayer(Kernel::HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
     void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);

src/core/hle/service/am/applets/software_keyboard.cpp

@@ -13,11 +13,23 @@
 
 namespace Service::AM::Applets {
 
+namespace {
+enum class Request : u32 {
+    Finalize = 0x4,
+    SetUserWordInfo = 0x6,
+    SetCustomizeDic = 0x7,
+    Calc = 0xa,
+    SetCustomizedDictionaries = 0xb,
+    UnsetCustomizedDictionaries = 0xc,
+    UnknownD = 0xd,
+    UnknownE = 0xe,
+};
+constexpr std::size_t SWKBD_INLINE_INIT_SIZE = 0x8;
 constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
 constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
 constexpr std::size_t DEFAULT_MAX_LENGTH = 500;
 constexpr bool INTERACTIVE_STATUS_OK = false;
-
+} // Anonymous namespace
 static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
     KeyboardConfig config, std::u16string initial_text) {
     Core::Frontend::SoftwareKeyboardParameters params{};
@@ -47,6 +59,7 @@ SoftwareKeyboard::~SoftwareKeyboard() = default;
 
 void SoftwareKeyboard::Initialize() {
     complete = false;
+    is_inline = false;
     initial_text.clear();
     final_data.clear();
 
@@ -56,6 +69,11 @@ void SoftwareKeyboard::Initialize() {
     ASSERT(keyboard_config_storage != nullptr);
     const auto& keyboard_config = keyboard_config_storage->GetData();
 
+    if (keyboard_config.size() == SWKBD_INLINE_INIT_SIZE) {
+        is_inline = true;
+        return;
+    }
+
     ASSERT(keyboard_config.size() >= sizeof(KeyboardConfig));
     std::memcpy(&config, keyboard_config.data(), sizeof(KeyboardConfig));
 
@@ -87,16 +105,32 @@ void SoftwareKeyboard::ExecuteInteractive() {
     const auto storage = broker.PopInteractiveDataToApplet();
     ASSERT(storage != nullptr);
     const auto data = storage->GetData();
-    const auto status = static_cast<bool>(data[0]);
-
-    if (status == INTERACTIVE_STATUS_OK) {
-        complete = true;
+    if (!is_inline) {
+        const auto status = static_cast<bool>(data[0]);
+        if (status == INTERACTIVE_STATUS_OK) {
+            complete = true;
+        } else {
+            std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
+            std::memcpy(string.data(), data.data() + 4, string.size() * 2);
+            frontend.SendTextCheckDialog(
+                Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
+                [this] { broker.SignalStateChanged(); });
+        }
     } else {
-        std::array<char16_t, SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE / 2 - 2> string;
-        std::memcpy(string.data(), data.data() + 4, string.size() * 2);
-        frontend.SendTextCheckDialog(
-            Common::UTF16StringFromFixedZeroTerminatedBuffer(string.data(), string.size()),
-            [this] { broker.SignalStateChanged(); });
+        Request request{};
+        std::memcpy(&request, data.data(), sizeof(Request));
+
+        switch (request) {
+        case Request::Calc: {
+            broker.PushNormalDataFromApplet(
+                std::make_shared<IStorage>(std::move(std::vector<u8>{1})));
+            broker.SignalStateChanged();
+            break;
+        }
+        default:
+            UNIMPLEMENTED_MSG("Request {:X} is not implemented", request);
+            break;
+        }
     }
 }
 
@@ -108,9 +142,10 @@ void SoftwareKeyboard::Execute() {
     }
 
     const auto parameters = ConvertToFrontendParameters(config, initial_text);
-
-    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(std::move(text)); },
-                         parameters);
+    if (!is_inline) {
+        frontend.RequestText(
+            [this](std::optional<std::u16string> text) { WriteText(std::move(text)); }, parameters);
+    }
 }
 
 void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {

src/core/hle/service/am/applets/software_keyboard.h

@@ -78,6 +78,7 @@ private:
     KeyboardConfig config;
     std::u16string initial_text;
     bool complete = false;
+    bool is_inline = false;
     std::vector<u8> final_data;
 };
 

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

@@ -55,6 +55,10 @@ std::string VfsDirectoryServiceWrapper::GetName() const {
 ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size) const {
     std::string path(FileUtil::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
+    // dir can be nullptr if path contains subdirectories, create those prior to creating the file.
+    if (dir == nullptr) {
+        dir = backing->CreateSubdirectory(FileUtil::GetParentPath(path));
+    }
     auto file = dir->CreateFile(FileUtil::GetFilename(path));
     if (file == nullptr) {
         // TODO(DarkLordZach): Find a better error code for this

src/core/hle/service/hid/hid.cpp

@@ -39,9 +39,10 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // TODO(ogniK): Find actual polling rate of hid
-constexpr s64 pad_update_ticks = static_cast<s64>(1000000000 / 66);
-[[maybe_unused]] constexpr s64 accelerometer_update_ticks = static_cast<s64>(1000000000 / 100);
-[[maybe_unused]] constexpr s64 gyroscope_update_ticks = static_cast<s64>(1000000000 / 100);
+constexpr auto pad_update_ns = std::chrono::nanoseconds{1000000000 / 66};
+[[maybe_unused]] constexpr auto accelerometer_update_ns =
+    std::chrono::nanoseconds{1000000000 / 100};
+[[maybe_unused]] constexpr auto gyroscope_update_ticks = std::chrono::nanoseconds{1000000000 / 100};
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
 IAppletResource::IAppletResource(Core::System& system)
@@ -75,14 +76,14 @@ IAppletResource::IAppletResource(Core::System& system)
     GetController<Controller_Stubbed>(HidController::Unknown3).SetCommonHeaderOffset(0x5000);
 
     // Register update callbacks
-    pad_update_event =
-        Core::Timing::CreateEvent("HID::UpdatePadCallback", [this](u64 userdata, s64 ns_late) {
+    pad_update_event = Core::Timing::CreateEvent(
+        "HID::UpdatePadCallback", [this](u64 userdata, std::chrono::nanoseconds ns_late) {
             UpdateControllers(userdata, ns_late);
         });
 
     // TODO(shinyquagsire23): Other update callbacks? (accel, gyro?)
 
-    system.CoreTiming().ScheduleEvent(pad_update_ticks, pad_update_event);
+    system.CoreTiming().ScheduleEvent(pad_update_ns, pad_update_event);
 
     ReloadInputDevices();
 }
@@ -107,7 +108,7 @@ void IAppletResource::GetSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
     rb.PushCopyObjects(shared_mem);
 }
 
-void IAppletResource::UpdateControllers(u64 userdata, s64 ns_late) {
+void IAppletResource::UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
 
     const bool should_reload = Settings::values.is_device_reload_pending.exchange(false);
@@ -118,7 +119,7 @@ void IAppletResource::UpdateControllers(u64 userdata, s64 ns_late) {
         controller->OnUpdate(core_timing, shared_mem->GetPointer(), SHARED_MEMORY_SIZE);
     }
 
-    core_timing.ScheduleEvent(pad_update_ticks - ns_late, pad_update_event);
+    core_timing.ScheduleEvent(pad_update_ns - ns_late, pad_update_event);
 }
 
 class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {

src/core/hle/service/hid/hid.h

@@ -4,10 +4,9 @@
 
 #pragma once
 
-#include "core/hle/service/hid/controllers/controller_base.h"
-#include "core/hle/service/service.h"
+#include <chrono>
 
-#include "controllers/controller_base.h"
+#include "core/hle/service/hid/controllers/controller_base.h"
 #include "core/hle/service/service.h"
 
 namespace Core::Timing {
@@ -65,7 +64,7 @@ private:
     }
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
-    void UpdateControllers(u64 userdata, s64 cycles_late);
+    void UpdateControllers(u64 userdata, std::chrono::nanoseconds ns_late);
 
     std::shared_ptr<Kernel::SharedMemory> shared_mem;
 

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

@@ -0,0 +1,484 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include <random>
+
+#include "common/assert.h"
+#include "common/file_util.h"
+#include "common/logging/log.h"
+#include "common/string_util.h"
+
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/hle/service/mii/manager.h"
+#include "core/hle/service/mii/raw_data.h"
+#include "core/hle/service/mii/types.h"
+
+namespace Service::Mii {
+
+namespace {
+
+constexpr ResultCode ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};
+
+constexpr std::size_t DefaultMiiCount{sizeof(RawData::DefaultMii) / sizeof(DefaultMii)};
+
+constexpr MiiStoreData::Name DefaultMiiName{u'y', u'u', u'z', u'u'};
+constexpr std::array<u8, 8> HairColorLookup{8, 1, 2, 3, 4, 5, 6, 7};
+constexpr std::array<u8, 6> EyeColorLookup{8, 9, 10, 11, 12, 13};
+constexpr std::array<u8, 5> MouthColorLookup{19, 20, 21, 22, 23};
+constexpr std::array<u8, 7> GlassesColorLookup{8, 14, 15, 16, 17, 18, 0};
+constexpr std::array<u8, 62> EyeRotateLookup{
+    {0x03, 0x04, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
+     0x04, 0x04, 0x03, 0x03, 0x04, 0x03, 0x04, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04,
+     0x04, 0x03, 0x03, 0x03, 0x04, 0x04, 0x03, 0x03, 0x03, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03,
+     0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04}};
+constexpr std::array<u8, 24> EyebrowRotateLookup{{0x06, 0x06, 0x05, 0x07, 0x06, 0x07, 0x06, 0x07,
+                                                  0x04, 0x07, 0x06, 0x08, 0x05, 0x05, 0x06, 0x06,
+                                                  0x07, 0x07, 0x06, 0x06, 0x05, 0x06, 0x07, 0x05}};
+
+template <typename T, std::size_t SourceArraySize, std::size_t DestArraySize>
+std::array<T, DestArraySize> ResizeArray(const std::array<T, SourceArraySize>& in) {
+    std::array<T, DestArraySize> out{};
+    std::memcpy(out.data(), in.data(), sizeof(T) * std::min(SourceArraySize, DestArraySize));
+    return out;
+}
+
+MiiInfo ConvertStoreDataToInfo(const MiiStoreData& data) {
+    MiiStoreBitFields bf;
+    std::memcpy(&bf, data.data.data.data(), sizeof(MiiStoreBitFields));
+
+    return {
+        .uuid = data.data.uuid,
+        .name = ResizeArray<char16_t, 10, 11>(data.data.name),
+        .font_region = static_cast<u8>(bf.font_region.Value()),
+        .favorite_color = static_cast<u8>(bf.favorite_color.Value()),
+        .gender = static_cast<u8>(bf.gender.Value()),
+        .height = static_cast<u8>(bf.height.Value()),
+        .build = static_cast<u8>(bf.build.Value()),
+        .type = static_cast<u8>(bf.type.Value()),
+        .region_move = static_cast<u8>(bf.region_move.Value()),
+        .faceline_type = static_cast<u8>(bf.faceline_type.Value()),
+        .faceline_color = static_cast<u8>(bf.faceline_color.Value()),
+        .faceline_wrinkle = static_cast<u8>(bf.faceline_wrinkle.Value()),
+        .faceline_make = static_cast<u8>(bf.faceline_makeup.Value()),
+        .hair_type = static_cast<u8>(bf.hair_type.Value()),
+        .hair_color = static_cast<u8>(bf.hair_color.Value()),
+        .hair_flip = static_cast<u8>(bf.hair_flip.Value()),
+        .eye_type = static_cast<u8>(bf.eye_type.Value()),
+        .eye_color = static_cast<u8>(bf.eye_color.Value()),
+        .eye_scale = static_cast<u8>(bf.eye_scale.Value()),
+        .eye_aspect = static_cast<u8>(bf.eye_aspect.Value()),
+        .eye_rotate = static_cast<u8>(bf.eye_rotate.Value()),
+        .eye_x = static_cast<u8>(bf.eye_x.Value()),
+        .eye_y = static_cast<u8>(bf.eye_y.Value()),
+        .eyebrow_type = static_cast<u8>(bf.eyebrow_type.Value()),
+        .eyebrow_color = static_cast<u8>(bf.eyebrow_color.Value()),
+        .eyebrow_scale = static_cast<u8>(bf.eyebrow_scale.Value()),
+        .eyebrow_aspect = static_cast<u8>(bf.eyebrow_aspect.Value()),
+        .eyebrow_rotate = static_cast<u8>(bf.eyebrow_rotate.Value()),
+        .eyebrow_x = static_cast<u8>(bf.eyebrow_x.Value()),
+        .eyebrow_y = static_cast<u8>(bf.eyebrow_y.Value() + 3),
+        .nose_type = static_cast<u8>(bf.nose_type.Value()),
+        .nose_scale = static_cast<u8>(bf.nose_scale.Value()),
+        .nose_y = static_cast<u8>(bf.nose_y.Value()),
+        .mouth_type = static_cast<u8>(bf.mouth_type.Value()),
+        .mouth_color = static_cast<u8>(bf.mouth_color.Value()),
+        .mouth_scale = static_cast<u8>(bf.mouth_scale.Value()),
+        .mouth_aspect = static_cast<u8>(bf.mouth_aspect.Value()),
+        .mouth_y = static_cast<u8>(bf.mouth_y.Value()),
+        .beard_color = static_cast<u8>(bf.beard_color.Value()),
+        .beard_type = static_cast<u8>(bf.beard_type.Value()),
+        .mustache_type = static_cast<u8>(bf.mustache_type.Value()),
+        .mustache_scale = static_cast<u8>(bf.mustache_scale.Value()),
+        .mustache_y = static_cast<u8>(bf.mustache_y.Value()),
+        .glasses_type = static_cast<u8>(bf.glasses_type.Value()),
+        .glasses_color = static_cast<u8>(bf.glasses_color.Value()),
+        .glasses_scale = static_cast<u8>(bf.glasses_scale.Value()),
+        .glasses_y = static_cast<u8>(bf.glasses_y.Value()),
+        .mole_type = static_cast<u8>(bf.mole_type.Value()),
+        .mole_scale = static_cast<u8>(bf.mole_scale.Value()),
+        .mole_x = static_cast<u8>(bf.mole_x.Value()),
+        .mole_y = static_cast<u8>(bf.mole_y.Value()),
+    };
+}
+
+u16 GenerateCrc16(const void* data, std::size_t size) {
+    s32 crc{};
+    for (std::size_t i = 0; i < size; i++) {
+        crc ^= static_cast<const u8*>(data)[i] << 8;
+        for (std::size_t j = 0; j < 8; j++) {
+            crc <<= 1;
+            if ((crc & 0x10000) != 0) {
+                crc = (crc ^ 0x1021) & 0xFFFF;
+            }
+        }
+    }
+    return Common::swap16(static_cast<u16>(crc));
+}
+
+Common::UUID GenerateValidUUID() {
+    auto uuid{Common::UUID::Generate()};
+
+    // Bit 7 must be set, and bit 6 unset for the UUID to be valid
+    uuid.uuid[1] &= 0xFFFFFFFFFFFFFF3FULL;
+    uuid.uuid[1] |= 0x0000000000000080ULL;
+
+    return uuid;
+}
+
+template <typename T>
+T GetRandomValue(T min, T max) {
+    std::random_device device;
+    std::mt19937 gen(device());
+    std::uniform_int_distribution<u64> distribution(0, static_cast<u64>(max));
+    return static_cast<T>(distribution(gen));
+}
+
+template <typename T>
+T GetRandomValue(T max) {
+    return GetRandomValue<T>({}, max);
+}
+
+template <typename T>
+T GetArrayValue(const u8* data, std::size_t index) {
+    T result{};
+    std::memcpy(&result, &data[index * sizeof(T)], sizeof(T));
+    return result;
+}
+
+MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race, const Common::UUID& user_id) {
+    MiiStoreBitFields bf{};
+
+    if (gender == Gender::All) {
+        gender = GetRandomValue<Gender>(Gender::Maximum);
+    }
+
+    bf.gender.Assign(gender);
+    bf.favorite_color.Assign(GetRandomValue<u8>(11));
+    bf.region_move.Assign(0);
+    bf.font_region.Assign(FontRegion::Standard);
+    bf.type.Assign(0);
+    bf.height.Assign(64);
+    bf.build.Assign(64);
+
+    if (age == Age::All) {
+        const auto temp{GetRandomValue<int>(10)};
+        if (temp >= 8) {
+            age = Age::Old;
+        } else if (temp >= 4) {
+            age = Age::Normal;
+        } else {
+            age = Age::Young;
+        }
+    }
+
+    if (race == Race::All) {
+        const auto temp{GetRandomValue<int>(10)};
+        if (temp >= 8) {
+            race = Race::Black;
+        } else if (temp >= 4) {
+            race = Race::White;
+        } else {
+            race = Race::Asian;
+        }
+    }
+
+    u32 axis_y{};
+    if (gender == Gender::Female && age == Age::Young) {
+        axis_y = GetRandomValue<u32>(3);
+    }
+
+    const std::size_t index{3 * static_cast<std::size_t>(age) +
+                            9 * static_cast<std::size_t>(gender) + static_cast<std::size_t>(race)};
+
+    const auto faceline_type_info{
+        GetArrayValue<RandomMiiData4>(&RawData::RandomMiiFaceline[0], index)};
+    const auto faceline_color_info{GetArrayValue<RandomMiiData3>(
+        RawData::RandomMiiFacelineColor.data(),
+        3 * static_cast<std::size_t>(gender) + static_cast<std::size_t>(race))};
+    const auto faceline_wrinkle_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiFacelineWrinkle.data(), index)};
+    const auto faceline_makeup_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiFacelineMakeup.data(), index)};
+    const auto hair_type_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiHairType.data(), index)};
+    const auto hair_color_info{GetArrayValue<RandomMiiData3>(RawData::RandomMiiHairColor.data(),
+                                                             3 * static_cast<std::size_t>(race) +
+                                                                 static_cast<std::size_t>(age))};
+    const auto eye_type_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiEyeType.data(), index)};
+    const auto eye_color_info{GetArrayValue<RandomMiiData2>(RawData::RandomMiiEyeColor.data(),
+                                                            static_cast<std::size_t>(race))};
+    const auto eyebrow_type_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiEyebrowType.data(), index)};
+    const auto nose_type_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiNoseType.data(), index)};
+    const auto mouth_type_info{
+        GetArrayValue<RandomMiiData4>(RawData::RandomMiiMouthType.data(), index)};
+    const auto glasses_type_info{GetArrayValue<RandomMiiData2>(RawData::RandomMiiGlassType.data(),
+                                                               static_cast<std::size_t>(age))};
+
+    bf.faceline_type.Assign(
+        faceline_type_info.values[GetRandomValue<std::size_t>(faceline_type_info.values_count)]);
+    bf.faceline_color.Assign(
+        faceline_color_info.values[GetRandomValue<std::size_t>(faceline_color_info.values_count)]);
+    bf.faceline_wrinkle.Assign(
+        faceline_wrinkle_info
+            .values[GetRandomValue<std::size_t>(faceline_wrinkle_info.values_count)]);
+    bf.faceline_makeup.Assign(
+        faceline_makeup_info
+            .values[GetRandomValue<std::size_t>(faceline_makeup_info.values_count)]);
+
+    bf.hair_type.Assign(
+        hair_type_info.values[GetRandomValue<std::size_t>(hair_type_info.values_count)]);
+    bf.hair_color.Assign(
+        HairColorLookup[hair_color_info
+                            .values[GetRandomValue<std::size_t>(hair_color_info.values_count)]]);
+    bf.hair_flip.Assign(GetRandomValue<HairFlip>(HairFlip::Maximum));
+
+    bf.eye_type.Assign(
+        eye_type_info.values[GetRandomValue<std::size_t>(eye_type_info.values_count)]);
+
+    const auto eye_rotate_1{gender != Gender::Male ? 4 : 2};
+    const auto eye_rotate_2{gender != Gender::Male ? 3 : 4};
+    const auto eye_rotate_offset{32 - EyeRotateLookup[eye_rotate_1] + eye_rotate_2};
+    const auto eye_rotate{32 - EyeRotateLookup[bf.eye_type]};
+
+    bf.eye_color.Assign(
+        EyeColorLookup[eye_color_info
+                           .values[GetRandomValue<std::size_t>(eye_color_info.values_count)]]);
+    bf.eye_scale.Assign(4);
+    bf.eye_aspect.Assign(3);
+    bf.eye_rotate.Assign(eye_rotate_offset - eye_rotate);
+    bf.eye_x.Assign(2);
+    bf.eye_y.Assign(axis_y + 12);
+
+    bf.eyebrow_type.Assign(
+        eyebrow_type_info.values[GetRandomValue<std::size_t>(eyebrow_type_info.values_count)]);
+
+    const auto eyebrow_rotate_1{race == Race::Asian ? 6 : 0};
+    const auto eyebrow_y{race == Race::Asian ? 9 : 10};
+    const auto eyebrow_rotate_offset{32 - EyebrowRotateLookup[eyebrow_rotate_1] + 6};
+    const auto eyebrow_rotate{
+        32 - EyebrowRotateLookup[static_cast<std::size_t>(bf.eyebrow_type.Value())]};
+
+    bf.eyebrow_color.Assign(bf.hair_color);
+    bf.eyebrow_scale.Assign(4);
+    bf.eyebrow_aspect.Assign(3);
+    bf.eyebrow_rotate.Assign(eyebrow_rotate_offset - eyebrow_rotate);
+    bf.eyebrow_x.Assign(2);
+    bf.eyebrow_y.Assign(axis_y + eyebrow_y);
+
+    const auto nose_scale{gender == Gender::Female ? 3 : 4};
+
+    bf.nose_type.Assign(
+        nose_type_info.values[GetRandomValue<std::size_t>(nose_type_info.values_count)]);
+    bf.nose_scale.Assign(nose_scale);
+    bf.nose_y.Assign(axis_y + 9);
+
+    const auto mouth_color{gender == Gender::Female ? GetRandomValue<int>(4) : 0};
+
+    bf.mouth_type.Assign(
+        mouth_type_info.values[GetRandomValue<std::size_t>(mouth_type_info.values_count)]);
+    bf.mouth_color.Assign(MouthColorLookup[mouth_color]);
+    bf.mouth_scale.Assign(4);
+    bf.mouth_aspect.Assign(3);
+    bf.mouth_y.Assign(axis_y + 13);
+
+    bf.beard_color.Assign(bf.hair_color);
+    bf.mustache_scale.Assign(4);
+
+    if (gender == Gender::Male && age != Age::Young && GetRandomValue<int>(10) < 2) {
+        const auto mustache_and_beard_flag{
+            GetRandomValue<BeardAndMustacheFlag>(BeardAndMustacheFlag::All)};
+
+        auto beard_type{BeardType::None};
+        auto mustache_type{MustacheType::None};
+
+        if ((mustache_and_beard_flag & BeardAndMustacheFlag::Beard) ==
+            BeardAndMustacheFlag::Beard) {
+            beard_type = GetRandomValue<BeardType>(BeardType::Beard1, BeardType::Beard5);
+        }
+
+        if ((mustache_and_beard_flag & BeardAndMustacheFlag::Mustache) ==
+            BeardAndMustacheFlag::Mustache) {
+            mustache_type =
+                GetRandomValue<MustacheType>(MustacheType::Mustache1, MustacheType::Mustache5);
+        }
+
+        bf.mustache_type.Assign(mustache_type);
+        bf.beard_type.Assign(beard_type);
+        bf.mustache_y.Assign(10);
+    } else {
+        bf.mustache_type.Assign(MustacheType::None);
+        bf.beard_type.Assign(BeardType::None);
+        bf.mustache_y.Assign(axis_y + 10);
+    }
+
+    const auto glasses_type_start{GetRandomValue<std::size_t>(100)};
+    u8 glasses_type{};
+    while (glasses_type_start < glasses_type_info.values[glasses_type]) {
+        if (++glasses_type >= glasses_type_info.values_count) {
+            UNREACHABLE();
+            break;
+        }
+    }
+
+    bf.glasses_type.Assign(glasses_type);
+    bf.glasses_color.Assign(GlassesColorLookup[0]);
+    bf.glasses_scale.Assign(4);
+    bf.glasses_y.Assign(axis_y + 10);
+
+    bf.mole_type.Assign(0);
+    bf.mole_scale.Assign(4);
+    bf.mole_x.Assign(2);
+    bf.mole_y.Assign(20);
+
+    return {DefaultMiiName, bf, user_id};
+}
+
+MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::UUID& user_id) {
+    MiiStoreBitFields bf{};
+
+    bf.font_region.Assign(info.font_region);
+    bf.favorite_color.Assign(info.favorite_color);
+    bf.gender.Assign(info.gender);
+    bf.height.Assign(info.height);
+    bf.build.Assign(info.weight);
+    bf.type.Assign(info.type);
+    bf.region_move.Assign(info.region);
+    bf.faceline_type.Assign(info.face_type);
+    bf.faceline_color.Assign(info.face_color);
+    bf.faceline_wrinkle.Assign(info.face_wrinkle);
+    bf.faceline_makeup.Assign(info.face_makeup);
+    bf.hair_type.Assign(info.hair_type);
+    bf.hair_color.Assign(HairColorLookup[info.hair_color]);
+    bf.hair_flip.Assign(static_cast<HairFlip>(info.hair_flip));
+    bf.eye_type.Assign(info.eye_type);
+    bf.eye_color.Assign(EyeColorLookup[info.eye_color]);
+    bf.eye_scale.Assign(info.eye_scale);
+    bf.eye_aspect.Assign(info.eye_aspect);
+    bf.eye_rotate.Assign(info.eye_rotate);
+    bf.eye_x.Assign(info.eye_x);
+    bf.eye_y.Assign(info.eye_y);
+    bf.eyebrow_type.Assign(info.eyebrow_type);
+    bf.eyebrow_color.Assign(HairColorLookup[info.eyebrow_color]);
+    bf.eyebrow_scale.Assign(info.eyebrow_scale);
+    bf.eyebrow_aspect.Assign(info.eyebrow_aspect);
+    bf.eyebrow_rotate.Assign(info.eyebrow_rotate);
+    bf.eyebrow_x.Assign(info.eyebrow_x);
+    bf.eyebrow_y.Assign(info.eyebrow_y - 3);
+    bf.nose_type.Assign(info.nose_type);
+    bf.nose_scale.Assign(info.nose_scale);
+    bf.nose_y.Assign(info.nose_y);
+    bf.mouth_type.Assign(info.mouth_type);
+    bf.mouth_color.Assign(MouthColorLookup[info.mouth_color]);
+    bf.mouth_scale.Assign(info.mouth_scale);
+    bf.mouth_aspect.Assign(info.mouth_aspect);
+    bf.mouth_y.Assign(info.mouth_y);
+    bf.beard_color.Assign(HairColorLookup[info.beard_color]);
+    bf.beard_type.Assign(static_cast<BeardType>(info.beard_type));
+    bf.mustache_type.Assign(static_cast<MustacheType>(info.mustache_type));
+    bf.mustache_scale.Assign(info.mustache_scale);
+    bf.mustache_y.Assign(info.mustache_y);
+    bf.glasses_type.Assign(info.glasses_type);
+    bf.glasses_color.Assign(GlassesColorLookup[info.glasses_color]);
+    bf.glasses_scale.Assign(info.glasses_scale);
+    bf.glasses_y.Assign(info.glasses_y);
+    bf.mole_type.Assign(info.mole_type);
+    bf.mole_scale.Assign(info.mole_scale);
+    bf.mole_x.Assign(info.mole_x);
+    bf.mole_y.Assign(info.mole_y);
+
+    return {DefaultMiiName, bf, user_id};
+}
+
+} // namespace
+
+MiiStoreData::MiiStoreData() = default;
+
+MiiStoreData::MiiStoreData(const MiiStoreData::Name& name, const MiiStoreBitFields& bit_fields,
+                           const Common::UUID& user_id) {
+    data.name = name;
+    data.uuid = GenerateValidUUID();
+
+    std::memcpy(data.data.data(), &bit_fields, sizeof(MiiStoreBitFields));
+    data_crc = GenerateCrc16(data.data.data(), sizeof(data));
+    device_crc = GenerateCrc16(&user_id, sizeof(Common::UUID));
+}
+
+MiiManager::MiiManager() : user_id{Service::Account::ProfileManager().GetLastOpenedUser()} {}
+
+bool MiiManager::CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter) {
+    if ((source_flag & SourceFlag::Database) == SourceFlag::None) {
+        return false;
+    }
+
+    const bool result{current_update_counter != update_counter};
+
+    current_update_counter = update_counter;
+
+    return result;
+}
+
+bool MiiManager::IsFullDatabase() const {
+    // TODO(bunnei): We don't implement the Mii database, so it cannot be full
+    return false;
+}
+
+u32 MiiManager::GetCount(SourceFlag source_flag) const {
+    u32 count{};
+    if ((source_flag & SourceFlag::Database) != SourceFlag::None) {
+        // TODO(bunnei): We don't implement the Mii database, but when we do, update this
+        count += 0;
+    }
+    if ((source_flag & SourceFlag::Default) != SourceFlag::None) {
+        count += DefaultMiiCount;
+    }
+    return count;
+}
+
+ResultVal<MiiInfo> MiiManager::UpdateLatest([[maybe_unused]] const MiiInfo& info,
+                                            SourceFlag source_flag) {
+    if ((source_flag & SourceFlag::Database) == SourceFlag::None) {
+        return ERROR_CANNOT_FIND_ENTRY;
+    }
+
+    // TODO(bunnei): We don't implement the Mii database, so we can't have an entry
+    return ERROR_CANNOT_FIND_ENTRY;
+}
+
+MiiInfo MiiManager::BuildRandom(Age age, Gender gender, Race race) {
+    return ConvertStoreDataToInfo(BuildRandomStoreData(age, gender, race, user_id));
+}
+
+MiiInfo MiiManager::BuildDefault(std::size_t index) {
+    return ConvertStoreDataToInfo(BuildDefaultStoreData(
+        GetArrayValue<DefaultMii>(RawData::DefaultMii.data(), index), user_id));
+}
+
+ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_flag) {
+    std::vector<MiiInfoElement> result;
+
+    if ((source_flag & SourceFlag::Default) == SourceFlag::None) {
+        return MakeResult(std::move(result));
+    }
+
+    for (std::size_t index = 0; index < DefaultMiiCount; index++) {
+        result.emplace_back(BuildDefault(index), Source::Default);
+    }
+
+    return MakeResult(std::move(result));
+}
+
+ResultCode MiiManager::GetIndex([[maybe_unused]] const MiiInfo& info, u32& index) {
+    constexpr u32 INVALID_INDEX{0xFFFFFFFF};
+
+    index = INVALID_INDEX;
+
+    // TODO(bunnei): We don't implement the Mii database, so we can't have an index
+    return ERROR_CANNOT_FIND_ENTRY;
+}
+
+} // namespace Service::Mii

src/core/hle/service/mii/manager.h

@@ -0,0 +1,331 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
+#include "common/uuid.h"
+#include "core/hle/result.h"
+#include "core/hle/service/mii/types.h"
+
+namespace Service::Mii {
+
+enum class Source : u32 {
+    Database = 0,
+    Default = 1,
+    Account = 2,
+    Friend = 3,
+};
+
+enum class SourceFlag : u32 {
+    None = 0,
+    Database = 1 << 0,
+    Default = 1 << 1,
+};
+DECLARE_ENUM_FLAG_OPERATORS(SourceFlag);
+
+struct MiiInfo {
+    Common::UUID uuid{Common::INVALID_UUID};
+    std::array<char16_t, 11> name{};
+    u8 font_region{};
+    u8 favorite_color{};
+    u8 gender{};
+    u8 height{};
+    u8 build{};
+    u8 type{};
+    u8 region_move{};
+    u8 faceline_type{};
+    u8 faceline_color{};
+    u8 faceline_wrinkle{};
+    u8 faceline_make{};
+    u8 hair_type{};
+    u8 hair_color{};
+    u8 hair_flip{};
+    u8 eye_type{};
+    u8 eye_color{};
+    u8 eye_scale{};
+    u8 eye_aspect{};
+    u8 eye_rotate{};
+    u8 eye_x{};
+    u8 eye_y{};
+    u8 eyebrow_type{};
+    u8 eyebrow_color{};
+    u8 eyebrow_scale{};
+    u8 eyebrow_aspect{};
+    u8 eyebrow_rotate{};
+    u8 eyebrow_x{};
+    u8 eyebrow_y{};
+    u8 nose_type{};
+    u8 nose_scale{};
+    u8 nose_y{};
+    u8 mouth_type{};
+    u8 mouth_color{};
+    u8 mouth_scale{};
+    u8 mouth_aspect{};
+    u8 mouth_y{};
+    u8 beard_color{};
+    u8 beard_type{};
+    u8 mustache_type{};
+    u8 mustache_scale{};
+    u8 mustache_y{};
+    u8 glasses_type{};
+    u8 glasses_color{};
+    u8 glasses_scale{};
+    u8 glasses_y{};
+    u8 mole_type{};
+    u8 mole_scale{};
+    u8 mole_x{};
+    u8 mole_y{};
+    INSERT_PADDING_BYTES(1);
+
+    std::u16string Name() const;
+};
+static_assert(sizeof(MiiInfo) == 0x58, "MiiInfo has incorrect size.");
+static_assert(std::has_unique_object_representations_v<MiiInfo>,
+              "All bits of MiiInfo must contribute to its value.");
+
+#pragma pack(push, 4)
+
+struct MiiInfoElement {
+    MiiInfoElement(const MiiInfo& info, Source source) : info{info}, source{source} {}
+
+    MiiInfo info{};
+    Source source{};
+};
+static_assert(sizeof(MiiInfoElement) == 0x5c, "MiiInfoElement has incorrect size.");
+
+struct MiiStoreBitFields {
+    union {
+        u32 word_0{};
+
+        BitField<0, 8, u32> hair_type;
+        BitField<8, 7, u32> height;
+        BitField<15, 1, u32> mole_type;
+        BitField<16, 7, u32> build;
+        BitField<23, 1, HairFlip> hair_flip;
+        BitField<24, 7, u32> hair_color;
+        BitField<31, 1, u32> type;
+    };
+
+    union {
+        u32 word_1{};
+
+        BitField<0, 7, u32> eye_color;
+        BitField<7, 1, Gender> gender;
+        BitField<8, 7, u32> eyebrow_color;
+        BitField<16, 7, u32> mouth_color;
+        BitField<24, 7, u32> beard_color;
+    };
+
+    union {
+        u32 word_2{};
+
+        BitField<0, 7, u32> glasses_color;
+        BitField<8, 6, u32> eye_type;
+        BitField<14, 2, u32> region_move;
+        BitField<16, 6, u32> mouth_type;
+        BitField<22, 2, FontRegion> font_region;
+        BitField<24, 5, u32> eye_y;
+        BitField<29, 3, u32> glasses_scale;
+    };
+
+    union {
+        u32 word_3{};
+
+        BitField<0, 5, u32> eyebrow_type;
+        BitField<5, 3, MustacheType> mustache_type;
+        BitField<8, 5, u32> nose_type;
+        BitField<13, 3, BeardType> beard_type;
+        BitField<16, 5, u32> nose_y;
+        BitField<21, 3, u32> mouth_aspect;
+        BitField<24, 5, u32> mouth_y;
+        BitField<29, 3, u32> eyebrow_aspect;
+    };
+
+    union {
+        u32 word_4{};
+
+        BitField<0, 5, u32> mustache_y;
+        BitField<5, 3, u32> eye_rotate;
+        BitField<8, 5, u32> glasses_y;
+        BitField<13, 3, u32> eye_aspect;
+        BitField<16, 5, u32> mole_x;
+        BitField<21, 3, u32> eye_scale;
+        BitField<24, 5, u32> mole_y;
+    };
+
+    union {
+        u32 word_5{};
+
+        BitField<0, 5, u32> glasses_type;
+        BitField<8, 4, u32> favorite_color;
+        BitField<12, 4, u32> faceline_type;
+        BitField<16, 4, u32> faceline_color;
+        BitField<20, 4, u32> faceline_wrinkle;
+        BitField<24, 4, u32> faceline_makeup;
+        BitField<28, 4, u32> eye_x;
+    };
+
+    union {
+        u32 word_6{};
+
+        BitField<0, 4, u32> eyebrow_scale;
+        BitField<4, 4, u32> eyebrow_rotate;
+        BitField<8, 4, u32> eyebrow_x;
+        BitField<12, 4, u32> eyebrow_y;
+        BitField<16, 4, u32> nose_scale;
+        BitField<20, 4, u32> mouth_scale;
+        BitField<24, 4, u32> mustache_scale;
+        BitField<28, 4, u32> mole_scale;
+    };
+};
+static_assert(sizeof(MiiStoreBitFields) == 0x1c, "MiiStoreBitFields has incorrect size.");
+static_assert(std::is_trivially_copyable_v<MiiStoreBitFields>,
+              "MiiStoreBitFields is not trivially copyable.");
+
+struct MiiStoreData {
+    using Name = std::array<char16_t, 10>;
+
+    MiiStoreData();
+    MiiStoreData(const Name& name, const MiiStoreBitFields& bit_fields,
+                 const Common::UUID& user_id);
+
+    // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
+    // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
+    // not suitable for our uses.
+    struct {
+        std::array<u8, 0x1C> data{};
+        static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
+
+        Name name{};
+        Common::UUID uuid{Common::INVALID_UUID};
+    } data;
+
+    u16 data_crc{};
+    u16 device_crc{};
+};
+static_assert(sizeof(MiiStoreData) == 0x44, "MiiStoreData has incorrect size.");
+
+struct MiiStoreDataElement {
+    MiiStoreData data{};
+    Source source{};
+};
+static_assert(sizeof(MiiStoreDataElement) == 0x48, "MiiStoreDataElement has incorrect size.");
+
+struct MiiDatabase {
+    u32 magic{}; // 'NFDB'
+    std::array<MiiStoreData, 0x64> miis{};
+    INSERT_PADDING_BYTES(1);
+    u8 count{};
+    u16 crc{};
+};
+static_assert(sizeof(MiiDatabase) == 0x1A98, "MiiDatabase has incorrect size.");
+
+struct RandomMiiValues {
+    std::array<u8, 0xbc> values{};
+};
+static_assert(sizeof(RandomMiiValues) == 0xbc, "RandomMiiValues has incorrect size.");
+
+struct RandomMiiData4 {
+    Gender gender{};
+    Age age{};
+    Race race{};
+    u32 values_count{};
+    std::array<u8, 0xbc> values{};
+};
+static_assert(sizeof(RandomMiiData4) == 0xcc, "RandomMiiData4 has incorrect size.");
+
+struct RandomMiiData3 {
+    u32 arg_1;
+    u32 arg_2;
+    u32 values_count;
+    std::array<u8, 0xbc> values{};
+};
+static_assert(sizeof(RandomMiiData3) == 0xc8, "RandomMiiData3 has incorrect size.");
+
+struct RandomMiiData2 {
+    u32 arg_1;
+    u32 values_count;
+    std::array<u8, 0xbc> values{};
+};
+static_assert(sizeof(RandomMiiData2) == 0xc4, "RandomMiiData2 has incorrect size.");
+
+struct DefaultMii {
+    u32 face_type{};
+    u32 face_color{};
+    u32 face_wrinkle{};
+    u32 face_makeup{};
+    u32 hair_type{};
+    u32 hair_color{};
+    u32 hair_flip{};
+    u32 eye_type{};
+    u32 eye_color{};
+    u32 eye_scale{};
+    u32 eye_aspect{};
+    u32 eye_rotate{};
+    u32 eye_x{};
+    u32 eye_y{};
+    u32 eyebrow_type{};
+    u32 eyebrow_color{};
+    u32 eyebrow_scale{};
+    u32 eyebrow_aspect{};
+    u32 eyebrow_rotate{};
+    u32 eyebrow_x{};
+    u32 eyebrow_y{};
+    u32 nose_type{};
+    u32 nose_scale{};
+    u32 nose_y{};
+    u32 mouth_type{};
+    u32 mouth_color{};
+    u32 mouth_scale{};
+    u32 mouth_aspect{};
+    u32 mouth_y{};
+    u32 mustache_type{};
+    u32 beard_type{};
+    u32 beard_color{};
+    u32 mustache_scale{};
+    u32 mustache_y{};
+    u32 glasses_type{};
+    u32 glasses_color{};
+    u32 glasses_scale{};
+    u32 glasses_y{};
+    u32 mole_type{};
+    u32 mole_scale{};
+    u32 mole_x{};
+    u32 mole_y{};
+    u32 height{};
+    u32 weight{};
+    Gender gender{};
+    u32 favorite_color{};
+    u32 region{};
+    FontRegion font_region{};
+    u32 type{};
+    INSERT_PADDING_WORDS(5);
+};
+static_assert(sizeof(DefaultMii) == 0xd8, "MiiStoreData has incorrect size.");
+
+#pragma pack(pop)
+
+// The Mii manager is responsible for loading and storing the Miis to the database in NAND along
+// with providing an easy interface for HLE emulation of the mii service.
+class MiiManager {
+public:
+    MiiManager();
+
+    bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter);
+    bool IsFullDatabase() const;
+    u32 GetCount(SourceFlag source_flag) const;
+    ResultVal<MiiInfo> UpdateLatest(const MiiInfo& info, SourceFlag source_flag);
+    MiiInfo BuildRandom(Age age, Gender gender, Race race);
+    MiiInfo BuildDefault(std::size_t index);
+    ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag);
+    ResultCode GetIndex(const MiiInfo& info, u32& index);
+
+private:
+    const Common::UUID user_id;
+    u64 update_counter{};
+};
+
+}; // namespace Service::Mii

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

@@ -4,22 +4,17 @@
 
 #include <memory>
 
-#include <fmt/ostream.h>
-
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/service/mii/manager.h"
 #include "core/hle/service/mii/mii.h"
-#include "core/hle/service/mii/mii_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Mii {
 
 constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::Mii, 1};
-constexpr ResultCode ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};
-constexpr ResultCode ERROR_NOT_IN_TEST_MODE{ErrorModule::Mii, 99};
 
 class IDatabaseService final : public ServiceFramework<IDatabaseService> {
 public:
@@ -31,19 +26,19 @@ public:
             {2, &IDatabaseService::GetCount, "GetCount"},
             {3, &IDatabaseService::Get, "Get"},
             {4, &IDatabaseService::Get1, "Get1"},
-            {5, nullptr, "UpdateLatest"},
+            {5, &IDatabaseService::UpdateLatest, "UpdateLatest"},
             {6, &IDatabaseService::BuildRandom, "BuildRandom"},
             {7, &IDatabaseService::BuildDefault, "BuildDefault"},
-            {8, &IDatabaseService::Get2, "Get2"},
-            {9, &IDatabaseService::Get3, "Get3"},
+            {8, nullptr, "Get2"},
+            {9, nullptr, "Get3"},
             {10, nullptr, "UpdateLatest1"},
-            {11, &IDatabaseService::FindIndex, "FindIndex"},
-            {12, &IDatabaseService::Move, "Move"},
-            {13, &IDatabaseService::AddOrReplace, "AddOrReplace"},
-            {14, &IDatabaseService::Delete, "Delete"},
-            {15, &IDatabaseService::DestroyFile, "DestroyFile"},
-            {16, &IDatabaseService::DeleteFile, "DeleteFile"},
-            {17, &IDatabaseService::Format, "Format"},
+            {11, nullptr, "FindIndex"},
+            {12, nullptr, "Move"},
+            {13, nullptr, "AddOrReplace"},
+            {14, nullptr, "Delete"},
+            {15, nullptr, "DestroyFile"},
+            {16, nullptr, "DeleteFile"},
+            {17, nullptr, "Format"},
             {18, nullptr, "Import"},
             {19, nullptr, "Export"},
             {20, nullptr, "IsBrokenDatabaseWithClearFlag"},
@@ -59,31 +54,26 @@ public:
     }
 
 private:
-    template <typename OutType>
-    std::vector<u8> SerializeArray(OutType (MiiManager::*getter)(u32) const, u32 offset,
-                                   u32 requested_size, u32& read_size) {
-        read_size = std::min(requested_size, db.Size() - offset);
-
-        std::vector<u8> out(read_size * sizeof(OutType));
-
-        for (u32 i = 0; i < read_size; ++i) {
-            const auto obj = (db.*getter)(offset + i);
-            std::memcpy(out.data() + i * sizeof(OutType), &obj, sizeof(OutType));
+    template <typename T>
+    std::vector<u8> SerializeArray(const std::vector<T>& values) {
+        std::vector<u8> out(values.size() * sizeof(T));
+        std::size_t offset{};
+        for (const auto& value : values) {
+            std::memcpy(out.data() + offset, &value, sizeof(T));
+            offset += sizeof(T);
         }
-
         return out;
     }
 
     void IsUpdated(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto source{rp.PopRaw<Source>()};
+        const auto source_flag{rp.PopRaw<SourceFlag>()};
 
-        LOG_DEBUG(Service_Mii, "called with source={}", source);
+        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(db.CheckUpdatedFlag());
-        db.ResetUpdatedFlag();
+        rb.Push(manager.CheckAndResetUpdateCounter(source_flag, current_update_counter));
     }
 
     void IsFullDatabase(Kernel::HLERequestContext& ctx) {
@@ -91,93 +81,126 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(db.Full());
+        rb.Push(manager.IsFullDatabase());
     }
 
     void GetCount(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto source{rp.PopRaw<Source>()};
+        const auto source_flag{rp.PopRaw<SourceFlag>()};
 
-        LOG_DEBUG(Service_Mii, "called with source={}", source);
+        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(db.Size());
+        rb.Push<u32>(manager.GetCount(source_flag));
     }
 
-    // Gets Miis from database at offset and index in format MiiInfoElement
     void Get(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
+        const auto source_flag{rp.PopRaw<SourceFlag>()};
 
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[0], source);
+        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetInfoElement, offsets[0], size, read_size));
-        offsets[0] += read_size;
+        const auto result{manager.GetDefault(source_flag)};
+        if (result.Failed()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result.Code());
+            return;
+        }
+
+        if (result->size() > 0) {
+            ctx.WriteBuffer(SerializeArray(*result));
+        }
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
+        rb.Push<u32>(static_cast<u32>(result->size()));
     }
 
-    // Gets Miis from database at offset and index in format MiiInfo
     void Get1(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
+        const auto source_flag{rp.PopRaw<SourceFlag>()};
 
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[1], source);
+        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
 
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetInfo, offsets[1], size, read_size));
-        offsets[1] += read_size;
+        const auto result{manager.GetDefault(source_flag)};
+        if (result.Failed()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result.Code());
+            return;
+        }
+
+        std::vector<MiiInfo> values;
+        for (const auto& element : *result) {
+            values.emplace_back(element.info);
+        }
+
+        ctx.WriteBuffer(SerializeArray(values));
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
+        rb.Push<u32>(static_cast<u32>(result->size()));
+    }
+
+    void UpdateLatest(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto info{rp.PopRaw<MiiInfo>()};
+        const auto source_flag{rp.PopRaw<SourceFlag>()};
+
+        LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
+
+        const auto result{manager.UpdateLatest(info, source_flag)};
+        if (result.Failed()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result.Code());
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 2 + sizeof(MiiInfo) / sizeof(u32)};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<MiiInfo>(*result);
     }
 
     void BuildRandom(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto [unknown1, unknown2, unknown3] = rp.PopRaw<RandomParameters>();
 
-        if (unknown1 > 3) {
+        const auto age{rp.PopRaw<Age>()};
+        const auto gender{rp.PopRaw<Gender>()};
+        const auto race{rp.PopRaw<Race>()};
+
+        LOG_DEBUG(Service_Mii, "called with age={}, gender={}, race={}", age, gender, race);
+
+        if (age > Age::All) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown1 value: {}", unknown1);
+            LOG_ERROR(Service_Mii, "invalid age={}", age);
             return;
         }
 
-        if (unknown2 > 2) {
+        if (gender > Gender::All) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown2 value: {}", unknown2);
+            LOG_ERROR(Service_Mii, "invalid gender={}", gender);
             return;
         }
 
-        if (unknown3 > 3) {
+        if (race > Race::All) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERROR_INVALID_ARGUMENT);
-            LOG_ERROR(Service_Mii, "Invalid unknown3 value: {}", unknown3);
+            LOG_ERROR(Service_Mii, "invalid race={}", race);
             return;
         }
 
-        LOG_DEBUG(Service_Mii, "called with param_1={:08X}, param_2={:08X}, param_3={:08X}",
-                  unknown1, unknown2, unknown3);
-
-        const auto info = db.CreateRandom({unknown1, unknown2, unknown3});
         IPC::ResponseBuilder rb{ctx, 2 + sizeof(MiiInfo) / sizeof(u32)};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<MiiInfo>(info);
+        rb.PushRaw<MiiInfo>(manager.BuildRandom(age, gender, race));
     }
 
     void BuildDefault(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
-        const auto index{rp.PopRaw<u32>()};
+        const auto index{rp.Pop<u32>()};
+
+        LOG_DEBUG(Service_Mii, "called with index={}", index);
 
         if (index > 5) {
             LOG_ERROR(Service_Mii, "invalid argument, index cannot be greater than 5 but is {:08X}",
@@ -187,168 +210,20 @@ private:
             return;
         }
 
-        LOG_DEBUG(Service_Mii, "called with index={:08X}", index);
-
-        const auto info = db.CreateDefault(index);
         IPC::ResponseBuilder rb{ctx, 2 + sizeof(MiiInfo) / sizeof(u32)};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<MiiInfo>(info);
-    }
-
-    // Gets Miis from database at offset and index in format MiiStoreDataElement
-    void Get2(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[2], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(
-            SerializeArray(&MiiManager::GetStoreDataElement, offsets[2], size, read_size));
-        offsets[2] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    // Gets Miis from database at offset and index in format MiiStoreData
-    void Get3(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto size{rp.PopRaw<u32>()};
-        const auto source{rp.PopRaw<Source>()};
-
-        LOG_DEBUG(Service_Mii, "called with size={:08X}, offset={:08X}, source={}", size,
-                  offsets[3], source);
-
-        u32 read_size{};
-        ctx.WriteBuffer(SerializeArray(&MiiManager::GetStoreData, offsets[3], size, read_size));
-        offsets[3] += read_size;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(read_size);
-    }
-
-    void FindIndex(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-        const auto unknown{rp.PopRaw<bool>()};
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}, unknown={}", uuid.FormatSwitch(), unknown);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-
-        const auto index = db.IndexOf(uuid);
-        if (index > MAX_MIIS) {
-            // TODO(DarkLordZach): Find a better error code
-            rb.Push(RESULT_UNKNOWN);
-            rb.Push(index);
-        } else {
-            rb.Push(RESULT_SUCCESS);
-            rb.Push(index);
-        }
-    }
-
-    void Move(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-        const auto index{rp.PopRaw<s32>()};
-
-        if (index < 0) {
-            LOG_ERROR(Service_Mii, "Index cannot be negative but is {:08X}!", index);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}, index={:08X}", uuid.FormatSwitch(), index);
-
-        const auto success = db.Move(uuid, index);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        // TODO(DarkLordZach): Find a better error code
-        rb.Push(success ? RESULT_SUCCESS : RESULT_UNKNOWN);
-    }
-
-    void AddOrReplace(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto data{rp.PopRaw<MiiStoreData>()};
-
-        LOG_DEBUG(Service_Mii, "called with Mii data uuid={}, name={}", data.uuid.FormatSwitch(),
-                  Common::UTF16ToUTF8(data.Name()));
-
-        const auto success = db.AddOrReplace(data);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        // TODO(DarkLordZach): Find a better error code
-        rb.Push(success ? RESULT_SUCCESS : RESULT_UNKNOWN);
-    }
-
-    void Delete(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto uuid{rp.PopRaw<Common::UUID>()};
-
-        LOG_DEBUG(Service_Mii, "called with uuid={}", uuid.FormatSwitch());
-
-        const auto success = db.Remove(uuid);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(success ? RESULT_SUCCESS : ERROR_CANNOT_FIND_ENTRY);
-    }
-
-    void DestroyFile(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        if (!db.IsTestModeEnabled()) {
-            LOG_ERROR(Service_Mii, "Database is not in test mode -- cannot destory database file.");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NOT_IN_TEST_MODE);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.DestroyFile());
-    }
-
-    void DeleteFile(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        if (!db.IsTestModeEnabled()) {
-            LOG_ERROR(Service_Mii, "Database is not in test mode -- cannot delete database file.");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_NOT_IN_TEST_MODE);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(db.DeleteFile());
-    }
-
-    void Format(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Mii, "called");
-
-        db.Clear();
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
+        rb.PushRaw<MiiInfo>(manager.BuildDefault(index));
     }
 
     void GetIndex(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto info{rp.PopRaw<MiiInfo>()};
 
-        LOG_DEBUG(Service_Mii, "called with Mii info uuid={}, name={}", info.uuid.FormatSwitch(),
-                  Common::UTF16ToUTF8(info.Name()));
+        LOG_DEBUG(Service_Mii, "called");
 
-        const auto index = db.IndexOf(info);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
+        u32 index{};
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(manager.GetIndex(info, index));
         rb.Push(index);
     }
 
@@ -364,12 +239,14 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    MiiManager db;
+    constexpr bool IsInterfaceVersionSupported(u32 interface_version) const {
+        return current_interface_version >= interface_version;
+    }
 
-    u32 current_interface_version = 0;
+    MiiManager manager;
 
-    // Last read offsets of Get functions
-    std::array<u32, 4> offsets{};
+    u32 current_interface_version{};
+    u64 current_update_counter{};
 };
 
 class MiiDBModule final : public ServiceFramework<MiiDBModule> {

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

@@ -1,420 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include "common/assert.h"
-#include "common/file_util.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/hle/service/mii/mii_manager.h"
-
-namespace Service::Mii {
-
-namespace {
-
-constexpr char MII_SAVE_DATABASE_PATH[] = "/system/save/8000000000000030/MiiDatabase.dat";
-constexpr std::array<char16_t, 11> DEFAULT_MII_NAME = {u'y', u'u', u'z', u'u', u'\0'};
-
-// This value was retrieved from HW test
-constexpr MiiStoreData DEFAULT_MII = {
-    {
-        0x21, 0x40, 0x40, 0x01, 0x08, 0x01, 0x13, 0x08, 0x08, 0x02, 0x17, 0x8C, 0x06, 0x01,
-        0x69, 0x6D, 0x8A, 0x6A, 0x82, 0x14, 0x00, 0x00, 0x00, 0x20, 0x64, 0x72, 0x44, 0x44,
-    },
-    {'y', 'u', 'z', 'u', '\0'},
-    Common::UUID{1, 0},
-    0,
-    0,
-};
-
-// Default values taken from multiple real databases
-const MiiDatabase DEFAULT_MII_DATABASE{Common::MakeMagic('N', 'F', 'D', 'B'), {}, {1}, 0, 0};
-
-constexpr std::array<const char*, 4> SOURCE_NAMES{
-    "Database",
-    "Default",
-    "Account",
-    "Friend",
-};
-
-template <typename T, std::size_t SourceArraySize, std::size_t DestArraySize>
-std::array<T, DestArraySize> ResizeArray(const std::array<T, SourceArraySize>& in) {
-    std::array<T, DestArraySize> out{};
-    std::memcpy(out.data(), in.data(), sizeof(T) * std::min(SourceArraySize, DestArraySize));
-    return out;
-}
-
-MiiInfo ConvertStoreDataToInfo(const MiiStoreData& data) {
-    MiiStoreBitFields bf{};
-    std::memcpy(&bf, data.data.data(), sizeof(MiiStoreBitFields));
-    return {
-        data.uuid,
-        ResizeArray<char16_t, 10, 11>(data.name),
-        static_cast<u8>(bf.font_region.Value()),
-        static_cast<u8>(bf.favorite_color.Value()),
-        static_cast<u8>(bf.gender.Value()),
-        static_cast<u8>(bf.height.Value()),
-        static_cast<u8>(bf.weight.Value()),
-        static_cast<u8>(bf.mii_type.Value()),
-        static_cast<u8>(bf.mii_region.Value()),
-        static_cast<u8>(bf.face_type.Value()),
-        static_cast<u8>(bf.face_color.Value()),
-        static_cast<u8>(bf.face_wrinkle.Value()),
-        static_cast<u8>(bf.face_makeup.Value()),
-        static_cast<u8>(bf.hair_type.Value()),
-        static_cast<u8>(bf.hair_color.Value()),
-        static_cast<bool>(bf.hair_flip.Value()),
-        static_cast<u8>(bf.eye_type.Value()),
-        static_cast<u8>(bf.eye_color.Value()),
-        static_cast<u8>(bf.eye_scale.Value()),
-        static_cast<u8>(bf.eye_aspect.Value()),
-        static_cast<u8>(bf.eye_rotate.Value()),
-        static_cast<u8>(bf.eye_x.Value()),
-        static_cast<u8>(bf.eye_y.Value()),
-        static_cast<u8>(bf.eyebrow_type.Value()),
-        static_cast<u8>(bf.eyebrow_color.Value()),
-        static_cast<u8>(bf.eyebrow_scale.Value()),
-        static_cast<u8>(bf.eyebrow_aspect.Value()),
-        static_cast<u8>(bf.eyebrow_rotate.Value()),
-        static_cast<u8>(bf.eyebrow_x.Value()),
-        static_cast<u8>(bf.eyebrow_y.Value()),
-        static_cast<u8>(bf.nose_type.Value()),
-        static_cast<u8>(bf.nose_scale.Value()),
-        static_cast<u8>(bf.nose_y.Value()),
-        static_cast<u8>(bf.mouth_type.Value()),
-        static_cast<u8>(bf.mouth_color.Value()),
-        static_cast<u8>(bf.mouth_scale.Value()),
-        static_cast<u8>(bf.mouth_aspect.Value()),
-        static_cast<u8>(bf.mouth_y.Value()),
-        static_cast<u8>(bf.facial_hair_color.Value()),
-        static_cast<u8>(bf.beard_type.Value()),
-        static_cast<u8>(bf.mustache_type.Value()),
-        static_cast<u8>(bf.mustache_scale.Value()),
-        static_cast<u8>(bf.mustache_y.Value()),
-        static_cast<u8>(bf.glasses_type.Value()),
-        static_cast<u8>(bf.glasses_color.Value()),
-        static_cast<u8>(bf.glasses_scale.Value()),
-        static_cast<u8>(bf.glasses_y.Value()),
-        static_cast<u8>(bf.mole_type.Value()),
-        static_cast<u8>(bf.mole_scale.Value()),
-        static_cast<u8>(bf.mole_x.Value()),
-        static_cast<u8>(bf.mole_y.Value()),
-        0x00,
-    };
-}
-MiiStoreData ConvertInfoToStoreData(const MiiInfo& info) {
-    MiiStoreData out{};
-    out.name = ResizeArray<char16_t, 11, 10>(info.name);
-    out.uuid = info.uuid;
-
-    MiiStoreBitFields bf{};
-
-    bf.hair_type.Assign(info.hair_type);
-    bf.mole_type.Assign(info.mole_type);
-    bf.height.Assign(info.height);
-    bf.hair_flip.Assign(info.hair_flip);
-    bf.weight.Assign(info.weight);
-    bf.hair_color.Assign(info.hair_color);
-
-    bf.gender.Assign(info.gender);
-    bf.eye_color.Assign(info.eye_color);
-    bf.eyebrow_color.Assign(info.eyebrow_color);
-    bf.mouth_color.Assign(info.mouth_color);
-    bf.facial_hair_color.Assign(info.facial_hair_color);
-
-    bf.mii_type.Assign(info.mii_type);
-    bf.glasses_color.Assign(info.glasses_color);
-    bf.font_region.Assign(info.font_region);
-    bf.eye_type.Assign(info.eye_type);
-    bf.mii_region.Assign(info.mii_region);
-    bf.mouth_type.Assign(info.mouth_type);
-    bf.glasses_scale.Assign(info.glasses_scale);
-    bf.eye_y.Assign(info.eye_y);
-
-    bf.mustache_type.Assign(info.mustache_type);
-    bf.eyebrow_type.Assign(info.eyebrow_type);
-    bf.beard_type.Assign(info.beard_type);
-    bf.nose_type.Assign(info.nose_type);
-    bf.mouth_aspect.Assign(info.mouth_aspect_ratio);
-    bf.nose_y.Assign(info.nose_y);
-    bf.eyebrow_aspect.Assign(info.eyebrow_aspect_ratio);
-    bf.mouth_y.Assign(info.mouth_y);
-
-    bf.eye_rotate.Assign(info.eye_rotate);
-    bf.mustache_y.Assign(info.mustache_y);
-    bf.eye_aspect.Assign(info.eye_aspect_ratio);
-    bf.glasses_y.Assign(info.glasses_y);
-    bf.eye_scale.Assign(info.eye_scale);
-    bf.mole_x.Assign(info.mole_x);
-    bf.mole_y.Assign(info.mole_y);
-
-    bf.glasses_type.Assign(info.glasses_type);
-    bf.face_type.Assign(info.face_type);
-    bf.favorite_color.Assign(info.favorite_color);
-    bf.face_wrinkle.Assign(info.face_wrinkle);
-    bf.face_color.Assign(info.face_color);
-    bf.eye_x.Assign(info.eye_x);
-    bf.face_makeup.Assign(info.face_makeup);
-
-    bf.eyebrow_rotate.Assign(info.eyebrow_rotate);
-    bf.eyebrow_scale.Assign(info.eyebrow_scale);
-    bf.eyebrow_y.Assign(info.eyebrow_y);
-    bf.eyebrow_x.Assign(info.eyebrow_x);
-    bf.mouth_scale.Assign(info.mouth_scale);
-    bf.nose_scale.Assign(info.nose_scale);
-    bf.mole_scale.Assign(info.mole_scale);
-    bf.mustache_scale.Assign(info.mustache_scale);
-
-    std::memcpy(out.data.data(), &bf, sizeof(MiiStoreBitFields));
-
-    return out;
-}
-
-} // namespace
-
-std::ostream& operator<<(std::ostream& os, Source source) {
-    if (static_cast<std::size_t>(source) >= SOURCE_NAMES.size()) {
-        return os << "[UNKNOWN SOURCE]";
-    }
-
-    os << SOURCE_NAMES.at(static_cast<std::size_t>(source));
-    return os;
-}
-
-std::u16string MiiInfo::Name() const {
-    return Common::UTF16StringFromFixedZeroTerminatedBuffer(name.data(), name.size());
-}
-
-bool operator==(const MiiInfo& lhs, const MiiInfo& rhs) {
-    return std::memcmp(&lhs, &rhs, sizeof(MiiInfo)) == 0;
-}
-
-bool operator!=(const MiiInfo& lhs, const MiiInfo& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-std::u16string MiiStoreData::Name() const {
-    return Common::UTF16StringFromFixedZeroTerminatedBuffer(name.data(), name.size());
-}
-
-MiiManager::MiiManager() = default;
-
-MiiManager::~MiiManager() = default;
-
-MiiInfo MiiManager::CreateRandom(RandomParameters params) {
-    LOG_WARNING(Service_Mii,
-                "(STUBBED) called with params={:08X}{:08X}{:08X}, returning default Mii",
-                params.unknown_1, params.unknown_2, params.unknown_3);
-
-    return ConvertStoreDataToInfo(CreateMiiWithUniqueUUID());
-}
-
-MiiInfo MiiManager::CreateDefault(u32 index) {
-    const auto new_mii = CreateMiiWithUniqueUUID();
-
-    database.miis.at(index) = new_mii;
-
-    EnsureDatabasePartition();
-    return ConvertStoreDataToInfo(new_mii);
-}
-
-bool MiiManager::CheckUpdatedFlag() const {
-    return updated_flag;
-}
-
-void MiiManager::ResetUpdatedFlag() {
-    updated_flag = false;
-}
-
-bool MiiManager::IsTestModeEnabled() const {
-    return is_test_mode_enabled;
-}
-
-bool MiiManager::Empty() const {
-    return Size() == 0;
-}
-
-bool MiiManager::Full() const {
-    return Size() == MAX_MIIS;
-}
-
-void MiiManager::Clear() {
-    updated_flag = true;
-    std::fill(database.miis.begin(), database.miis.end(), MiiStoreData{});
-}
-
-u32 MiiManager::Size() const {
-    return static_cast<u32>(std::count_if(database.miis.begin(), database.miis.end(),
-                                          [](const MiiStoreData& elem) { return elem.uuid; }));
-}
-
-MiiInfo MiiManager::GetInfo(u32 index) const {
-    return ConvertStoreDataToInfo(GetStoreData(index));
-}
-
-MiiInfoElement MiiManager::GetInfoElement(u32 index) const {
-    return {GetInfo(index), Source::Database};
-}
-
-MiiStoreData MiiManager::GetStoreData(u32 index) const {
-    return database.miis.at(index);
-}
-
-MiiStoreDataElement MiiManager::GetStoreDataElement(u32 index) const {
-    return {GetStoreData(index), Source::Database};
-}
-
-bool MiiManager::Remove(Common::UUID uuid) {
-    const auto iter = std::find_if(database.miis.begin(), database.miis.end(),
-                                   [uuid](const MiiStoreData& elem) { return elem.uuid == uuid; });
-
-    if (iter == database.miis.end())
-        return false;
-
-    updated_flag = true;
-    *iter = MiiStoreData{};
-    EnsureDatabasePartition();
-    return true;
-}
-
-u32 MiiManager::IndexOf(Common::UUID uuid) const {
-    const auto iter = std::find_if(database.miis.begin(), database.miis.end(),
-                                   [uuid](const MiiStoreData& elem) { return elem.uuid == uuid; });
-
-    if (iter == database.miis.end())
-        return INVALID_INDEX;
-
-    return static_cast<u32>(std::distance(database.miis.begin(), iter));
-}
-
-u32 MiiManager::IndexOf(const MiiInfo& info) const {
-    const auto iter =
-        std::find_if(database.miis.begin(), database.miis.end(), [&info](const MiiStoreData& elem) {
-            return ConvertStoreDataToInfo(elem) == info;
-        });
-
-    if (iter == database.miis.end())
-        return INVALID_INDEX;
-
-    return static_cast<u32>(std::distance(database.miis.begin(), iter));
-}
-
-bool MiiManager::Move(Common::UUID uuid, u32 new_index) {
-    const auto index = IndexOf(uuid);
-
-    if (index == INVALID_INDEX || new_index >= MAX_MIIS)
-        return false;
-
-    updated_flag = true;
-    const auto moving = database.miis[index];
-    const auto replacing = database.miis[new_index];
-    if (replacing.uuid) {
-        database.miis[index] = replacing;
-        database.miis[new_index] = moving;
-    } else {
-        database.miis[index] = MiiStoreData{};
-        database.miis[new_index] = moving;
-    }
-
-    EnsureDatabasePartition();
-    return true;
-}
-
-bool MiiManager::AddOrReplace(const MiiStoreData& data) {
-    const auto index = IndexOf(data.uuid);
-
-    updated_flag = true;
-    if (index == INVALID_INDEX) {
-        const auto size = Size();
-        if (size == MAX_MIIS)
-            return false;
-        database.miis[size] = data;
-    } else {
-        database.miis[index] = data;
-    }
-
-    return true;
-}
-
-bool MiiManager::DestroyFile() {
-    database = DEFAULT_MII_DATABASE;
-    updated_flag = false;
-    return DeleteFile();
-}
-
-bool MiiManager::DeleteFile() {
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH;
-    return FileUtil::Exists(path) && FileUtil::Delete(path);
-}
-
-void MiiManager::WriteToFile() {
-    const auto raw_path =
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000030";
-    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
-        FileUtil::Delete(raw_path);
-
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH;
-
-    if (!FileUtil::CreateFullPath(path)) {
-        LOG_WARNING(Service_Mii,
-                    "Failed to create full path of MiiDatabase.dat. Create the directory "
-                    "nand/system/save/8000000000000030 to mitigate this "
-                    "issue.");
-        return;
-    }
-
-    FileUtil::IOFile save(path, "wb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_Mii, "Failed to write save data to file... No changes to user data "
-                                 "made in current session will be saved.");
-        return;
-    }
-
-    save.Resize(sizeof(MiiDatabase));
-    if (save.WriteBytes(&database, sizeof(MiiDatabase)) != sizeof(MiiDatabase)) {
-        LOG_WARNING(Service_Mii, "Failed to write all data to save file... Data may be malformed "
-                                 "and/or regenerated on next run.");
-        save.Resize(0);
-    }
-}
-
-void MiiManager::ReadFromFile() {
-    FileUtil::IOFile save(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + MII_SAVE_DATABASE_PATH, "rb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "blank Mii database with no Miis.");
-        std::memcpy(&database, &DEFAULT_MII_DATABASE, sizeof(MiiDatabase));
-        return;
-    }
-
-    if (save.ReadBytes(&database, sizeof(MiiDatabase)) != sizeof(MiiDatabase)) {
-        LOG_WARNING(Service_ACC, "MiiDatabase.dat is smaller than expected... Generating new blank "
-                                 "Mii database with no Miis.");
-        std::memcpy(&database, &DEFAULT_MII_DATABASE, sizeof(MiiDatabase));
-        return;
-    }
-
-    EnsureDatabasePartition();
-}
-
-MiiStoreData MiiManager::CreateMiiWithUniqueUUID() const {
-    auto new_mii = DEFAULT_MII;
-
-    do {
-        new_mii.uuid = Common::UUID::Generate();
-    } while (IndexOf(new_mii.uuid) != INVALID_INDEX);
-
-    return new_mii;
-}
-
-void MiiManager::EnsureDatabasePartition() {
-    std::stable_partition(database.miis.begin(), database.miis.end(),
-                          [](const MiiStoreData& elem) { return elem.uuid; });
-}
-
-} // namespace Service::Mii

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

@@ -1,273 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/bit_field.h"
-#include "common/common_funcs.h"
-#include "common/uuid.h"
-
-namespace Service::Mii {
-
-constexpr std::size_t MAX_MIIS{100};
-constexpr u32 INVALID_INDEX{0xFFFFFFFF};
-
-struct RandomParameters {
-    u32 unknown_1{};
-    u32 unknown_2{};
-    u32 unknown_3{};
-};
-static_assert(sizeof(RandomParameters) == 0xC, "RandomParameters has incorrect size.");
-
-enum class Source : u32 {
-    Database = 0,
-    Default = 1,
-    Account = 2,
-    Friend = 3,
-};
-
-std::ostream& operator<<(std::ostream& os, Source source);
-
-struct MiiInfo {
-    Common::UUID uuid{Common::INVALID_UUID};
-    std::array<char16_t, 11> name{};
-    u8 font_region{};
-    u8 favorite_color{};
-    u8 gender{};
-    u8 height{};
-    u8 weight{};
-    u8 mii_type{};
-    u8 mii_region{};
-    u8 face_type{};
-    u8 face_color{};
-    u8 face_wrinkle{};
-    u8 face_makeup{};
-    u8 hair_type{};
-    u8 hair_color{};
-    bool hair_flip{};
-    u8 eye_type{};
-    u8 eye_color{};
-    u8 eye_scale{};
-    u8 eye_aspect_ratio{};
-    u8 eye_rotate{};
-    u8 eye_x{};
-    u8 eye_y{};
-    u8 eyebrow_type{};
-    u8 eyebrow_color{};
-    u8 eyebrow_scale{};
-    u8 eyebrow_aspect_ratio{};
-    u8 eyebrow_rotate{};
-    u8 eyebrow_x{};
-    u8 eyebrow_y{};
-    u8 nose_type{};
-    u8 nose_scale{};
-    u8 nose_y{};
-    u8 mouth_type{};
-    u8 mouth_color{};
-    u8 mouth_scale{};
-    u8 mouth_aspect_ratio{};
-    u8 mouth_y{};
-    u8 facial_hair_color{};
-    u8 beard_type{};
-    u8 mustache_type{};
-    u8 mustache_scale{};
-    u8 mustache_y{};
-    u8 glasses_type{};
-    u8 glasses_color{};
-    u8 glasses_scale{};
-    u8 glasses_y{};
-    u8 mole_type{};
-    u8 mole_scale{};
-    u8 mole_x{};
-    u8 mole_y{};
-    INSERT_PADDING_BYTES(1);
-
-    std::u16string Name() const;
-};
-static_assert(sizeof(MiiInfo) == 0x58, "MiiInfo has incorrect size.");
-static_assert(std::has_unique_object_representations_v<MiiInfo>,
-              "All bits of MiiInfo must contribute to its value.");
-
-bool operator==(const MiiInfo& lhs, const MiiInfo& rhs);
-bool operator!=(const MiiInfo& lhs, const MiiInfo& rhs);
-
-#pragma pack(push, 4)
-struct MiiInfoElement {
-    MiiInfo info{};
-    Source source{};
-};
-static_assert(sizeof(MiiInfoElement) == 0x5C, "MiiInfoElement has incorrect size.");
-
-struct MiiStoreBitFields {
-    union {
-        u32 word_0{};
-
-        BitField<24, 8, u32> hair_type;
-        BitField<23, 1, u32> mole_type;
-        BitField<16, 7, u32> height;
-        BitField<15, 1, u32> hair_flip;
-        BitField<8, 7, u32> weight;
-        BitField<0, 7, u32> hair_color;
-    };
-
-    union {
-        u32 word_1{};
-
-        BitField<31, 1, u32> gender;
-        BitField<24, 7, u32> eye_color;
-        BitField<16, 7, u32> eyebrow_color;
-        BitField<8, 7, u32> mouth_color;
-        BitField<0, 7, u32> facial_hair_color;
-    };
-
-    union {
-        u32 word_2{};
-
-        BitField<31, 1, u32> mii_type;
-        BitField<24, 7, u32> glasses_color;
-        BitField<22, 2, u32> font_region;
-        BitField<16, 6, u32> eye_type;
-        BitField<14, 2, u32> mii_region;
-        BitField<8, 6, u32> mouth_type;
-        BitField<5, 3, u32> glasses_scale;
-        BitField<0, 5, u32> eye_y;
-    };
-
-    union {
-        u32 word_3{};
-
-        BitField<29, 3, u32> mustache_type;
-        BitField<24, 5, u32> eyebrow_type;
-        BitField<21, 3, u32> beard_type;
-        BitField<16, 5, u32> nose_type;
-        BitField<13, 3, u32> mouth_aspect;
-        BitField<8, 5, u32> nose_y;
-        BitField<5, 3, u32> eyebrow_aspect;
-        BitField<0, 5, u32> mouth_y;
-    };
-
-    union {
-        u32 word_4{};
-
-        BitField<29, 3, u32> eye_rotate;
-        BitField<24, 5, u32> mustache_y;
-        BitField<21, 3, u32> eye_aspect;
-        BitField<16, 5, u32> glasses_y;
-        BitField<13, 3, u32> eye_scale;
-        BitField<8, 5, u32> mole_x;
-        BitField<0, 5, u32> mole_y;
-    };
-
-    union {
-        u32 word_5{};
-
-        BitField<24, 5, u32> glasses_type;
-        BitField<20, 4, u32> face_type;
-        BitField<16, 4, u32> favorite_color;
-        BitField<12, 4, u32> face_wrinkle;
-        BitField<8, 4, u32> face_color;
-        BitField<4, 4, u32> eye_x;
-        BitField<0, 4, u32> face_makeup;
-    };
-
-    union {
-        u32 word_6{};
-
-        BitField<28, 4, u32> eyebrow_rotate;
-        BitField<24, 4, u32> eyebrow_scale;
-        BitField<20, 4, u32> eyebrow_y;
-        BitField<16, 4, u32> eyebrow_x;
-        BitField<12, 4, u32> mouth_scale;
-        BitField<8, 4, u32> nose_scale;
-        BitField<4, 4, u32> mole_scale;
-        BitField<0, 4, u32> mustache_scale;
-    };
-};
-static_assert(sizeof(MiiStoreBitFields) == 0x1C, "MiiStoreBitFields has incorrect size.");
-static_assert(std::is_trivially_copyable_v<MiiStoreBitFields>,
-              "MiiStoreBitFields is not trivially copyable.");
-
-struct MiiStoreData {
-    // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
-    // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
-    // not suitable for our uses.
-    std::array<u8, 0x1C> data{};
-    static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
-
-    std::array<char16_t, 10> name{};
-    Common::UUID uuid{Common::INVALID_UUID};
-    u16 crc_1{};
-    u16 crc_2{};
-
-    std::u16string Name() const;
-};
-static_assert(sizeof(MiiStoreData) == 0x44, "MiiStoreData has incorrect size.");
-
-struct MiiStoreDataElement {
-    MiiStoreData data{};
-    Source source{};
-};
-static_assert(sizeof(MiiStoreDataElement) == 0x48, "MiiStoreDataElement has incorrect size.");
-
-struct MiiDatabase {
-    u32 magic{}; // 'NFDB'
-    std::array<MiiStoreData, MAX_MIIS> miis{};
-    INSERT_PADDING_BYTES(1);
-    u8 count{};
-    u16 crc{};
-};
-static_assert(sizeof(MiiDatabase) == 0x1A98, "MiiDatabase has incorrect size.");
-#pragma pack(pop)
-
-// The Mii manager is responsible for loading and storing the Miis to the database in NAND along
-// with providing an easy interface for HLE emulation of the mii service.
-class MiiManager {
-public:
-    MiiManager();
-    ~MiiManager();
-
-    MiiInfo CreateRandom(RandomParameters params);
-    MiiInfo CreateDefault(u32 index);
-
-    bool CheckUpdatedFlag() const;
-    void ResetUpdatedFlag();
-
-    bool IsTestModeEnabled() const;
-
-    bool Empty() const;
-    bool Full() const;
-
-    void Clear();
-
-    u32 Size() const;
-
-    MiiInfo GetInfo(u32 index) const;
-    MiiInfoElement GetInfoElement(u32 index) const;
-    MiiStoreData GetStoreData(u32 index) const;
-    MiiStoreDataElement GetStoreDataElement(u32 index) const;
-
-    bool Remove(Common::UUID uuid);
-    u32 IndexOf(Common::UUID uuid) const;
-    u32 IndexOf(const MiiInfo& info) const;
-
-    bool Move(Common::UUID uuid, u32 new_index);
-    bool AddOrReplace(const MiiStoreData& data);
-
-    bool DestroyFile();
-    bool DeleteFile();
-
-private:
-    void WriteToFile();
-    void ReadFromFile();
-
-    MiiStoreData CreateMiiWithUniqueUUID() const;
-
-    void EnsureDatabasePartition();
-
-    MiiDatabase database;
-    bool updated_flag{};
-    bool is_test_mode_enabled{};
-};
-
-}; // namespace Service::Mii

src/core/hle/service/mii/raw_data.h

@@ -0,0 +1,27 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+
+namespace Service::Mii::RawData {
+
+extern const std::array<u8, 1728> DefaultMii;
+extern const std::array<u8, 3672> RandomMiiFaceline;
+extern const std::array<u8, 1200> RandomMiiFacelineColor;
+extern const std::array<u8, 3672> RandomMiiFacelineWrinkle;
+extern const std::array<u8, 3672> RandomMiiFacelineMakeup;
+extern const std::array<u8, 3672> RandomMiiHairType;
+extern const std::array<u8, 1800> RandomMiiHairColor;
+extern const std::array<u8, 3672> RandomMiiEyeType;
+extern const std::array<u8, 588> RandomMiiEyeColor;
+extern const std::array<u8, 3672> RandomMiiEyebrowType;
+extern const std::array<u8, 3672> RandomMiiNoseType;
+extern const std::array<u8, 3672> RandomMiiMouthType;
+extern const std::array<u8, 588> RandomMiiGlassType;
+
+} // namespace Service::Mii::RawData

src/core/hle/service/mii/types.h

@@ -0,0 +1,67 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace Service::Mii {
+
+enum class Age : u32 {
+    Young,
+    Normal,
+    Old,
+    All,
+};
+
+enum class BeardType : u32 {
+    None,
+    Beard1,
+    Beard2,
+    Beard3,
+    Beard4,
+    Beard5,
+};
+
+enum class BeardAndMustacheFlag : u32 { Beard = 1, Mustache, All = Beard | Mustache };
+DECLARE_ENUM_FLAG_OPERATORS(BeardAndMustacheFlag);
+
+enum class FontRegion : u32 {
+    Standard,
+    China,
+    Korea,
+    Taiwan,
+};
+
+enum class Gender : u32 {
+    Male,
+    Female,
+    All,
+    Maximum = Female,
+};
+
+enum class HairFlip : u32 {
+    Left,
+    Right,
+    Maximum = Right,
+};
+
+enum class MustacheType : u32 {
+    None,
+    Mustache1,
+    Mustache2,
+    Mustache3,
+    Mustache4,
+    Mustache5,
+};
+
+enum class Race : u32 {
+    Black,
+    White,
+    Asian,
+    All,
+};
+
+} // namespace Service::Mii

src/core/hle/service/nim/nim.cpp

@@ -121,11 +121,83 @@ public:
             {39, nullptr, "PrepareShutdown"},
             {40, nullptr, "ListApplyDeltaTask"},
             {41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
-            {42, nullptr, "Unknown1"},
-            {43, nullptr, "Unknown2"},
-            {44, nullptr, "Unknown3"},
-            {45, nullptr, "Unknown4"},
-            {46, nullptr, "Unknown5"},
+            {42, nullptr, "Unknown42"},
+            {43, nullptr, "Unknown43"},
+            {44, nullptr, "Unknown44"},
+            {45, nullptr, "Unknown45"},
+            {46, nullptr, "Unknown46"},
+            {47, nullptr, "Unknown47"},
+            {48, nullptr, "Unknown48"},
+            {49, nullptr, "Unknown49"},
+            {50, nullptr, "Unknown50"},
+            {51, nullptr, "Unknown51"},
+            {52, nullptr, "Unknown52"},
+            {53, nullptr, "Unknown53"},
+            {54, nullptr, "Unknown54"},
+            {55, nullptr, "Unknown55"},
+            {56, nullptr, "Unknown56"},
+            {57, nullptr, "Unknown57"},
+            {58, nullptr, "Unknown58"},
+            {59, nullptr, "Unknown59"},
+            {60, nullptr, "Unknown60"},
+            {61, nullptr, "Unknown61"},
+            {62, nullptr, "Unknown62"},
+            {63, nullptr, "Unknown63"},
+            {64, nullptr, "Unknown64"},
+            {65, nullptr, "Unknown65"},
+            {66, nullptr, "Unknown66"},
+            {67, nullptr, "Unknown67"},
+            {68, nullptr, "Unknown68"},
+            {69, nullptr, "Unknown69"},
+            {70, nullptr, "Unknown70"},
+            {71, nullptr, "Unknown71"},
+            {72, nullptr, "Unknown72"},
+            {73, nullptr, "Unknown73"},
+            {74, nullptr, "Unknown74"},
+            {75, nullptr, "Unknown75"},
+            {76, nullptr, "Unknown76"},
+            {77, nullptr, "Unknown77"},
+            {78, nullptr, "Unknown78"},
+            {79, nullptr, "Unknown79"},
+            {80, nullptr, "Unknown80"},
+            {81, nullptr, "Unknown81"},
+            {82, nullptr, "Unknown82"},
+            {83, nullptr, "Unknown83"},
+            {84, nullptr, "Unknown84"},
+            {85, nullptr, "Unknown85"},
+            {86, nullptr, "Unknown86"},
+            {87, nullptr, "Unknown87"},
+            {88, nullptr, "Unknown88"},
+            {89, nullptr, "Unknown89"},
+            {90, nullptr, "Unknown90"},
+            {91, nullptr, "Unknown91"},
+            {92, nullptr, "Unknown92"},
+            {93, nullptr, "Unknown93"},
+            {94, nullptr, "Unknown94"},
+            {95, nullptr, "Unknown95"},
+            {96, nullptr, "Unknown96"},
+            {97, nullptr, "Unknown97"},
+            {98, nullptr, "Unknown98"},
+            {99, nullptr, "Unknown99"},
+            {100, nullptr, "Unknown100"},
+            {101, nullptr, "Unknown101"},
+            {102, nullptr, "Unknown102"},
+            {103, nullptr, "Unknown103"},
+            {104, nullptr, "Unknown104"},
+            {105, nullptr, "Unknown105"},
+            {106, nullptr, "Unknown106"},
+            {107, nullptr, "Unknown107"},
+            {108, nullptr, "Unknown108"},
+            {109, nullptr, "Unknown109"},
+            {110, nullptr, "Unknown110"},
+            {111, nullptr, "Unknown111"},
+            {112, nullptr, "Unknown112"},
+            {113, nullptr, "Unknown113"},
+            {114, nullptr, "Unknown114"},
+            {115, nullptr, "Unknown115"},
+            {116, nullptr, "Unknown116"},
+            {117, nullptr, "Unknown117"},
+            {118, nullptr, "Unknown118"},
         };
         // clang-format on
 
@@ -142,6 +214,7 @@ public:
             {1, nullptr, "RefreshDebugAvailability"},
             {2, nullptr, "ClearDebugResponse"},
             {3, nullptr, "RegisterDebugResponse"},
+            {4, nullptr, "IsLargeResourceAvailable"},
         };
         // clang-format on
 
@@ -164,6 +237,8 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "RequestDeviceAuthenticationToken"},
             {1, nullptr, "RequestCachedDeviceAuthenticationToken"},
+            {2, nullptr, "RequestEdgeToken"},
+            {3, nullptr, "RequestCachedEdgeToken"},
             {100, nullptr, "RequestRegisterDeviceAccount"},
             {101, nullptr, "RequestUnregisterDeviceAccount"},
             {102, nullptr, "RequestDeviceAccountStatus"},
@@ -181,7 +256,8 @@ public:
             {305, nullptr, "RequestCreateVirtualAccount"},
             {306, nullptr, "RequestDeviceLinkStatus"},
             {400, nullptr, "GetAccountByVirtualAccount"},
-            {500, nullptr, "RequestSyncTicket"},
+            {401, nullptr, "GetVirtualAccount"},
+            {500, nullptr, "RequestSyncTicketLegacy"},
             {501, nullptr, "RequestDownloadTicket"},
             {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
             {503, nullptr, "RequestSyncTicket"},

src/core/hle/service/npns/npns.cpp

@@ -30,6 +30,7 @@ public:
             {23, nullptr, "DestroyToken"},
             {24, nullptr, "DestroyTokenWithApplicationId"},
             {25, nullptr, "QueryIsTokenValid"},
+            {26, nullptr, "ListenToMyApplicationId"},
             {31, nullptr, "UploadTokenToBaaS"},
             {32, nullptr, "DestroyTokenForBaaS"},
             {33, nullptr, "CreateTokenForBaaS"},

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

@@ -104,7 +104,7 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {94, nullptr, "LaunchApplication"},
         {95, nullptr, "GetApplicationLaunchInfo"},
         {96, nullptr, "AcquireApplicationLaunchInfo"},
-        {97, nullptr, "GetMainApplicationProgramIndex2"},
+        {97, nullptr, "GetMainApplicationProgramIndexByApplicationLaunchInfo"},
         {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
         {99, nullptr, "LaunchDevMenu"},
         {100, nullptr, "ResetToFactorySettings"},
@@ -254,7 +254,7 @@ IApplicationManagerInterface::IApplicationManagerInterface()
         {2170, nullptr, "GetRightsEnvironmentStatus"},
         {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
         {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
-        {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
+        {2181, nullptr, "GetResultOfExtendRightsInRightsEnvironment"},
         {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
         {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
         {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
@@ -366,7 +366,8 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
     LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
 
     // Get language code from settings
-    const auto language_code = Set::GetLanguageCodeFromIndex(Settings::values.language_index);
+    const auto language_code =
+        Set::GetLanguageCodeFromIndex(Settings::values.language_index.GetValue());
 
     // Convert to application language, get priority list
     const auto application_language = ConvertToApplicationLanguage(language_code);
@@ -445,8 +446,8 @@ IApplicationVersionInterface::IApplicationVersionInterface()
 
 IApplicationVersionInterface::~IApplicationVersionInterface() = default;
 
-IContentManagerInterface::IContentManagerInterface()
-    : ServiceFramework{"IContentManagerInterface"} {
+IContentManagementInterface::IContentManagementInterface()
+    : ServiceFramework{"IContentManagementInterface"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {11, nullptr, "CalculateApplicationOccupiedSize"},
@@ -463,7 +464,7 @@ IContentManagerInterface::IContentManagerInterface()
     RegisterHandlers(functions);
 }
 
-IContentManagerInterface::~IContentManagerInterface() = default;
+IContentManagementInterface::~IContentManagementInterface() = default;
 
 IDocumentInterface::IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
     // clang-format off
@@ -545,7 +546,7 @@ NS::NS(const char* name) : ServiceFramework{name} {
         {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
         {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
         {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
-        {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
+        {7998, &NS::PushInterface<IContentManagementInterface>, "GetContentManagementInterface"},
         {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
     };
     // clang-format on
@@ -572,9 +573,9 @@ public:
             {6, nullptr, "TerminateApplication"},
             {7, nullptr, "PrepareLaunchProgramFromHost"},
             {8, nullptr, "LaunchApplication"},
-            {9, nullptr, "LaunchApplicationWithStorageId"},
-            {10, nullptr, "TerminateApplication2"},
-            {11, nullptr, "GetRunningApplicationProcessId"},
+            {9, nullptr, "LaunchApplicationWithStorageIdForDevelop"},
+            {10, nullptr, "IsSystemMemoryResourceLimitBoosted"},
+            {11, nullptr, "GetRunningApplicationProcessIdForDevelop"},
             {12, nullptr, "SetCurrentApplicationRightsEnvironmentCanBeActive"},
             {13, nullptr, "CreateApplicationResourceForDevelop"},
             {14, nullptr, "IsPreomiaForDevelop"},
@@ -636,6 +637,10 @@ public:
             {9, nullptr, "GetSystemUpdateNotificationEventForContentDelivery"},
             {10, nullptr, "NotifySystemUpdateForContentDelivery"},
             {11, nullptr, "PrepareShutdown"},
+            {12, nullptr, "Unknown12"},
+            {13, nullptr, "Unknown13"},
+            {14, nullptr, "Unknown14"},
+            {15, nullptr, "Unknown15"},
             {16, nullptr, "DestroySystemUpdateTask"},
             {17, nullptr, "RequestSendSystemUpdate"},
             {18, nullptr, "GetSendSystemUpdateProgress"},

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

@@ -40,10 +40,10 @@ public:
     ~IApplicationVersionInterface() override;
 };
 
-class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
+class IContentManagementInterface final : public ServiceFramework<IContentManagementInterface> {
 public:
-    explicit IContentManagerInterface();
-    ~IContentManagerInterface() override;
+    explicit IContentManagementInterface();
+    ~IContentManagementInterface() override;
 };
 
 class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {

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

@@ -163,7 +163,7 @@ PL_U::PL_U(Core::System& system)
         {5, &PL_U::GetSharedFontInOrderOfPriority, "GetSharedFontInOrderOfPriority"},
         {6, nullptr, "GetSharedFontInOrderOfPriorityForSystem"},
         {100, nullptr, "RequestApplicationFunctionAuthorization"},
-        {101, nullptr, "RequestApplicationFunctionAuthorizationForSystem"},
+        {101, nullptr, "RequestApplicationFunctionAuthorizationByProcessId"},
         {102, nullptr, "RequestApplicationFunctionAuthorizationByApplicationId"},
         {1000, nullptr, "LoadNgWordDataForPlatformRegionChina"},
         {1001, nullptr, "GetNgWordDataSizeForPlatformRegionChina"},

src/core/hle/service/nvdrv/interface.cpp

@@ -144,7 +144,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
     }
 }
 
-void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
+void NVDRV::SetAruid(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     pid = rp.Pop<u64>();
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, pid=0x{:X}", pid);
@@ -154,7 +154,7 @@ void NVDRV::SetClientPID(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(0);
 }
 
-void NVDRV::FinishInitialize(Kernel::HLERequestContext& ctx) {
+void NVDRV::SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
@@ -187,13 +187,14 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
         {4, &NVDRV::QueryEvent, "QueryEvent"},
         {5, nullptr, "MapSharedMem"},
         {6, &NVDRV::GetStatus, "GetStatus"},
-        {7, nullptr, "ForceSetClientPID"},
-        {8, &NVDRV::SetClientPID, "SetClientPID"},
+        {7, nullptr, "SetAruidForTest"},
+        {8, &NVDRV::SetAruid, "SetAruid"},
         {9, &NVDRV::DumpGraphicsMemoryInfo, "DumpGraphicsMemoryInfo"},
         {10, nullptr, "InitializeDevtools"},
         {11, &NVDRV::Ioctl2, "Ioctl2"},
         {12, &NVDRV::Ioctl3, "Ioctl3"},
-        {13, &NVDRV::FinishInitialize, "FinishInitialize"},
+        {13, &NVDRV::SetGraphicsFirmwareMemoryMarginEnabled,
+         "SetGraphicsFirmwareMemoryMarginEnabled"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/nvdrv/interface.h

@@ -29,8 +29,8 @@ private:
     void Close(Kernel::HLERequestContext& ctx);
     void Initialize(Kernel::HLERequestContext& ctx);
     void QueryEvent(Kernel::HLERequestContext& ctx);
-    void SetClientPID(Kernel::HLERequestContext& ctx);
-    void FinishInitialize(Kernel::HLERequestContext& ctx);
+    void SetAruid(Kernel::HLERequestContext& ctx);
+    void SetGraphicsFirmwareMemoryMarginEnabled(Kernel::HLERequestContext& ctx);
     void GetStatus(Kernel::HLERequestContext& ctx);
     void DumpGraphicsMemoryInfo(Kernel::HLERequestContext& ctx);
     void IoctlBase(Kernel::HLERequestContext& ctx, IoctlVersion version);

src/core/hle/service/nvdrv/nvmemp.cpp

@@ -10,19 +10,19 @@ namespace Service::Nvidia {
 
 NVMEMP::NVMEMP() : ServiceFramework("nvmemp") {
     static const FunctionInfo functions[] = {
-        {0, &NVMEMP::Cmd0, "Cmd0"},
-        {1, &NVMEMP::Cmd1, "Cmd1"},
+        {0, &NVMEMP::Open, "Open"},
+        {1, &NVMEMP::GetAruid, "GetAruid"},
     };
     RegisterHandlers(functions);
 }
 
 NVMEMP::~NVMEMP() = default;
 
-void NVMEMP::Cmd0(Kernel::HLERequestContext& ctx) {
+void NVMEMP::Open(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 
-void NVMEMP::Cmd1(Kernel::HLERequestContext& ctx) {
+void NVMEMP::GetAruid(Kernel::HLERequestContext& ctx) {
     UNIMPLEMENTED();
 }
 

src/core/hle/service/nvdrv/nvmemp.h

@@ -14,8 +14,8 @@ public:
     ~NVMEMP() override;
 
 private:
-    void Cmd0(Kernel::HLERequestContext& ctx);
-    void Cmd1(Kernel::HLERequestContext& ctx);
+    void Open(Kernel::HLERequestContext& ctx);
+    void GetAruid(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -28,8 +28,7 @@
 
 namespace Service::NVFlinger {
 
-constexpr s64 frame_ticks = static_cast<s64>(1000000000 / 60);
-constexpr s64 frame_ticks_30fps = static_cast<s64>(1000000000 / 30);
+constexpr auto frame_ns = std::chrono::nanoseconds{1000000000 / 60};
 
 void NVFlinger::VSyncThread(NVFlinger& nv_flinger) {
     nv_flinger.SplitVSync();
@@ -67,20 +66,24 @@ NVFlinger::NVFlinger(Core::System& system) : system(system) {
     guard = std::make_shared<std::mutex>();
 
     // Schedule the screen composition events
-    composition_event =
-        Core::Timing::CreateEvent("ScreenComposition", [this](u64 userdata, s64 ns_late) {
+    composition_event = Core::Timing::CreateEvent(
+        "ScreenComposition", [this](u64, std::chrono::nanoseconds ns_late) {
             Lock();
             Compose();
-            const auto ticks = GetNextTicks();
-            this->system.CoreTiming().ScheduleEvent(std::max<s64>(0LL, ticks - ns_late),
-                                                    composition_event);
+
+            const auto ticks = std::chrono::nanoseconds{GetNextTicks()};
+            const auto ticks_delta = ticks - ns_late;
+            const auto future_ns = std::max(std::chrono::nanoseconds::zero(), ticks_delta);
+
+            this->system.CoreTiming().ScheduleEvent(future_ns, composition_event);
         });
+
     if (system.IsMulticore()) {
         is_running = true;
         wait_event = std::make_unique<Common::Event>();
         vsync_thread = std::make_unique<std::thread>(VSyncThread, std::ref(*this));
     } else {
-        system.CoreTiming().ScheduleEvent(frame_ticks, composition_event);
+        system.CoreTiming().ScheduleEvent(frame_ns, composition_event);
     }
 }
 

src/core/hle/service/pcie/pcie.cpp

@@ -36,6 +36,9 @@ public:
             {18, nullptr, "ReleaseIrq"},
             {19, nullptr, "SetIrqEnable"},
             {20, nullptr, "SetAspmEnable"},
+            {21, nullptr, "SetResetUponResumeEnable"},
+            {22, nullptr, "Unknown22"},
+            {23, nullptr, "Unknown23"},
         };
         // clang-format on
 

src/core/hle/service/pcv/pcv.cpp

@@ -42,6 +42,9 @@ public:
             {24, nullptr, "GetModuleStateTable"},
             {25, nullptr, "GetPowerDomainStateTable"},
             {26, nullptr, "GetFuseInfo"},
+            {27, nullptr, "GetDramId"},
+            {28, nullptr, "IsPoweredOn"},
+            {29, nullptr, "GetVoltage"},
         };
         // clang-format on
 

src/core/hle/service/pm/pm.cpp

@@ -78,13 +78,13 @@ public:
         : ServiceFramework{"pm:dmnt"}, kernel(kernel) {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetDebugProcesses"},
-            {1, nullptr, "StartDebugProcess"},
-            {2, &DebugMonitor::GetTitlePid, "GetTitlePid"},
-            {3, nullptr, "EnableDebugForTitleId"},
-            {4, &DebugMonitor::GetApplicationPid, "GetApplicationPid"},
-            {5, nullptr, "EnableDebugForApplication"},
-            {6, nullptr, "DisableDebug"},
+            {0, nullptr, "GetJitDebugProcessIdList"},
+            {1, nullptr, "StartProcess"},
+            {2, &DebugMonitor::GetProcessId, "GetProcessId"},
+            {3, nullptr, "HookToCreateProcess"},
+            {4, &DebugMonitor::GetApplicationProcessId, "GetApplicationProcessId"},
+            {5, nullptr, "HookToCreateApplicationProgress"},
+            {6, nullptr, "ClearHook"},
         };
         // clang-format on
 
@@ -92,7 +92,7 @@ public:
     }
 
 private:
-    void GetTitlePid(Kernel::HLERequestContext& ctx) {
+    void GetProcessId(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto title_id = rp.PopRaw<u64>();
 
@@ -114,7 +114,7 @@ private:
         rb.Push((*process)->GetProcessID());
     }
 
-    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
+    void GetApplicationProcessId(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_PM, "called");
         GetApplicationPidGeneric(ctx, kernel.GetProcessList());
     }
@@ -163,15 +163,15 @@ public:
         : ServiceFramework{"pm:shell"}, kernel(kernel) {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "LaunchProcess"},
-            {1, nullptr, "TerminateProcessByPid"},
-            {2, nullptr, "TerminateProcessByTitleId"},
-            {3, nullptr, "GetProcessEventWaiter"},
-            {4, nullptr, "GetProcessEventType"},
+            {0, nullptr, "LaunchProgram"},
+            {1, nullptr, "TerminateProcess"},
+            {2, nullptr, "TerminateProgram"},
+            {3, nullptr, "GetProcessEventHandle"},
+            {4, nullptr, "GetProcessEventInfo"},
             {5, nullptr, "NotifyBootFinished"},
-            {6, &Shell::GetApplicationPid, "GetApplicationPid"},
+            {6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
             {7, nullptr, "BoostSystemMemoryResourceLimit"},
-            {8, nullptr, "EnableAdditionalSystemThreads"},
+            {8, nullptr, "BoostApplicationThreadResourceLimit"},
             {9, nullptr, "GetBootFinishedEventHandle"},
         };
         // clang-format on
@@ -180,7 +180,7 @@ public:
     }
 
 private:
-    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
+    void GetApplicationProcessIdForShell(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_PM, "called");
         GetApplicationPidGeneric(ctx, kernel.GetProcessList());
     }

src/core/hle/service/prepo/prepo.cpp

@@ -42,6 +42,11 @@ public:
             {40101, nullptr, "SetUserAgreementCheckEnabled"},
             {50100, nullptr, "ReadAllApplicationReportFiles"},
             {90100, nullptr, "ReadAllReportFiles"},
+            {90101, nullptr, "Unknown90101"},
+            {90102, nullptr, "Unknown90102"},
+            {90200, nullptr, "GetStatistics"},
+            {90201, nullptr, "GetThroughputHistory"},
+            {90300, nullptr, "GetLastUploadError"},
         };
         // clang-format on
 

src/core/hle/service/psc/psc.cpp

@@ -24,6 +24,8 @@ public:
             {4, nullptr, "Cancel"},
             {5, nullptr, "PrintModuleInformation"},
             {6, nullptr, "GetModuleInformation"},
+            {10, nullptr, "Unknown10"},
+            {11, nullptr, "Unknown11"},
         };
         // clang-format on
 

src/core/hle/service/ptm/psm.cpp

@@ -35,6 +35,7 @@ public:
             {15, nullptr, "GetBatteryAgePercentage"},
             {16, nullptr, "GetBatteryChargeInfoEvent"},
             {17, nullptr, "GetBatteryChargeInfoFields"},
+            {18, nullptr, "GetBatteryChargeCalibratedEvent"},
         };
         // clang-format on
 

src/core/hle/service/set/set.cpp

@@ -91,7 +91,7 @@ void GetAvailableLanguageCodesImpl(Kernel::HLERequestContext& ctx, std::size_t m
 }
 
 void GetKeyCodeMapImpl(Kernel::HLERequestContext& ctx) {
-    const auto language_code = available_language_codes[Settings::values.language_index];
+    const auto language_code = available_language_codes[Settings::values.language_index.GetValue()];
     const auto key_code =
         std::find_if(language_to_layout.cbegin(), language_to_layout.cend(),
                      [=](const auto& element) { return element.first == language_code; });
@@ -99,7 +99,7 @@ void GetKeyCodeMapImpl(Kernel::HLERequestContext& ctx) {
     if (key_code == language_to_layout.cend()) {
         LOG_ERROR(Service_SET,
                   "Could not find keyboard layout for language index {}, defaulting to English us",
-                  Settings::values.language_index);
+                  Settings::values.language_index.GetValue());
     } else {
         layout = key_code->second;
     }
@@ -163,11 +163,11 @@ void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {
 }
 
 void SET::GetLanguageCode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index);
+    LOG_DEBUG(Service_SET, "called {}", Settings::values.language_index.GetValue());
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(available_language_codes[Settings::values.language_index]);
+    rb.PushEnum(available_language_codes[Settings::values.language_index.GetValue()]);
 }
 
 void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {
@@ -175,7 +175,7 @@ void SET::GetRegionCode(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(Settings::values.region_index);
+    rb.Push(Settings::values.region_index.GetValue());
 }
 
 void SET::GetKeyCodeMap(Kernel::HLERequestContext& ctx) {

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

@@ -12,7 +12,7 @@
 
 namespace Service::SM {
 
-void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
+void Controller::ConvertCurrentObjectToDomain(Kernel::HLERequestContext& ctx) {
     ASSERT_MSG(ctx.Session()->IsSession(), "Session is already a domain");
     LOG_DEBUG(Service, "called, server_session={}", ctx.Session()->GetObjectId());
     ctx.Session()->ConvertToDomain();
@@ -22,7 +22,7 @@ void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(1); // Converted sessions start with 1 request handler
 }
 
-void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
+void Controller::CloneCurrentObject(Kernel::HLERequestContext& ctx) {
     // TODO(bunnei): This is just creating a new handle to the same Session. I assume this is wrong
     // and that we probably want to actually make an entirely new Session, but we still need to
     // verify this on hardware.
@@ -33,10 +33,10 @@ void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
     rb.PushMoveObjects(ctx.Session()->GetParent()->Client());
 }
 
-void Controller::DuplicateSessionEx(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called, using DuplicateSession");
+void Controller::CloneCurrentObjectEx(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service, "(STUBBED) called, using CloneCurrentObject");
 
-    DuplicateSession(ctx);
+    CloneCurrentObject(ctx);
 }
 
 void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
@@ -47,13 +47,14 @@ void Controller::QueryPointerBufferSize(Kernel::HLERequestContext& ctx) {
     rb.Push<u16>(0x1000);
 }
 
+// https://switchbrew.org/wiki/IPC_Marshalling
 Controller::Controller() : ServiceFramework("IpcController") {
     static const FunctionInfo functions[] = {
-        {0x00000000, &Controller::ConvertSessionToDomain, "ConvertSessionToDomain"},
-        {0x00000001, nullptr, "ConvertDomainToSession"},
-        {0x00000002, &Controller::DuplicateSession, "DuplicateSession"},
-        {0x00000003, &Controller::QueryPointerBufferSize, "QueryPointerBufferSize"},
-        {0x00000004, &Controller::DuplicateSessionEx, "DuplicateSessionEx"},
+        {0, &Controller::ConvertCurrentObjectToDomain, "ConvertCurrentObjectToDomain"},
+        {1, nullptr, "CopyFromCurrentDomain"},
+        {2, &Controller::CloneCurrentObject, "CloneCurrentObject"},
+        {3, &Controller::QueryPointerBufferSize, "QueryPointerBufferSize"},
+        {4, &Controller::CloneCurrentObjectEx, "CloneCurrentObjectEx"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/sm/controller.h

@@ -14,9 +14,9 @@ public:
     ~Controller() override;
 
 private:
-    void ConvertSessionToDomain(Kernel::HLERequestContext& ctx);
-    void DuplicateSession(Kernel::HLERequestContext& ctx);
-    void DuplicateSessionEx(Kernel::HLERequestContext& ctx);
+    void ConvertCurrentObjectToDomain(Kernel::HLERequestContext& ctx);
+    void CloneCurrentObject(Kernel::HLERequestContext& ctx);
+    void CloneCurrentObjectEx(Kernel::HLERequestContext& ctx);
     void QueryPointerBufferSize(Kernel::HLERequestContext& ctx);
 };
 

src/core/hle/service/sockets/nsd.cpp

@@ -14,6 +14,7 @@ NSD::NSD(const char* name) : ServiceFramework(name) {
         {12, nullptr, "GetDeviceId"},
         {13, nullptr, "DeleteSettings"},
         {14, nullptr, "ImportSettings"},
+        {15, nullptr, "SetChangeEnvironmentIdentifierDisabled"},
         {20, nullptr, "Resolve"},
         {21, nullptr, "ResolveEx"},
         {30, nullptr, "GetNasServiceSetting"},
@@ -28,6 +29,11 @@ NSD::NSD(const char* name) : ServiceFramework(name) {
         {60, nullptr, "ReadSaveDataFromFsForTest"},
         {61, nullptr, "WriteSaveDataToFsForTest"},
         {62, nullptr, "DeleteSaveDataOfFsForTest"},
+        {63, nullptr, "IsChangeEnvironmentIdentifierDisabled"},
+        {64, nullptr, "SetWithoutDomainExchangeFqdns"},
+        {100, nullptr, "GetApplicationServerEnvironmentType"},
+        {101, nullptr, "SetApplicationServerEnvironmentType"},
+        {102, nullptr, "DeleteApplicationServerEnvironmentType"},
     };
     // clang-format on
 

src/core/hle/service/sockets/sfdnsres.cpp

@@ -7,7 +7,7 @@
 
 namespace Service::Sockets {
 
-void SFDNSRES::GetAddrInfo(Kernel::HLERequestContext& ctx) {
+void SFDNSRES::GetAddrInfoRequest(Kernel::HLERequestContext& ctx) {
     struct Parameters {
         u8 use_nsd_resolve;
         u32 unknown;
@@ -29,15 +29,20 @@ SFDNSRES::SFDNSRES() : ServiceFramework("sfdnsres") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "SetDnsAddressesPrivate"},
         {1, nullptr, "GetDnsAddressPrivate"},
-        {2, nullptr, "GetHostByName"},
-        {3, nullptr, "GetHostByAddr"},
-        {4, nullptr, "GetHostStringError"},
-        {5, nullptr, "GetGaiStringError"},
-        {6, &SFDNSRES::GetAddrInfo, "GetAddrInfo"},
-        {7, nullptr, "GetNameInfo"},
-        {8, nullptr, "RequestCancelHandle"},
-        {9, nullptr, "CancelSocketCall"},
-        {11, nullptr, "ClearDnsIpServerAddressArray"},
+        {2, nullptr, "GetHostByNameRequest"},
+        {3, nullptr, "GetHostByAddrRequest"},
+        {4, nullptr, "GetHostStringErrorRequest"},
+        {5, nullptr, "GetGaiStringErrorRequest"},
+        {6, &SFDNSRES::GetAddrInfoRequest, "GetAddrInfoRequest"},
+        {7, nullptr, "GetNameInfoRequest"},
+        {8, nullptr, "RequestCancelHandleRequest"},
+        {9, nullptr, "CancelRequest"},
+        {10, nullptr, "GetHostByNameRequestWithOptions"},
+        {11, nullptr, "GetHostByAddrRequestWithOptions"},
+        {12, nullptr, "GetAddrInfoRequestWithOptions"},
+        {13, nullptr, "GetNameInfoRequestWithOptions"},
+        {14, nullptr, "ResolverSetOptionRequest"},
+        {15, nullptr, "ResolverGetOptionRequest"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/sockets/sfdnsres.h

@@ -15,7 +15,7 @@ public:
     ~SFDNSRES() override;
 
 private:
-    void GetAddrInfo(Kernel::HLERequestContext& ctx);
+    void GetAddrInfoRequest(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Sockets

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

@@ -19,7 +19,7 @@ namespace Service::SPL {
 
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)),
-      rng(Settings::values.rng_seed.value_or(std::time(nullptr))) {}
+      rng(Settings::values.rng_seed.GetValue().value_or(std::time(nullptr))) {}
 
 Module::Interface::~Interface() = default;
 

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

@@ -9,35 +9,36 @@ namespace Service::SPL {
 SPL::SPL(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "spl:") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetConfig"},
-        {1, nullptr, "UserExpMod"},
+        {1, nullptr, "ModularExponentiate"},
         {2, nullptr, "GenerateAesKek"},
         {3, nullptr, "LoadAesKey"},
         {4, nullptr, "GenerateAesKey"},
         {5, nullptr, "SetConfig"},
         {7, &SPL::GetRandomBytes, "GetRandomBytes"},
-        {9, nullptr, "LoadSecureExpModKey"},
-        {10, nullptr, "SecureExpMod"},
+        {9, nullptr, "ImportLotusKey"},
+        {10, nullptr, "DecryptLotusMessage"},
         {11, nullptr, "IsDevelopment"},
         {12, nullptr, "GenerateSpecificAesKey"},
-        {13, nullptr, "DecryptPrivk"},
+        {13, nullptr, "DecryptDeviceUniqueData"},
         {14, nullptr, "DecryptAesKey"},
-        {15, nullptr, "DecryptAesCtr"},
+        {15, nullptr, "CryptAesCtr"},
         {16, nullptr, "ComputeCmac"},
-        {17, nullptr, "LoadRsaOaepKey"},
-        {18, nullptr, "UnwrapRsaOaepWrappedTitleKey"},
+        {17, nullptr, "ImportEsKey"},
+        {18, nullptr, "UnwrapTitleKey"},
         {19, nullptr, "LoadTitleKey"},
-        {20, nullptr, "UnwrapAesWrappedTitleKey"},
-        {21, nullptr, "LockAesEngine"},
-        {22, nullptr, "UnlockAesEngine"},
-        {23, nullptr, "GetSplWaitEvent"},
-        {24, nullptr, "SetSharedData"},
-        {25, nullptr, "GetSharedData"},
-        {26, nullptr, "ImportSslRsaKey"},
-        {27, nullptr, "SecureExpModWithSslKey"},
-        {28, nullptr, "ImportEsRsaKey"},
-        {29, nullptr, "SecureExpModWithEsKey"},
-        {30, nullptr, "EncryptManuRsaKeyForImport"},
-        {31, nullptr, "GetPackage2Hash"},
+        {20, nullptr, "PrepareEsCommonKey"},
+        {21, nullptr, "AllocateAesKeyslot"},
+        {22, nullptr, "DeallocateAesKeySlot"},
+        {23, nullptr, "GetAesKeyslotAvailableEvent"},
+        {24, nullptr, "SetBootReason"},
+        {25, nullptr, "GetBootReason"},
+        {26, nullptr, "DecryptAndStoreSslClientCertKey"},
+        {27, nullptr, "ModularExponentiateWithSslClientCertKey"},
+        {28, nullptr, "DecryptAndStoreDrmDeviceCertKey"},
+        {29, nullptr, "ModularExponentiateWithDrmDeviceCertKey"},
+        {30, nullptr, "ReencryptDeviceUniqueData "},
+        {31, nullptr, "PrepareEsArchiveKey"}, // This is also GetPackage2Hash?
+        {32, nullptr, "LoadPreparedAesKey"},
     };
     RegisterHandlers(functions);
 }

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

@@ -90,6 +90,13 @@ public:
         : ServiceFramework("ISteadyClock"), clock_core{clock_core}, system{system} {
         static const FunctionInfo functions[] = {
             {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
+            {2, nullptr, "GetTestOffset"},
+            {3, nullptr, "SetTestOffset"},
+            {100, nullptr, "GetRtcValue"},
+            {101, nullptr, "IsRtcResetDetected"},
+            {102, nullptr, "GetSetupResultValue"},
+            {200, nullptr, "GetInternalOffset"},
+            {201, nullptr, "SetInternalOffset"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/usb/usb.cpp

@@ -20,7 +20,7 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetDsEndpoint"},
             {1, nullptr, "GetSetupEvent"},
-            {2, nullptr, "Unknown"},
+            {2, nullptr, "Unknown2"},
             {3, nullptr, "EnableInterface"},
             {4, nullptr, "DisableInterface"},
             {5, nullptr, "CtrlInPostBufferAsync"},
@@ -55,6 +55,7 @@ public:
             {9, nullptr, "SetBinaryObjectStore"},
             {10, nullptr, "Enable"},
             {11, nullptr, "Disable"},
+            {12, nullptr, "Unknown12"},
         };
         // clang-format on
 
@@ -69,13 +70,13 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "Open"},
             {1, nullptr, "Close"},
-            {2, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
             {3, nullptr, "Populate"},
             {4, nullptr, "PostBufferAsync"},
             {5, nullptr, "GetXferReport"},
             {6, nullptr, "PostBufferMultiAsync"},
-            {7, nullptr, "Unknown3"},
-            {8, nullptr, "Unknown4"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
         };
         // clang-format on
 
@@ -88,13 +89,13 @@ public:
     explicit IClientIfSession() : ServiceFramework{"IClientIfSession"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
+            {0, nullptr, "Unknown0"},
             {1, nullptr, "SetInterface"},
             {2, nullptr, "GetInterface"},
             {3, nullptr, "GetAlternateInterface"},
             {4, nullptr, "GetCurrentFrame"},
             {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown2"},
+            {6, nullptr, "Unknown6"},
             {7, nullptr, "GetCtrlXferReport"},
             {8, nullptr, "ResetDevice"},
             {9, nullptr, "OpenUsbEp"},
@@ -118,7 +119,7 @@ public:
             {5, nullptr, "DestroyInterfaceAvailableEvent"},
             {6, nullptr, "GetInterfaceStateChangeEvent"},
             {7, nullptr, "AcquireUsbIf"},
-            {8, nullptr, "Unknown1"},
+            {8, nullptr, "Unknown8"},
         };
         // clang-format on
 
@@ -179,8 +180,8 @@ public:
             {4, nullptr, "GetFwRevision"},
             {5, nullptr, "GetManufacturerId"},
             {6, nullptr, "GetDeviceId"},
-            {7, nullptr, "Unknown1"},
-            {8, nullptr, "Unknown2"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
         };
         // clang-format on
 
@@ -215,12 +216,12 @@ public:
     explicit USB_PM() : ServiceFramework{"usb:pm"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "Unknown6"},
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
         };
         // clang-format on
 

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

@@ -519,9 +519,9 @@ private:
             IGBPConnectRequestParcel request{ctx.ReadBuffer()};
             IGBPConnectResponseParcel response{
                 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
-                                 Settings::values.resolution_factor),
+                                 Settings::values.resolution_factor.GetValue()),
                 static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
-                                 Settings::values.resolution_factor)};
+                                 Settings::values.resolution_factor.GetValue())};
             ctx.WriteBuffer(response.Serialize());
             break;
         }
@@ -700,6 +700,7 @@ public:
             {3215, nullptr, "SetDisplayGamma"},
             {3216, nullptr, "GetDisplayCmuLuma"},
             {3217, nullptr, "SetDisplayCmuLuma"},
+            {6013, nullptr, "GetLayerPresentationSubmissionTimestamps"},
             {8225, nullptr, "GetSharedBufferMemoryHandleId"},
             {8250, nullptr, "OpenSharedLayer"},
             {8251, nullptr, "CloseSharedLayer"},
@@ -748,14 +749,14 @@ private:
 
         if (Settings::values.use_docked_mode) {
             rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
             rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
         } else {
             rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
             rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
-                    static_cast<u32>(Settings::values.resolution_factor));
+                    static_cast<u32>(Settings::values.resolution_factor.GetValue()));
         }
 
         rb.PushRaw<float>(60.0f); // This wouldn't seem to be correct for 30 fps games.
@@ -785,6 +786,7 @@ public:
             {2300, nullptr, "AcquireLayerTexturePresentingEvent"},
             {2301, nullptr, "ReleaseLayerTexturePresentingEvent"},
             {2302, nullptr, "GetDisplayHotplugEvent"},
+            {2303, nullptr, "GetDisplayModeChangedEvent"},
             {2402, nullptr, "GetDisplayHotplugState"},
             {2501, nullptr, "GetCompositorErrorInfo"},
             {2601, nullptr, "GetDisplayErrorEvent"},
@@ -1029,9 +1031,9 @@ private:
         // between docked and undocked dimensions. We take the liberty of applying
         // the resolution scaling factor here.
         rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
         rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
-                static_cast<u32>(Settings::values.resolution_factor));
+                static_cast<u32>(Settings::values.resolution_factor.GetValue()));
     }
 
     void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
@@ -1064,8 +1066,8 @@ private:
         LOG_WARNING(Service_VI, "(STUBBED) called");
 
         DisplayInfo display_info;
-        display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
-        display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
+        display_info.width *= static_cast<u64>(Settings::values.resolution_factor.GetValue());
+        display_info.height *= static_cast<u64>(Settings::values.resolution_factor.GetValue());
         ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);

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

@@ -12,6 +12,7 @@ VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
     : ServiceFramework{"vi:u"}, nv_flinger{std::move(nv_flinger)} {
     static const FunctionInfo functions[] = {
         {0, &VI_U::GetDisplayService, "GetDisplayService"},
+        {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/wlan/wlan.cpp

@@ -15,34 +15,37 @@ public:
     explicit WLANInfra() : ServiceFramework{"wlan:inf"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
+            {0, nullptr, "OpenMode"},
+            {1, nullptr, "CloseMode"},
             {2, nullptr, "GetMacAddress"},
             {3, nullptr, "StartScan"},
             {4, nullptr, "StopScan"},
             {5, nullptr, "Connect"},
             {6, nullptr, "CancelConnect"},
             {7, nullptr, "Disconnect"},
-            {8, nullptr, "Unknown3"},
-            {9, nullptr, "Unknown4"},
+            {8, nullptr, "GetConnectionEvent"},
+            {9, nullptr, "GetConnectionStatus"},
             {10, nullptr, "GetState"},
             {11, nullptr, "GetScanResult"},
             {12, nullptr, "GetRssi"},
             {13, nullptr, "ChangeRxAntenna"},
-            {14, nullptr, "Unknown5"},
-            {15, nullptr, "Unknown6"},
+            {14, nullptr, "GetFwVersion"},
+            {15, nullptr, "RequestSleep"},
             {16, nullptr, "RequestWakeUp"},
             {17, nullptr, "RequestIfUpDown"},
-            {18, nullptr, "Unknown7"},
-            {19, nullptr, "Unknown8"},
-            {20, nullptr, "Unknown9"},
-            {21, nullptr, "Unknown10"},
-            {22, nullptr, "Unknown11"},
-            {23, nullptr, "Unknown12"},
-            {24, nullptr, "Unknown13"},
-            {25, nullptr, "Unknown14"},
-            {26, nullptr, "Unknown15"},
-            {27, nullptr, "Unknown16"},
+            {18, nullptr, "Unknown18"},
+            {19, nullptr, "Unknown19"},
+            {20, nullptr, "Unknown20"},
+            {21, nullptr, "Unknown21"},
+            {22, nullptr, "Unknown22"},
+            {23, nullptr, "Unknown23"},
+            {24, nullptr, "Unknown24"},
+            {25, nullptr, "Unknown25"},
+            {26, nullptr, "Unknown26"},
+            {27, nullptr, "Unknown27"},
+            {28, nullptr, "Unknown28"},
+            {29, nullptr, "Unknown29"},
+            {30, nullptr, "Unknown30"},
         };
         // clang-format on
 
@@ -55,12 +58,12 @@ public:
     explicit WLANLocal() : ServiceFramework{"wlan:lcl"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "Unknown6"},
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
             {6, nullptr, "GetMacAddress"},
             {7, nullptr, "CreateBss"},
             {8, nullptr, "DestroyBss"},
@@ -72,38 +75,42 @@ public:
             {14, nullptr, "CancelJoin"},
             {15, nullptr, "Disconnect"},
             {16, nullptr, "SetBeaconLostCount"},
-            {17, nullptr, "Unknown7"},
-            {18, nullptr, "Unknown8"},
-            {19, nullptr, "Unknown9"},
+            {17, nullptr, "Unknown17"},
+            {18, nullptr, "Unknown18"},
+            {19, nullptr, "Unknown19"},
             {20, nullptr, "GetBssIndicationEvent"},
             {21, nullptr, "GetBssIndicationInfo"},
             {22, nullptr, "GetState"},
             {23, nullptr, "GetAllowedChannels"},
             {24, nullptr, "AddIe"},
             {25, nullptr, "DeleteIe"},
-            {26, nullptr, "Unknown10"},
-            {27, nullptr, "Unknown11"},
+            {26, nullptr, "Unknown26"},
+            {27, nullptr, "Unknown27"},
             {28, nullptr, "CreateRxEntry"},
             {29, nullptr, "DeleteRxEntry"},
-            {30, nullptr, "Unknown12"},
-            {31, nullptr, "Unknown13"},
+            {30, nullptr, "Unknown30"},
+            {31, nullptr, "Unknown31"},
             {32, nullptr, "AddMatchingDataToRxEntry"},
             {33, nullptr, "RemoveMatchingDataFromRxEntry"},
             {34, nullptr, "GetScanResult"},
-            {35, nullptr, "Unknown14"},
+            {35, nullptr, "Unknown35"},
             {36, nullptr, "SetActionFrameWithBeacon"},
             {37, nullptr, "CancelActionFrameWithBeacon"},
             {38, nullptr, "CreateRxEntryForActionFrame"},
             {39, nullptr, "DeleteRxEntryForActionFrame"},
-            {40, nullptr, "Unknown15"},
-            {41, nullptr, "Unknown16"},
+            {40, nullptr, "Unknown40"},
+            {41, nullptr, "Unknown41"},
             {42, nullptr, "CancelGetActionFrame"},
             {43, nullptr, "GetRssi"},
-            {44, nullptr, "Unknown17"},
-            {45, nullptr, "Unknown18"},
-            {46, nullptr, "Unknown19"},
-            {47, nullptr, "Unknown20"},
-            {48, nullptr, "Unknown21"},
+            {44, nullptr, "Unknown44"},
+            {45, nullptr, "Unknown45"},
+            {46, nullptr, "Unknown46"},
+            {47, nullptr, "Unknown47"},
+            {48, nullptr, "Unknown48"},
+            {49, nullptr, "Unknown49"},
+            {50, nullptr, "Unknown50"},
+            {51, nullptr, "Unknown51"},
+            {52, nullptr, "Unknown52"},
         };
         // clang-format on
 
@@ -142,18 +149,19 @@ public:
     explicit WLANSocketManager() : ServiceFramework{"wlan:soc"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Unknown1"},
-            {1, nullptr, "Unknown2"},
-            {2, nullptr, "Unknown3"},
-            {3, nullptr, "Unknown4"},
-            {4, nullptr, "Unknown5"},
-            {5, nullptr, "Unknown6"},
+            {0, nullptr, "Unknown0"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
             {6, nullptr, "GetMacAddress"},
             {7, nullptr, "SwitchTsfTimerFunction"},
-            {8, nullptr, "Unknown7"},
-            {9, nullptr, "Unknown8"},
-            {10, nullptr, "Unknown9"},
-            {11, nullptr, "Unknown10"},
+            {8, nullptr, "Unknown8"},
+            {9, nullptr, "Unknown9"},
+            {10, nullptr, "Unknown10"},
+            {11, nullptr, "Unknown11"},
+            {12, nullptr, "Unknown12"},
         };
         // clang-format on
 

src/core/memory/cheat_engine.cpp

@@ -20,7 +20,7 @@
 
 namespace Core::Memory {
 
-constexpr s64 CHEAT_ENGINE_TICKS = static_cast<s64>(1000000000 / 12);
+constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};
 constexpr u32 KEYPAD_BITMASK = 0x3FFFFFF;
 
 StandardVmCallbacks::StandardVmCallbacks(Core::System& system, const CheatProcessMetadata& metadata)
@@ -188,10 +188,12 @@ CheatEngine::~CheatEngine() {
 }
 
 void CheatEngine::Initialize() {
-    event = Core::Timing::CreateEvent(
-        "CheatEngine::FrameCallback::" + Common::HexToString(metadata.main_nso_build_id),
-        [this](u64 userdata, s64 ns_late) { FrameCallback(userdata, ns_late); });
-    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS, event);
+    event = Core::Timing::CreateEvent("CheatEngine::FrameCallback::" +
+                                          Common::HexToString(metadata.main_nso_build_id),
+                                      [this](u64 userdata, std::chrono::nanoseconds ns_late) {
+                                          FrameCallback(userdata, ns_late);
+                                      });
+    core_timing.ScheduleEvent(CHEAT_ENGINE_NS, event);
 
     metadata.process_id = system.CurrentProcess()->GetProcessID();
     metadata.title_id = system.CurrentProcess()->GetTitleID();
@@ -217,7 +219,7 @@ void CheatEngine::Reload(std::vector<CheatEntry> cheats) {
 
 MICROPROFILE_DEFINE(Cheat_Engine, "Add-Ons", "Cheat Engine", MP_RGB(70, 200, 70));
 
-void CheatEngine::FrameCallback(u64 userdata, s64 ns_late) {
+void CheatEngine::FrameCallback(u64, std::chrono::nanoseconds ns_late) {
     if (is_pending_reload.exchange(false)) {
         vm.LoadProgram(cheats);
     }
@@ -230,7 +232,7 @@ void CheatEngine::FrameCallback(u64 userdata, s64 ns_late) {
 
     vm.Execute(metadata);
 
-    core_timing.ScheduleEvent(CHEAT_ENGINE_TICKS - ns_late, event);
+    core_timing.ScheduleEvent(CHEAT_ENGINE_NS - ns_late, event);
 }
 
 } // namespace Core::Memory

src/core/memory/cheat_engine.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <atomic>
+#include <chrono>
 #include <memory>
 #include <vector>
 #include "common/common_types.h"
@@ -71,7 +72,7 @@ public:
     void Reload(std::vector<CheatEntry> cheats);
 
 private:
-    void FrameCallback(u64 userdata, s64 cycles_late);
+    void FrameCallback(u64 userdata, std::chrono::nanoseconds ns_late);
 
     DmntCheatVm vm;
     CheatProcessMetadata metadata;

src/core/memory/dmnt_cheat_vm.cpp

@@ -190,6 +190,15 @@ void DmntCheatVm::LogOpcode(const CheatVmOpcode& opcode) {
             callbacks->CommandLog(
                 fmt::format("Act[{:02X}]:   {:d}", i, save_restore_regmask->should_operate[i]));
         }
+    } else if (auto rw_static_reg = std::get_if<ReadWriteStaticRegisterOpcode>(&opcode.opcode)) {
+        callbacks->CommandLog("Opcode: Read/Write Static Register");
+        if (rw_static_reg->static_idx < NumReadableStaticRegisters) {
+            callbacks->CommandLog("Op Type: ReadStaticRegister");
+        } else {
+            callbacks->CommandLog("Op Type: WriteStaticRegister");
+        }
+        callbacks->CommandLog(fmt::format("Reg Idx   {:X}", rw_static_reg->idx));
+        callbacks->CommandLog(fmt::format("Stc Idx   {:X}", rw_static_reg->static_idx));
     } else if (auto debug_log = std::get_if<DebugLogOpcode>(&opcode.opcode)) {
         callbacks->CommandLog("Opcode: Debug Log");
         callbacks->CommandLog(fmt::format("Bit Width: {:X}", debug_log->bit_width));
@@ -544,6 +553,16 @@ bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
         }
         opcode.opcode = save_restore_regmask;
     } break;
+    case CheatVmOpcodeType::ReadWriteStaticRegister: {
+        ReadWriteStaticRegisterOpcode rw_static_reg{};
+        // C3000XXx
+        // C3 = opcode 0xC3.
+        // XX = static register index.
+        // x  = register index.
+        rw_static_reg.static_idx = ((first_dword >> 4) & 0xFF);
+        rw_static_reg.idx = (first_dword & 0xF);
+        opcode.opcode = rw_static_reg;
+    } break;
     case CheatVmOpcodeType::DebugLog: {
         DebugLogOpcode debug_log{};
         // FFFTIX##
@@ -667,6 +686,7 @@ void DmntCheatVm::ResetState() {
     registers.fill(0);
     saved_values.fill(0);
     loop_tops.fill(0);
+    static_registers.fill(0);
     instruction_ptr = 0;
     condition_depth = 0;
     decode_success = true;
@@ -1153,6 +1173,15 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
                     }
                 }
             }
+        } else if (auto rw_static_reg =
+                       std::get_if<ReadWriteStaticRegisterOpcode>(&cur_opcode.opcode)) {
+            if (rw_static_reg->static_idx < NumReadableStaticRegisters) {
+                // Load a register with a static register.
+                registers[rw_static_reg->idx] = static_registers[rw_static_reg->static_idx];
+            } else {
+                // Store a register to a static register.
+                static_registers[rw_static_reg->static_idx] = registers[rw_static_reg->idx];
+            }
         } else if (auto debug_log = std::get_if<DebugLogOpcode>(&cur_opcode.opcode)) {
             // Read value from memory.
             u64 log_value = 0;

src/core/memory/dmnt_cheat_vm.h

@@ -56,6 +56,7 @@ enum class CheatVmOpcodeType : u32 {
     BeginRegisterConditionalBlock = 0xC0,
     SaveRestoreRegister = 0xC1,
     SaveRestoreRegisterMask = 0xC2,
+    ReadWriteStaticRegister = 0xC3,
 
     // This is a meta entry, and not a real opcode.
     // This is to facilitate multi-nybble instruction decoding.
@@ -237,6 +238,11 @@ struct SaveRestoreRegisterMaskOpcode {
     std::array<bool, 0x10> should_operate{};
 };
 
+struct ReadWriteStaticRegisterOpcode {
+    u32 static_idx{};
+    u32 idx{};
+};
+
 struct DebugLogOpcode {
     u32 bit_width{};
     u32 log_id{};
@@ -259,7 +265,8 @@ struct CheatVmOpcode {
                  PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
                  PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
                  BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
-                 SaveRestoreRegisterMaskOpcode, DebugLogOpcode, UnrecognizedInstruction>
+                 SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, DebugLogOpcode,
+                 UnrecognizedInstruction>
         opcode{};
 };
 
@@ -281,6 +288,10 @@ public:
 
     static constexpr std::size_t MaximumProgramOpcodeCount = 0x400;
     static constexpr std::size_t NumRegisters = 0x10;
+    static constexpr std::size_t NumReadableStaticRegisters = 0x80;
+    static constexpr std::size_t NumWritableStaticRegisters = 0x80;
+    static constexpr std::size_t NumStaticRegisters =
+        NumReadableStaticRegisters + NumWritableStaticRegisters;
 
     explicit DmntCheatVm(std::unique_ptr<Callbacks> callbacks);
     ~DmntCheatVm();
@@ -302,6 +313,7 @@ private:
     std::array<u32, MaximumProgramOpcodeCount> program{};
     std::array<u64, NumRegisters> registers{};
     std::array<u64, NumRegisters> saved_values{};
+    std::array<u64, NumStaticRegisters> static_registers{};
     std::array<std::size_t, NumRegisters> loop_tops{};
 
     bool DecodeNextOpcode(CheatVmOpcode& out);