common/logging: Apply nodiscard where applicable

Applies the nodiscard attribute where it would be a bug/logic error to
ignore the return value.

Also marks inline member functions as noexcept where applicable.

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-patreon: yuzuteam

.travis.yml

@@ -24,7 +24,7 @@ matrix:
     - os: osx
       env: NAME="macos build"
       sudo: false
-      osx_image: xcode10.2
+      osx_image: xcode10.1
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"

.travis/linux-mingw/build.sh

@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 mkdir "$HOME/.ccache" || true
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh
+docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh

.travis/linux-mingw/deps.sh

@@ -1,3 +1,3 @@
 #!/bin/sh -ex
 
-docker pull yuzuemu/build-environments:linux-mingw
+docker pull ubuntu:18.04

.travis/linux-mingw/docker.sh

@@ -1,6 +1,16 @@
 #!/bin/bash -ex
 
 cd /yuzu
+MINGW_PACKAGES="sdl2-mingw-w64 qt5base-mingw-w64 qt5tools-mingw-w64 libsamplerate-mingw-w64 qt5multimedia-mingw-w64"
+apt-get update
+apt-get install -y gpg wget git python3-pip python ccache g++-mingw-w64-x86-64 gcc-mingw-w64-x86-64 mingw-w64-tools cmake
+echo 'deb http://ppa.launchpad.net/tobydox/mingw-w64/ubuntu bionic main ' > /etc/apt/sources.list.d/extras.list
+apt-key adv --keyserver keyserver.ubuntu.com --recv '72931B477E22FEFD47F8DECE02FE5F12ADDE29B2'
+apt-get update
+apt-get install -y ${MINGW_PACKAGES}
+
+# fix a problem in current MinGW headers
+wget -q https://raw.githubusercontent.com/Alexpux/mingw-w64/d0d7f784833bbb0b2d279310ddc6afb52fe47a46/mingw-w64-headers/crt/errno.h -O /usr/x86_64-w64-mingw32/include/errno.h
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
 
@@ -13,8 +23,8 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd
 
 mkdir build && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
-ninja
+cmake .. -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+make -j4
 
 # Clean up the dirty hacks
 rm /bin/uname && mv /bin/uname1 /bin/uname

.travis/linux/build.sh

@@ -1,4 +1,4 @@
 #!/bin/bash -ex
 
 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/deps.sh

@@ -1,3 +1,3 @@
 #!/bin/sh -ex
 
-docker pull yuzuemu/build-environments:linux-fresh
+docker pull ubuntu:18.04

.travis/linux/docker.sh

@@ -1,9 +1,12 @@
 #!/bin/bash -ex
 
+apt-get update
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev qtwebengine5-dev wget cmake ninja-build ccache
+
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -G Ninja -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 .. -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 -G Ninja
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -7,7 +7,6 @@ export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
-# TODO: Build using ninja instead of make
 mkdir build && cd build
 cmake --version
 cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON

.travis/macos/upload.sh

@@ -19,6 +19,18 @@ $(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${R
 # move libs into folder for deployment
 macpack "${REV_NAME}/yuzu-cmd" -d "libs"
 
+# Make the yuzu.app application launch a debugging terminal.
+# Store away the actual binary
+mv ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu-bin
+
+cat > ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu <<EOL
+#!/usr/bin/env bash
+cd "\`dirname "\$0"\`"
+chmod +x yuzu-bin
+open yuzu-bin --args "\$@"
+EOL
+# Content that will serve as the launching script for yuzu (within the .app folder)
+
 # Make the launching script executable
 chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu
 

CMakeLists.txt

@@ -132,7 +132,7 @@ find_package(Threads REQUIRED)
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(SDL2_VER "SDL2-2.0.8")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
@@ -165,7 +165,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
         message(STATUS "unicorn not found, falling back to bundled")
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(UNICORN_VER "unicorn-yuzu")
         else()
             message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
@@ -233,7 +233,7 @@ endif()
 
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(QT_VER qt-5.12.0-msvc2017_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")

CMakeModules/GenerateSCMRev.cmake

@@ -19,7 +19,7 @@ set(BUILD_VERSION "0")
 if (BUILD_REPOSITORY)
   # regex capture the string nightly or canary into CMAKE_MATCH_1
   string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
-  if ("${CMAKE_MATCH_COUNT}" GREATER 0)
+  if (${CMAKE_MATCH_COUNT} GREATER 0)
     # capitalize the first letter of each word in the repo name.
     string(REPLACE "-" ";" REPO_NAME_LIST ${CMAKE_MATCH_1})
     foreach(WORD ${REPO_NAME_LIST})
@@ -82,9 +82,6 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/video.cpp"
     "${VIDEO_CORE}/shader/decode/xmad.cpp"
     "${VIDEO_CORE}/shader/decode.cpp"
-    "${VIDEO_CORE}/shader/node.h"
-    "${VIDEO_CORE}/shader/node_helper.cpp"
-    "${VIDEO_CORE}/shader/node_helper.h"
     "${VIDEO_CORE}/shader/shader_ir.cpp"
     "${VIDEO_CORE}/shader/shader_ir.h"
     "${VIDEO_CORE}/shader/track.cpp"

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. yuzu can boot some games, to varying degrees of success.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

externals/CMakeLists.txt

@@ -7,10 +7,6 @@ include(DownloadExternals)
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)
 
-# libfmt
-add_subdirectory(fmt)
-add_library(fmt::fmt ALIAS fmt)
-
 # Dynarmic
 if (ARCHITECTURE_x86_64)
     set(DYNARMIC_TESTS OFF)
@@ -18,6 +14,10 @@ if (ARCHITECTURE_x86_64)
     add_subdirectory(dynarmic)
 endif()
 
+# libfmt
+add_subdirectory(fmt)
+add_library(fmt::fmt ALIAS fmt)
+
 # getopt
 if (MSVC)
     add_subdirectory(getopt)

externals/glad/include/KHR/khrplatform.h

@@ -90,20 +90,12 @@
  *                                  int arg2) KHRONOS_APIATTRIBUTES;
  */
 
-#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
-#   define KHRONOS_STATIC 1
-#endif
-
 /*-------------------------------------------------------------------------
  * Definition of KHRONOS_APICALL
  *-------------------------------------------------------------------------
  * This precedes the return type of the function in the function prototype.
  */
-#if defined(KHRONOS_STATIC)
-    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
-     * header compatible with static linking. */
-#   define KHRONOS_APICALL
-#elif defined(_WIN32)
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
@@ -119,7 +111,7 @@
  * This follows the return type of the function  and precedes the function
  * name in the function prototype.
  */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(KHRONOS_STATIC)
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
     /* Win32 but not WinCE */
 #   define KHRONOS_APIENTRY __stdcall
 #else

src/CMakeLists.txt

@@ -18,32 +18,15 @@ if (MSVC)
     # Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
     add_definitions(-DWIN32_LEAN_AND_MEAN)
 
-    # Ensure that projects build with Unicode support.
-    add_definitions(-DUNICODE -D_UNICODE)
-
-    # /W3                 - Level 3 warnings
-    # /MP                 - Multi-threaded compilation
-    # /Zi                 - Output debugging information
-    # /Zo                 - Enhanced debug info for optimized builds
-    # /permissive-        - Enables stricter C++ standards conformance checks
-    # /EHsc               - C++-only exception handling semantics
-    # /volatile:iso       - Use strict standards-compliant volatile semantics.
-    # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
-    # /Zc:inline          - Let codegen omit inline functions in object files
-    # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
-    add_compile_options(
-        /W3
-        /MP
-        /Zi
-        /Zo
-        /permissive-
-        /EHsc
-        /std:c++latest
-        /volatile:iso
-        /Zc:externConstexpr
-        /Zc:inline
-        /Zc:throwingNew
-    )
+    # /W3 - Level 3 warnings
+    # /MP - Multi-threaded compilation
+    # /Zi - Output debugging information
+    # /Zo - enhanced debug info for optimized builds
+    # /permissive- - enables stricter C++ standards conformance checks
+    # /EHsc - C++-only exception handling semantics
+    # /Zc:throwingNew - let codegen assume `operator new` will never return null
+    # /Zc:inline - let codegen omit inline functions in object files
+    add_compile_options(/W3 /MP /Zi /Zo /permissive- /EHsc /std:c++latest /Zc:throwingNew,inline)
 
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
@@ -51,10 +34,7 @@ if (MSVC)
     set(CMAKE_EXE_LINKER_FLAGS_DEBUG   "/DEBUG /MANIFEST:NO" CACHE STRING "" FORCE)
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 else()
-    add_compile_options(
-        -Wall
-        -Wno-attributes
-    )
+    add_compile_options("-Wno-attributes")
 
     if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
         add_compile_options("-stdlib=libc++")

src/audio_core/stream.cpp

@@ -57,9 +57,7 @@ Stream::State Stream::GetState() const {
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const auto us =
-        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
-    return Core::Timing::usToCycles(us);
+    return Core::Timing::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
 static void VolumeAdjustSamples(std::vector<s16>& samples) {

src/common/CMakeLists.txt

@@ -56,9 +56,6 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/video.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
       "${VIDEO_CORE}/shader/decode.cpp"
-      "${VIDEO_CORE}/shader/node.h"
-      "${VIDEO_CORE}/shader/node_helper.cpp"
-      "${VIDEO_CORE}/shader/node_helper.h"
       "${VIDEO_CORE}/shader/shader_ir.cpp"
       "${VIDEO_CORE}/shader/shader_ir.h"
       "${VIDEO_CORE}/shader/track.cpp"
@@ -126,8 +123,6 @@ add_library(common STATIC
     timer.h
     uint128.cpp
     uint128.h
-    uuid.cpp
-    uuid.h
     vector_math.h
     web_result.h
     zstd_compression.cpp

src/common/alignment.h

@@ -8,25 +8,25 @@
 namespace Common {
 
 template <typename T>
-constexpr T AlignUp(T value, std::size_t size) {
+[[nodiscard]] constexpr T AlignUp(T value, std::size_t size) noexcept {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return static_cast<T>(value + (size - value % size) % size);
 }
 
 template <typename T>
-constexpr T AlignDown(T value, std::size_t size) {
+[[nodiscard]] constexpr T AlignDown(T value, std::size_t size) noexcept {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return static_cast<T>(value - value % size);
 }
 
 template <typename T>
-constexpr bool Is4KBAligned(T value) {
+[[nodiscard]] constexpr bool Is4KBAligned(T value) noexcept {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return (value & 0xFFF) == 0;
 }
 
 template <typename T>
-constexpr bool IsWordAligned(T value) {
+[[nodiscard]] constexpr bool IsWordAligned(T value) noexcept {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return (value & 0b11) == 0;
 }

src/common/bit_field.h

@@ -135,8 +135,8 @@ public:
      * containing several bitfields can be assembled by formatting each of their values and ORing
      * the results together.
      */
-    static constexpr FORCE_INLINE StorageType FormatValue(const T& value) {
-        return ((StorageType)value << position) & mask;
+    [[nodiscard]] static constexpr FORCE_INLINE StorageType FormatValue(const T& value) noexcept {
+        return (static_cast<StorageType>(value) << position) & mask;
     }
 
     /**
@@ -144,7 +144,8 @@ public:
      * (such as Value() or operator T), but this can be used to extract a value from a bitfield
      * union in a constexpr context.
      */
-    static constexpr FORCE_INLINE T ExtractValue(const StorageType& storage) {
+    [[nodiscard]] static constexpr FORCE_INLINE T
+    ExtractValue(const StorageType& storage) noexcept {
         if constexpr (std::numeric_limits<UnderlyingType>::is_signed) {
             std::size_t shift = 8 * sizeof(T) - bits;
             return static_cast<T>(static_cast<UnderlyingType>(storage << (shift - position)) >>
@@ -168,19 +169,19 @@ public:
     constexpr BitField(BitField&&) noexcept = default;
     constexpr BitField& operator=(BitField&&) noexcept = default;
 
-    constexpr FORCE_INLINE operator T() const {
+    [[nodiscard]] constexpr FORCE_INLINE operator T() const noexcept {
         return Value();
     }
 
-    constexpr FORCE_INLINE void Assign(const T& value) {
+    constexpr FORCE_INLINE void Assign(const T& value) noexcept {
         storage = (static_cast<StorageType>(storage) & ~mask) | FormatValue(value);
     }
 
-    constexpr T Value() const {
+    [[nodiscard]] constexpr T Value() const noexcept {
         return ExtractValue(storage);
     }
 
-    constexpr explicit operator bool() const {
+    [[nodiscard]] constexpr explicit operator bool() const noexcept {
         return Value() != 0;
     }
 

src/common/bit_util.h

@@ -17,12 +17,12 @@ namespace Common {
 
 /// Gets the size of a specified type T in bits.
 template <typename T>
-constexpr std::size_t BitSize() {
+[[nodiscard]] constexpr std::size_t BitSize() noexcept {
     return sizeof(T) * CHAR_BIT;
 }
 
 #ifdef _MSC_VER
-inline u32 CountLeadingZeroes32(u32 value) {
+[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) noexcept {
     unsigned long leading_zero = 0;
 
     if (_BitScanReverse(&leading_zero, value) != 0) {
@@ -32,7 +32,7 @@ inline u32 CountLeadingZeroes32(u32 value) {
     return 32;
 }
 
-inline u32 CountLeadingZeroes64(u64 value) {
+[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) noexcept {
     unsigned long leading_zero = 0;
 
     if (_BitScanReverse64(&leading_zero, value) != 0) {
@@ -42,7 +42,7 @@ inline u32 CountLeadingZeroes64(u64 value) {
     return 64;
 }
 #else
-inline u32 CountLeadingZeroes32(u32 value) {
+[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) noexcept {
     if (value == 0) {
         return 32;
     }
@@ -50,7 +50,7 @@ inline u32 CountLeadingZeroes32(u32 value) {
     return static_cast<u32>(__builtin_clz(value));
 }
 
-inline u32 CountLeadingZeroes64(u64 value) {
+[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) noexcept {
     if (value == 0) {
         return 64;
     }
@@ -60,7 +60,7 @@ inline u32 CountLeadingZeroes64(u64 value) {
 #endif
 
 #ifdef _MSC_VER
-inline u32 CountTrailingZeroes32(u32 value) {
+[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) noexcept {
     unsigned long trailing_zero = 0;
 
     if (_BitScanForward(&trailing_zero, value) != 0) {
@@ -70,7 +70,7 @@ inline u32 CountTrailingZeroes32(u32 value) {
     return 32;
 }
 
-inline u32 CountTrailingZeroes64(u64 value) {
+[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) noexcept {
     unsigned long trailing_zero = 0;
 
     if (_BitScanForward64(&trailing_zero, value) != 0) {
@@ -80,7 +80,7 @@ inline u32 CountTrailingZeroes64(u64 value) {
     return 64;
 }
 #else
-inline u32 CountTrailingZeroes32(u32 value) {
+[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) noexcept {
     if (value == 0) {
         return 32;
     }
@@ -88,7 +88,7 @@ inline u32 CountTrailingZeroes32(u32 value) {
     return static_cast<u32>(__builtin_ctz(value));
 }
 
-inline u32 CountTrailingZeroes64(u64 value) {
+[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) noexcept {
     if (value == 0) {
         return 64;
     }

src/common/common_funcs.h

@@ -52,11 +52,11 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Call directly after the command or use the error num.
 // This function might change the error code.
 // Defined in Misc.cpp.
-std::string GetLastErrorMsg();
+[[nodiscard]] std::string GetLastErrorMsg();
 
 namespace Common {
 
-constexpr u32 MakeMagic(char a, char b, char c, char d) {
+[[nodiscard]] constexpr u32 MakeMagic(char a, char b, char c, char d) noexcept {
     return a | b << 8 | c << 16 | d << 24;
 }
 

src/common/file_util.cpp

@@ -78,17 +78,16 @@ namespace FileUtil {
 // Remove any ending forward slashes from directory paths
 // Modifies argument.
 static void StripTailDirSlashes(std::string& fname) {
-    if (fname.length() <= 1) {
-        return;
+    if (fname.length() > 1) {
+        std::size_t i = fname.length();
+        while (i > 0 && fname[i - 1] == DIR_SEP_CHR)
+            --i;
+        fname.resize(i);
     }
-
-    std::size_t i = fname.length();
-    while (i > 0 && fname[i - 1] == DIR_SEP_CHR) {
-        --i;
-    }
-    fname.resize(i);
+    return;
 }
 
+// Returns true if file filename exists
 bool Exists(const std::string& filename) {
     struct stat file_info;
 
@@ -108,6 +107,7 @@ bool Exists(const std::string& filename) {
     return (result == 0);
 }
 
+// Returns true if filename is a directory
 bool IsDirectory(const std::string& filename) {
     struct stat file_info;
 
@@ -132,6 +132,8 @@ bool IsDirectory(const std::string& filename) {
     return S_ISDIR(file_info.st_mode);
 }
 
+// Deletes a given filename, return true on success
+// Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "file {}", filename);
 
@@ -163,6 +165,7 @@ bool Delete(const std::string& filename) {
     return true;
 }
 
+// Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
     LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
@@ -191,6 +194,7 @@ bool CreateDir(const std::string& path) {
 #endif
 }
 
+// Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
     int panicCounter = 100;
     LOG_TRACE(Common_Filesystem, "path {}", fullPath);
@@ -226,6 +230,7 @@ bool CreateFullPath(const std::string& fullPath) {
     }
 }
 
+// Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "directory {}", filename);
 
@@ -247,6 +252,7 @@ bool DeleteDir(const std::string& filename) {
     return false;
 }
 
+// renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
@@ -262,6 +268,7 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     return false;
 }
 
+// copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
@@ -317,6 +324,7 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
 #endif
 }
 
+// Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
     if (!Exists(filename)) {
         LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
@@ -343,6 +351,7 @@ u64 GetSize(const std::string& filename) {
     return 0;
 }
 
+// Overloaded GetSize, accepts file descriptor
 u64 GetSize(const int fd) {
     struct stat buf;
     if (fstat(fd, &buf) != 0) {
@@ -352,6 +361,7 @@ u64 GetSize(const int fd) {
     return buf.st_size;
 }
 
+// Overloaded GetSize, accepts FILE*
 u64 GetSize(FILE* f) {
     // can't use off_t here because it can be 32-bit
     u64 pos = ftello(f);
@@ -367,6 +377,7 @@ u64 GetSize(FILE* f) {
     return size;
 }
 
+// creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "{}", filename);
 
@@ -491,6 +502,7 @@ bool DeleteDirRecursively(const std::string& directory, unsigned int recursion)
     return true;
 }
 
+// Create directory and copy contents (does not overwrite existing files)
 void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #ifndef _WIN32
     if (source_path == dest_path)
@@ -527,7 +539,8 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #endif
 }
 
-std::optional<std::string> GetCurrentDir() {
+// Returns the current directory
+std::string GetCurrentDir() {
 // Get the current working directory (getcwd uses malloc)
 #ifdef _WIN32
     wchar_t* dir;
@@ -537,7 +550,7 @@ std::optional<std::string> GetCurrentDir() {
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
         LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
-        return {};
+        return nullptr;
     }
 #ifdef _WIN32
     std::string strDir = Common::UTF16ToUTF8(dir);
@@ -548,6 +561,7 @@ std::optional<std::string> GetCurrentDir() {
     return strDir;
 }
 
+// Sets the current directory to the given directory
 bool SetCurrentDir(const std::string& directory) {
 #ifdef _WIN32
     return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
@@ -659,6 +673,8 @@ std::string GetSysDirectory() {
     return sysDir;
 }
 
+// Returns a string with a yuzu data dir or file in the user's home
+// directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(UserPath path, const std::string& new_path) {
     static std::unordered_map<UserPath, std::string> paths;
     auto& user_path = paths[UserPath::UserDir];
@@ -746,11 +762,11 @@ std::string GetNANDRegistrationDir(bool system) {
     return GetUserPath(UserPath::NANDDir) + "user/Contents/registered/";
 }
 
-std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str) {
-    return IOFile(filename, text_file ? "w" : "wb").WriteString(str);
+std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
+    return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
 }
 
-std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str) {
+std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
     if (!file.IsOpen())
@@ -760,6 +776,13 @@ std::size_t ReadFileToString(bool text_file, const std::string& filename, std::s
     return file.ReadArray(&str[0], str.size());
 }
 
+/**
+ * Splits the filename into 8.3 format
+ * Loosely implemented following https://en.wikipedia.org/wiki/8.3_filename
+ * @param filename The normal filename to use
+ * @param short_name A 9-char array in which the short name will be written
+ * @param extension A 4-char array in which the extension will be written
+ */
 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                      std::array<char, 4>& extension) {
     const std::string forbidden_characters = ".\"/\\[]:;=, ";

src/common/file_util.h

@@ -9,7 +9,6 @@
 #include <fstream>
 #include <functional>
 #include <limits>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -47,19 +46,19 @@ struct FSTEntry {
 };
 
 // Returns true if file filename exists
-bool Exists(const std::string& filename);
+[[nodiscard]] bool Exists(const std::string& filename);
 
 // Returns true if filename is a directory
-bool IsDirectory(const std::string& filename);
+[[nodiscard]] bool IsDirectory(const std::string& filename);
 
 // Returns the size of filename (64bit)
-u64 GetSize(const std::string& filename);
+[[nodiscard]] u64 GetSize(const std::string& filename);
 
 // Overloaded GetSize, accepts file descriptor
-u64 GetSize(const int fd);
+[[nodiscard]] u64 GetSize(int fd);
 
 // Overloaded GetSize, accepts FILE*
-u64 GetSize(FILE* f);
+[[nodiscard]] u64 GetSize(FILE* f);
 
 // Returns true if successful, or path already exists.
 bool CreateDir(const std::string& filename);
@@ -119,7 +118,7 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
 
 // Returns the current directory
-std::optional<std::string> GetCurrentDir();
+[[nodiscard]] std::string GetCurrentDir();
 
 // Create directory and copy contents (does not overwrite existing files)
 void CopyDir(const std::string& source_path, const std::string& dest_path);
@@ -129,27 +128,27 @@ bool SetCurrentDir(const std::string& directory);
 
 // Returns a pointer to a string with a yuzu data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
+[[nodiscard]] const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
 
-std::string GetHactoolConfigurationPath();
+[[nodiscard]] std::string GetHactoolConfigurationPath();
 
-std::string GetNANDRegistrationDir(bool system = false);
+[[nodiscard]] std::string GetNANDRegistrationDir(bool system = false);
 
 // Returns the path to where the sys file are
-std::string GetSysDirectory();
+[[nodiscard]] std::string GetSysDirectory();
 
 #ifdef __APPLE__
-std::string GetBundleDirectory();
+[[nodiscard]] std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32
-const std::string& GetExeDirectory();
-std::string AppDataRoamingDirectory();
+[[nodiscard]] const std::string& GetExeDirectory();
+[[nodiscard]] std::string AppDataRoamingDirectory();
 #endif
 
-std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
+std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename);
 
-std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
+std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 
 /**
  * Splits the filename into 8.3 format
@@ -163,26 +162,27 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
 
 // Splits the path on '/' or '\' and put the components into a vector
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
-std::vector<std::string> SplitPathComponents(std::string_view filename);
+[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
 
 // Gets all of the text up to the last '/' or '\' in the path.
-std::string_view GetParentPath(std::string_view path);
+[[nodiscard]] std::string_view GetParentPath(std::string_view path);
 
 // Gets all of the text after the first '/' or '\' in the path.
-std::string_view GetPathWithoutTop(std::string_view path);
+[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
 
 // Gets the filename of the path
-std::string_view GetFilename(std::string_view path);
+[[nodiscard]] std::string_view GetFilename(std::string_view path);
 
 // Gets the extension of the filename
-std::string_view GetExtensionFromFilename(std::string_view name);
+[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
 
 // Removes the final '/' or '\' if one exists
-std::string_view RemoveTrailingSlash(std::string_view path);
+[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
 
 // Creates a new vector containing indices [first, last) from the original.
 template <typename T>
-std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first, std::size_t last) {
+[[nodiscard]] std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first,
+                                         std::size_t last) {
     if (first >= last)
         return {};
     last = std::min<std::size_t>(last, vector.size());
@@ -193,8 +193,9 @@ enum class DirectorySeparator { ForwardSlash, BackwardSlash, PlatformDefault };
 
 // Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
 // depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
-std::string SanitizePath(std::string_view path,
-                         DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
+[[nodiscard]] std::string SanitizePath(
+    std::string_view path,
+    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
 
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
@@ -258,17 +259,17 @@ public:
         return WriteArray(&object, 1);
     }
 
-    std::size_t WriteString(std::string_view str) {
-        return WriteArray(str.data(), str.length());
+    std::size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
     }
 
-    bool IsOpen() const {
+    [[nodiscard]] bool IsOpen() const {
         return nullptr != m_file;
     }
 
     bool Seek(s64 off, int origin) const;
-    u64 Tell() const;
-    u64 GetSize() const;
+    [[nodiscard]] u64 Tell() const;
+    [[nodiscard]] u64 GetSize() const;
     bool Resize(u64 size);
     bool Flush();
 
@@ -287,8 +288,8 @@ private:
 template <typename T>
 void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
 #ifdef _MSC_VER
-    fstream.open(Common::UTF8ToUTF16W(filename), openmode);
+    fstream.open(Common::UTF8ToUTF16W(filename).c_str(), openmode);
 #else
-    fstream.open(filename, openmode);
+    fstream.open(filename.c_str(), openmode);
 #endif
 }

src/common/hex_util.h

@@ -13,12 +13,12 @@
 
 namespace Common {
 
-u8 ToHexNibble(char c1);
+[[nodiscard]] u8 ToHexNibble(char c1);
 
-std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
+[[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
 
 template <std::size_t Size, bool le = false>
-std::array<u8, Size> HexStringToArray(std::string_view str) {
+[[nodiscard]] std::array<u8, Size> HexStringToArray(std::string_view str) {
     std::array<u8, Size> out{};
     if constexpr (le) {
         for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2)
@@ -30,17 +30,17 @@ std::array<u8, Size> HexStringToArray(std::string_view str) {
     return out;
 }
 
-std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
+[[nodiscard]] std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
 
 template <std::size_t Size>
-std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
+[[nodiscard]] std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     std::string out;
     for (u8 c : array)
         out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
     return out;
 }
 
-std::array<u8, 0x10> operator"" _array16(const char* str, std::size_t len);
-std::array<u8, 0x20> operator"" _array32(const char* str, std::size_t len);
+[[nodiscard]] std::array<u8, 0x10> operator"" _array16(const char* str, std::size_t len);
+[[nodiscard]] std::array<u8, 0x20> operator"" _array32(const char* str, std::size_t len);
 
 } // namespace Common

src/common/logging/backend.h

@@ -46,7 +46,7 @@ public:
     virtual void SetFilter(const Filter& new_filter) {
         filter = new_filter;
     }
-    virtual const char* GetName() const = 0;
+    [[nodiscard]] virtual const char* GetName() const = 0;
     virtual void Write(const Entry& entry) = 0;
 
 private:
@@ -58,12 +58,14 @@ private:
  */
 class ConsoleBackend : public Backend {
 public:
-    static const char* Name() {
+    [[nodiscard]] static const char* Name() {
         return "console";
     }
-    const char* GetName() const override {
+
+    [[nodiscard]] const char* GetName() const override {
         return Name();
     }
+
     void Write(const Entry& entry) override;
 };
 
@@ -72,13 +74,14 @@ public:
  */
 class ColorConsoleBackend : public Backend {
 public:
-    static const char* Name() {
+    [[nodiscard]] static const char* Name() {
         return "color_console";
     }
 
-    const char* GetName() const override {
+    [[nodiscard]] const char* GetName() const override {
         return Name();
     }
+
     void Write(const Entry& entry) override;
 };
 
@@ -89,11 +92,11 @@ class FileBackend : public Backend {
 public:
     explicit FileBackend(const std::string& filename);
 
-    static const char* Name() {
+    [[nodiscard]] static const char* Name() {
         return "file";
     }
 
-    const char* GetName() const override {
+    [[nodiscard]] const char* GetName() const override {
         return Name();
     }
 
@@ -109,12 +112,14 @@ private:
  */
 class DebuggerBackend : public Backend {
 public:
-    static const char* Name() {
+    [[nodiscard]] static const char* Name() {
         return "debugger";
     }
-    const char* GetName() const override {
+
+    [[nodiscard]] const char* GetName() const override {
         return Name();
     }
+
     void Write(const Entry& entry) override;
 };
 
@@ -122,18 +127,18 @@ void AddBackend(std::unique_ptr<Backend> backend);
 
 void RemoveBackend(std::string_view backend_name);
 
-Backend* GetBackend(std::string_view backend_name);
+[[nodiscard]] Backend* GetBackend(std::string_view backend_name);
 
 /**
  * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
  * instead of underscores as in the enumeration.
  */
-const char* GetLogClassName(Class log_class);
+[[nodiscard]] const char* GetLogClassName(Class log_class);
 
 /**
  * Returns the name of the passed log level as a C-string.
  */
-const char* GetLevelName(Level log_level);
+[[nodiscard]] const char* GetLevelName(Level log_level);
 
 /**
  * The global filter will prevent any messages from even being processed if they are filtered. Each

src/common/logging/filter.h

@@ -43,10 +43,10 @@ public:
     void ParseFilterString(std::string_view filter_view);
 
     /// Matches class/level combination against the filter, returning true if it passed.
-    bool CheckMessage(Class log_class, Level level) const;
+    [[nodiscard]] bool CheckMessage(Class log_class, Level level) const;
 
     /// Returns true if any logging classes are set to debug
-    bool IsDebug() const;
+    [[nodiscard]] bool IsDebug() const;
 
 private:
     std::array<Level, static_cast<std::size_t>(Class::Count)> class_levels;

src/common/logging/text_formatter.h

@@ -12,7 +12,7 @@ namespace Log {
 struct Entry;
 
 /// Formats a log entry into the provided text buffer.
-std::string FormatLogMessage(const Entry& entry);
+[[nodiscard]] std::string FormatLogMessage(const Entry& entry);
 /// Formats and prints a log entry to stderr.
 void PrintMessage(const Entry& entry);
 /// Prints the same message as `PrintMessage`, but colored according to the severity level.

src/common/lz4_compression.h

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <vector>
 
 #include "common/common_types.h"
@@ -18,7 +16,7 @@ namespace Common::Compression {
  *
  * @return the compressed data.
  */
-std::vector<u8> CompressDataLZ4(const u8* source, std::size_t source_size);
+[[nodiscard]] std::vector<u8> CompressDataLZ4(const u8* source, std::size_t source_size);
 
 /**
  * Utilizes the LZ4 subalgorithm LZ4HC with the specified compression level. Higher compression
@@ -32,7 +30,8 @@ std::vector<u8> CompressDataLZ4(const u8* source, std::size_t source_size);
  *
  * @return the compressed data.
  */
-std::vector<u8> CompressDataLZ4HC(const u8* source, std::size_t source_size, s32 compression_level);
+[[nodiscard]] std::vector<u8> CompressDataLZ4HC(const u8* source, std::size_t source_size,
+                                                s32 compression_level);
 
 /**
  * Utilizes the LZ4 subalgorithm LZ4HC with the highest possible compression level.
@@ -42,7 +41,7 @@ std::vector<u8> CompressDataLZ4HC(const u8* source, std::size_t source_size, s32
  *
  * @return the compressed data.
  */
-std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size);
+[[nodiscard]] std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size);
 
 /**
  * Decompresses a source memory region with LZ4 and returns the uncompressed data in a vector.
@@ -52,6 +51,7 @@ std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size);
  *
  * @return the decompressed data.
  */
-std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed, std::size_t uncompressed_size);
+[[nodiscard]] std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed,
+                                                std::size_t uncompressed_size);
 
 } // namespace Common::Compression

src/common/math_util.h

@@ -18,30 +18,27 @@ struct Rectangle {
     T right{};
     T bottom{};
 
-    constexpr Rectangle() = default;
+    constexpr Rectangle() noexcept = default;
 
-    constexpr Rectangle(T left, T top, T right, T bottom)
+    constexpr Rectangle(T left, T top, T right, T bottom) noexcept
         : left(left), top(top), right(right), bottom(bottom) {}
 
-    T GetWidth() const {
+    [[nodiscard]] T GetWidth() const noexcept {
         return std::abs(static_cast<std::make_signed_t<T>>(right - left));
     }
-    T GetHeight() const {
+    [[nodiscard]] T GetHeight() const noexcept {
         return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
     }
-    Rectangle<T> TranslateX(const T x) const {
+    [[nodiscard]] Rectangle<T> TranslateX(const T x) const noexcept {
         return Rectangle{left + x, top, right + x, bottom};
     }
-    Rectangle<T> TranslateY(const T y) const {
+    [[nodiscard]] Rectangle<T> TranslateY(const T y) const noexcept {
         return Rectangle{left, top + y, right, bottom + y};
     }
-    Rectangle<T> Scale(const float s) const {
+    [[nodiscard]] Rectangle<T> Scale(const float s) const noexcept {
         return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
                          static_cast<T>(top + GetHeight() * s)};
     }
 };
 
-template <typename T>
-Rectangle(T, T, T, T)->Rectangle<T>;
-
 } // namespace Common

src/common/memory_hook.h

@@ -26,21 +26,22 @@ class MemoryHook {
 public:
     virtual ~MemoryHook();
 
-    virtual std::optional<bool> IsValidAddress(VAddr addr) = 0;
+    [[nodiscard]] virtual std::optional<bool> IsValidAddress(VAddr addr) = 0;
 
-    virtual std::optional<u8> Read8(VAddr addr) = 0;
-    virtual std::optional<u16> Read16(VAddr addr) = 0;
-    virtual std::optional<u32> Read32(VAddr addr) = 0;
-    virtual std::optional<u64> Read64(VAddr addr) = 0;
+    [[nodiscard]] virtual std::optional<u8> Read8(VAddr addr) = 0;
+    [[nodiscard]] virtual std::optional<u16> Read16(VAddr addr) = 0;
+    [[nodiscard]] virtual std::optional<u32> Read32(VAddr addr) = 0;
+    [[nodiscard]] virtual std::optional<u64> Read64(VAddr addr) = 0;
 
-    virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) = 0;
+    [[nodiscard]] virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) = 0;
 
-    virtual bool Write8(VAddr addr, u8 data) = 0;
-    virtual bool Write16(VAddr addr, u16 data) = 0;
-    virtual bool Write32(VAddr addr, u32 data) = 0;
-    virtual bool Write64(VAddr addr, u64 data) = 0;
+    [[nodiscard]] virtual bool Write8(VAddr addr, u8 data) = 0;
+    [[nodiscard]] virtual bool Write16(VAddr addr, u16 data) = 0;
+    [[nodiscard]] virtual bool Write32(VAddr addr, u32 data) = 0;
+    [[nodiscard]] virtual bool Write64(VAddr addr, u64 data) = 0;
 
-    virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer, std::size_t size) = 0;
+    [[nodiscard]] virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer,
+                                          std::size_t size) = 0;
 };
 
 using MemoryHookPointer = std::shared_ptr<MemoryHook>;

src/common/multi_level_queue.h

@@ -43,21 +43,21 @@ public:
         using reference = std::conditional_t<is_constant, const T&, T&>;
         using difference_type = typename std::pointer_traits<pointer>::difference_type;
 
-        friend bool operator==(const iterator_impl& lhs, const iterator_impl& rhs) {
+        [[nodiscard]] friend bool operator==(const iterator_impl& lhs, const iterator_impl& rhs) {
             if (lhs.IsEnd() && rhs.IsEnd())
                 return true;
             return std::tie(lhs.current_priority, lhs.it) == std::tie(rhs.current_priority, rhs.it);
         }
 
-        friend bool operator!=(const iterator_impl& lhs, const iterator_impl& rhs) {
+        [[nodiscard]] friend bool operator!=(const iterator_impl& lhs, const iterator_impl& rhs) {
             return !operator==(lhs, rhs);
         }
 
-        reference operator*() const {
+        [[nodiscard]] reference operator*() const {
             return *it;
         }
 
-        pointer operator->() const {
+        [[nodiscard]] pointer operator->() const {
             return it.operator->();
         }
 
@@ -143,15 +143,15 @@ public:
         explicit iterator_impl(container_ref mlq, u32 current_priority)
             : mlq(mlq), it(), current_priority(current_priority) {}
 
-        bool IsEnd() const {
+        [[nodiscard]] bool IsEnd() const {
             return current_priority == mlq.depth();
         }
 
-        list_iterator GetBeginItForPrio() const {
+        [[nodiscard]] list_iterator GetBeginItForPrio() const {
             return mlq.levels[current_priority].begin();
         }
 
-        list_iterator GetEndItForPrio() const {
+        [[nodiscard]] list_iterator GetEndItForPrio() const {
             return mlq.levels[current_priority].end();
         }
 
@@ -223,15 +223,15 @@ public:
         ListShiftForward(levels[priority], n);
     }
 
-    std::size_t depth() const {
+    [[nodiscard]] std::size_t depth() const {
         return Depth;
     }
 
-    std::size_t size(u32 priority) const {
+    [[nodiscard]] std::size_t size(u32 priority) const {
         return levels[priority].size();
     }
 
-    std::size_t size() const {
+    [[nodiscard]] std::size_t size() const {
         u64 priorities = used_priorities;
         std::size_t size = 0;
         while (priorities != 0) {
@@ -242,64 +242,64 @@ public:
         return size;
     }
 
-    bool empty() const {
+    [[nodiscard]] bool empty() const {
         return used_priorities == 0;
     }
 
-    bool empty(u32 priority) const {
+    [[nodiscard]] bool empty(u32 priority) const {
         return (used_priorities & (1ULL << priority)) == 0;
     }
 
-    u32 highest_priority_set(u32 max_priority = 0) const {
+    [[nodiscard]] u32 highest_priority_set(u32 max_priority = 0) const {
         const u64 priorities =
             max_priority == 0 ? used_priorities : (used_priorities & ~((1ULL << max_priority) - 1));
         return priorities == 0 ? Depth : static_cast<u32>(CountTrailingZeroes64(priorities));
     }
 
-    u32 lowest_priority_set(u32 min_priority = Depth - 1) const {
+    [[nodiscard]] u32 lowest_priority_set(u32 min_priority = Depth - 1) const {
         const u64 priorities = min_priority >= Depth - 1
                                    ? used_priorities
                                    : (used_priorities & ((1ULL << (min_priority + 1)) - 1));
         return priorities == 0 ? Depth : 63 - CountLeadingZeroes64(priorities);
     }
 
-    const_iterator cbegin(u32 max_prio = 0) const {
+    [[nodiscard]] const_iterator cbegin(u32 max_prio = 0) const {
         const u32 priority = highest_priority_set(max_prio);
         return priority == Depth ? cend()
                                  : const_iterator{*this, levels[priority].cbegin(), priority};
     }
-    const_iterator begin(u32 max_prio = 0) const {
+    [[nodiscard]] const_iterator begin(u32 max_prio = 0) const {
         return cbegin(max_prio);
     }
-    iterator begin(u32 max_prio = 0) {
+    [[nodiscard]] iterator begin(u32 max_prio = 0) {
         const u32 priority = highest_priority_set(max_prio);
         return priority == Depth ? end() : iterator{*this, levels[priority].begin(), priority};
     }
 
-    const_iterator cend(u32 min_prio = Depth - 1) const {
+    [[nodiscard]] const_iterator cend(u32 min_prio = Depth - 1) const {
         return min_prio == Depth - 1 ? const_iterator{*this, Depth} : cbegin(min_prio + 1);
     }
-    const_iterator end(u32 min_prio = Depth - 1) const {
+    [[nodiscard]] const_iterator end(u32 min_prio = Depth - 1) const {
         return cend(min_prio);
     }
-    iterator end(u32 min_prio = Depth - 1) {
+    [[nodiscard]] iterator end(u32 min_prio = Depth - 1) {
         return min_prio == Depth - 1 ? iterator{*this, Depth} : begin(min_prio + 1);
     }
 
-    T& front(u32 max_priority = 0) {
+    [[nodiscard]] T& front(u32 max_priority = 0) {
         const u32 priority = highest_priority_set(max_priority);
         return levels[priority == Depth ? 0 : priority].front();
     }
-    const T& front(u32 max_priority = 0) const {
+    [[nodiscard]] const T& front(u32 max_priority = 0) const {
         const u32 priority = highest_priority_set(max_priority);
         return levels[priority == Depth ? 0 : priority].front();
     }
 
-    T back(u32 min_priority = Depth - 1) {
+    [[nodiscard]] T back(u32 min_priority = Depth - 1) {
         const u32 priority = lowest_priority_set(min_priority); // intended
         return levels[priority == Depth ? 63 : priority].back();
     }
-    const T& back(u32 min_priority = Depth - 1) const {
+    [[nodiscard]] const T& back(u32 min_priority = Depth - 1) const {
         const u32 priority = lowest_priority_set(min_priority); // intended
         return levels[priority == Depth ? 63 : priority].back();
     }
@@ -322,7 +322,8 @@ private:
         in_list.splice(position, out_list, element);
     }
 
-    static const_list_iterator ListIterateTo(const std::list<T>& list, const T& element) {
+    [[nodiscard]] static const_list_iterator ListIterateTo(const std::list<T>& list,
+                                                           const T& element) {
         auto it = list.cbegin();
         while (it != list.cend() && *it != element) {
             ++it;

src/common/page_table.h

@@ -33,11 +33,11 @@ struct SpecialRegion {
 
     MemoryHookPointer handler;
 
-    bool operator<(const SpecialRegion& other) const {
+    [[nodiscard]] bool operator<(const SpecialRegion& other) const {
         return std::tie(type, handler) < std::tie(other.type, other.handler);
     }
 
-    bool operator==(const SpecialRegion& other) const {
+    [[nodiscard]] bool operator==(const SpecialRegion& other) const {
         return std::tie(type, handler) == std::tie(other.type, other.handler);
     }
 };

src/common/param_package.h

@@ -24,14 +24,14 @@ public:
     ParamPackage& operator=(const ParamPackage& other) = default;
     ParamPackage& operator=(ParamPackage&& other) = default;
 
-    std::string Serialize() const;
-    std::string Get(const std::string& key, const std::string& default_value) const;
-    int Get(const std::string& key, int default_value) const;
-    float Get(const std::string& key, float default_value) const;
+    [[nodiscard]] std::string Serialize() const;
+    [[nodiscard]] std::string Get(const std::string& key, const std::string& default_value) const;
+    [[nodiscard]] int Get(const std::string& key, int default_value) const;
+    [[nodiscard]] float Get(const std::string& key, float default_value) const;
     void Set(const std::string& key, std::string value);
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
-    bool Has(const std::string& key) const;
+    [[nodiscard]] bool Has(const std::string& key) const;
     void Erase(const std::string& key);
     void Clear();
 

src/common/quaternion.h

@@ -14,35 +14,39 @@ public:
     Vec3<T> xyz;
     T w{};
 
-    Quaternion<decltype(-T{})> Inverse() const {
+    [[nodiscard]] Quaternion<decltype(-T{})> Inverse() const noexcept {
         return {-xyz, w};
     }
 
-    Quaternion<decltype(T{} + T{})> operator+(const Quaternion& other) const {
+    [[nodiscard]] Quaternion<decltype(T{} + T{})> operator+(const Quaternion& other) const
+        noexcept {
         return {xyz + other.xyz, w + other.w};
     }
 
-    Quaternion<decltype(T{} - T{})> operator-(const Quaternion& other) const {
+    [[nodiscard]] Quaternion<decltype(T{} - T{})> operator-(const Quaternion& other) const
+        noexcept {
         return {xyz - other.xyz, w - other.w};
     }
 
-    Quaternion<decltype(T{} * T{} - T{} * T{})> operator*(const Quaternion& other) const {
+    [[nodiscard]] Quaternion<decltype(T{} * T{} - T{} * T{})> operator*(
+        const Quaternion& other) const noexcept {
         return {xyz * other.w + other.xyz * w + Cross(xyz, other.xyz),
                 w * other.w - Dot(xyz, other.xyz)};
     }
 
-    Quaternion<T> Normalized() const {
+    [[nodiscard]] Quaternion<T> Normalized() const noexcept {
         T length = std::sqrt(xyz.Length2() + w * w);
         return {xyz / length, w / length};
     }
 };
 
 template <typename T>
-auto QuaternionRotate(const Quaternion<T>& q, const Vec3<T>& v) {
+[[nodiscard]] auto QuaternionRotate(const Quaternion<T>& q, const Vec3<T>& v) noexcept {
     return v + 2 * Cross(q.xyz, Cross(q.xyz, v) + v * q.w);
 }
 
-inline Quaternion<float> MakeQuaternion(const Vec3<float>& axis, float angle) {
+[[nodiscard]] inline Quaternion<float> MakeQuaternion(const Vec3<float>& axis,
+                                                      float angle) noexcept {
     return {axis * std::sin(angle / 2), std::cos(angle / 2)};
 }
 

src/common/ring_buffer.h

@@ -64,7 +64,7 @@ public:
     /// @param output     Where to store the popped slots
     /// @param max_slots  Maximum number of slots to pop
     /// @returns The number of slots actually popped
-    std::size_t Pop(void* output, std::size_t max_slots = ~std::size_t(0)) {
+    [[nodiscard]] std::size_t Pop(void* output, std::size_t max_slots = ~std::size_t(0)) {
         const std::size_t read_index = m_read_index.load();
         const std::size_t slots_filled = m_write_index.load() - read_index;
         const std::size_t pop_count = std::min(slots_filled, max_slots);
@@ -83,7 +83,7 @@ public:
         return pop_count;
     }
 
-    std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
+    [[nodiscard]] std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
         std::vector<T> out(std::min(max_slots, capacity) * granularity);
         const std::size_t count = Pop(out.data(), out.size() / granularity);
         out.resize(count * granularity);
@@ -91,12 +91,12 @@ public:
     }
 
     /// @returns Number of slots used
-    std::size_t Size() const {
+    [[nodiscard]] std::size_t Size() const {
         return m_write_index.load() - m_read_index.load();
     }
 
     /// @returns Maximum size of ring buffer
-    constexpr std::size_t Capacity() const {
+    [[nodiscard]] constexpr std::size_t Capacity() const {
         return capacity;
     }
 

src/common/string_util.h

@@ -12,19 +12,19 @@
 namespace Common {
 
 /// Make a string lowercase
-std::string ToLower(std::string str);
+[[nodiscard]] std::string ToLower(std::string str);
 
 /// Make a string uppercase
-std::string ToUpper(std::string str);
+[[nodiscard]] std::string ToUpper(std::string str);
 
-std::string StringFromBuffer(const std::vector<u8>& data);
+[[nodiscard]] std::string StringFromBuffer(const std::vector<u8>& data);
 
-std::string StripSpaces(const std::string& s);
-std::string StripQuotes(const std::string& s);
+[[nodiscard]] std::string StripSpaces(const std::string& s);
+[[nodiscard]] std::string StripQuotes(const std::string& s);
 
-std::string StringFromBool(bool value);
+[[nodiscard]] std::string StringFromBool(bool value);
 
-std::string TabsToSpaces(int tab_size, std::string in);
+[[nodiscard]] std::string TabsToSpaces(int tab_size, std::string in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
 
@@ -34,15 +34,15 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
 
 void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path,
                            const std::string& _Filename);
-std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest);
+[[nodiscard]] std::string ReplaceAll(std::string result, const std::string& src,
+                                     const std::string& dest);
 
-std::string UTF16ToUTF8(const std::u16string& input);
-std::u16string UTF8ToUTF16(const std::string& input);
+[[nodiscard]] std::string UTF16ToUTF8(const std::u16string& input);
+[[nodiscard]] std::u16string UTF8ToUTF16(const std::string& input);
 
 #ifdef _WIN32
-std::string UTF16ToUTF8(const std::wstring& input);
-std::wstring UTF8ToUTF16W(const std::string& str);
-
+[[nodiscard]] std::string UTF16ToUTF8(const std::wstring& input);
+[[nodiscard]] std::wstring UTF8ToUTF16W(const std::string& str);
 #endif
 
 /**
@@ -50,7 +50,7 @@ std::wstring UTF8ToUTF16W(const std::string& str);
  * `other` for equality.
  */
 template <typename InIt>
-bool ComparePartialString(InIt begin, InIt end, const char* other) {
+[[nodiscard]] bool ComparePartialString(InIt begin, InIt end, const char* other) {
     for (; begin != end && *other != '\0'; ++begin, ++other) {
         if (*begin != *other) {
             return false;
@@ -64,15 +64,16 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  * Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
  * NUL-terminated then the string ends at max_len characters.
  */
-std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len);
+[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(const char* buffer,
+                                                              std::size_t max_len);
 
 /**
  * Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
  * null-terminated, then the string ends at the greatest multiple of two less then or equal to
  * max_len_bytes.
  */
-std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
-                                                        std::size_t max_len);
+[[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
+                                                                      std::size_t max_len);
 
 /**
  * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
@@ -84,6 +85,6 @@ std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buff
  *             including the last occurrence of this name will be stripped
  * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
  */
-const char* TrimSourcePath(const char* path, const char* root = "src");
+[[nodiscard]] const char* TrimSourcePath(const char* path, const char* root = "src");
 
 } // namespace Common

src/common/telemetry.h

@@ -42,7 +42,7 @@ public:
      * Gets the name of this field.
      * @returns Name of this field as a string.
      */
-    virtual const std::string& GetName() const = 0;
+    [[nodiscard]] virtual const std::string& GetName() const = 0;
 };
 
 /**
@@ -63,29 +63,29 @@ public:
 
     void Accept(VisitorInterface& visitor) const override;
 
-    const std::string& GetName() const override {
+    [[nodiscard]] const std::string& GetName() const override {
         return name;
     }
 
     /**
      * Returns the type of the field.
      */
-    FieldType GetType() const {
+    [[nodiscard]] FieldType GetType() const {
         return type;
     }
 
     /**
      * Returns the value of the field.
      */
-    const T& GetValue() const {
+    [[nodiscard]] const T& GetValue() const {
         return value;
     }
 
-    bool operator==(const Field& other) const {
+    [[nodiscard]] bool operator==(const Field& other) const {
         return (type == other.type) && (name == other.name) && (value == other.value);
     }
 
-    bool operator!=(const Field& other) const {
+    [[nodiscard]] bool operator!=(const Field& other) const {
         return !(*this == other);
     }
 

src/common/thread.h

@@ -29,7 +29,7 @@ public:
     }
 
     template <class Clock, class Duration>
-    bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
+    [[nodiscard]] bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
         std::unique_lock lk{mutex};
         if (!condvar.wait_until(lk, time, [this] { return is_set; }))
             return false;

src/common/thread_queue_list.h

@@ -25,7 +25,7 @@ struct ThreadQueueList {
     }
 
     // Only for debugging, returns priority level.
-    Priority contains(const T& uid) const {
+    [[nodiscard]] Priority contains(const T& uid) const {
         for (Priority i = 0; i < NUM_QUEUES; ++i) {
             const Queue& cur = queues[i];
             if (std::find(cur.data.cbegin(), cur.data.cend(), uid) != cur.data.cend()) {
@@ -36,7 +36,7 @@ struct ThreadQueueList {
         return -1;
     }
 
-    T get_first() const {
+    [[nodiscard]] T get_first() const {
         const Queue* cur = first;
         while (cur != nullptr) {
             if (!cur->data.empty()) {
@@ -49,7 +49,7 @@ struct ThreadQueueList {
     }
 
     template <typename UnaryPredicate>
-    T get_first_filter(UnaryPredicate filter) const {
+    [[nodiscard]] T get_first_filter(UnaryPredicate filter) const {
         const Queue* cur = first;
         while (cur != nullptr) {
             if (!cur->data.empty()) {
@@ -129,7 +129,7 @@ struct ThreadQueueList {
         first = nullptr;
     }
 
-    bool empty(Priority priority) const {
+    [[nodiscard]] bool empty(Priority priority) const {
         const Queue* cur = &queues[priority];
         return cur->data.empty();
     }

src/common/threadsafe_queue.h

@@ -25,15 +25,15 @@ public:
         delete read_ptr;
     }
 
-    std::size_t Size() const {
+    [[nodiscard]] std::size_t Size() const {
         return size.load();
     }
 
-    bool Empty() const {
+    [[nodiscard]] bool Empty() const {
         return Size() == 0;
     }
 
-    T& Front() const {
+    [[nodiscard]] T& Front() const {
         return read_ptr->current;
     }
 
@@ -123,15 +123,15 @@ private:
 template <typename T>
 class MPSCQueue {
 public:
-    std::size_t Size() const {
+    [[nodiscard]] std::size_t Size() const {
         return spsc_queue.Size();
     }
 
-    bool Empty() const {
+    [[nodiscard]] bool Empty() const {
         return spsc_queue.Empty();
     }
 
-    T& Front() const {
+    [[nodiscard]] T& Front() const {
         return spsc_queue.Front();
     }
 

src/common/timer.h

@@ -19,18 +19,18 @@ public:
 
     // The time difference is always returned in milliseconds, regardless of alternative internal
     // representation
-    std::chrono::milliseconds GetTimeDifference();
+    [[nodiscard]] std::chrono::milliseconds GetTimeDifference();
     void AddTimeDifference();
 
-    static std::chrono::seconds GetTimeSinceJan1970();
-    static std::chrono::seconds GetLocalTimeSinceJan1970();
-    static double GetDoubleTime();
+    [[nodiscard]] static std::chrono::seconds GetTimeSinceJan1970();
+    [[nodiscard]] static std::chrono::seconds GetLocalTimeSinceJan1970();
+    [[nodiscard]] static double GetDoubleTime();
 
-    static std::string GetTimeFormatted();
-    std::string GetTimeElapsedFormatted() const;
-    std::chrono::milliseconds GetTimeElapsed();
+    [[nodiscard]] static std::string GetTimeFormatted();
+    [[nodiscard]] std::string GetTimeElapsedFormatted() const;
+    [[nodiscard]] std::chrono::milliseconds GetTimeElapsed();
 
-    static std::chrono::milliseconds GetTimeMs();
+    [[nodiscard]] static std::chrono::milliseconds GetTimeMs();
 
 private:
     std::chrono::milliseconds m_LastTime;

src/common/uint128.cpp

@@ -12,7 +12,7 @@
 
 namespace Common {
 
-u128 Multiply64Into128(u64 a, u64 b) {
+u128 Multiply64Into128(u64 a, u64 b) noexcept {
     u128 result;
 #ifdef _MSC_VER
     result[0] = _umul128(a, b, &result[1]);
@@ -24,7 +24,7 @@ u128 Multiply64Into128(u64 a, u64 b) {
     return result;
 }
 
-std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) {
+std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) noexcept {
     u64 remainder = dividend[0] % divisor;
     u64 accum = dividend[0] / divisor;
     if (dividend[1] == 0)

src/common/uint128.h

@@ -10,10 +10,10 @@
 namespace Common {
 
 // This function multiplies 2 u64 values and produces a u128 value;
-u128 Multiply64Into128(u64 a, u64 b);
+[[nodiscard]] u128 Multiply64Into128(u64 a, u64 b) noexcept;
 
 // This function divides a u128 by a u32 value and produces two u64 values:
 // the result of division and the remainder
-std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor);
+[[nodiscard]] std::pair<u64, u64> Divide128On32(u128 dividend, u32 divisor) noexcept;
 
 } // namespace Common

src/common/uuid.cpp

@@ -1,33 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <random>
-
-#include <fmt/format.h>
-
-#include "common/uuid.h"
-
-namespace Common {
-
-UUID UUID::Generate() {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return UUID{distribution(gen), distribution(gen)};
-}
-
-std::string UUID::Format() const {
-    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
-}
-
-std::string UUID::FormatSwitch() const {
-    std::array<u8, 16> s{};
-    std::memcpy(s.data(), uuid.data(), sizeof(u128));
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                       ":02x}{:02x}{:02x}{:02x}{:02x}",
-                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                       s[12], s[13], s[14], s[15]);
-}
-
-} // namespace Common

src/common/uuid.h

@@ -1,48 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-constexpr u128 INVALID_UUID{{0, 0}};
-
-struct UUID {
-    // UUIDs which are 0 are considered invalid!
-    u128 uuid = INVALID_UUID;
-    constexpr UUID() = default;
-    constexpr explicit UUID(const u128& id) : uuid{id} {}
-    constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-
-    constexpr explicit operator bool() const {
-        return uuid[0] != INVALID_UUID[0] && uuid[1] != INVALID_UUID[1];
-    }
-
-    constexpr bool operator==(const UUID& rhs) const {
-        // TODO(DarkLordZach): Replace with uuid == rhs.uuid with C++20
-        return uuid[0] == rhs.uuid[0] && uuid[1] == rhs.uuid[1];
-    }
-
-    constexpr bool operator!=(const UUID& rhs) const {
-        return !operator==(rhs);
-    }
-
-    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    static UUID Generate();
-
-    // Set the UUID to {0,0} to be considered an invalid user
-    constexpr void Invalidate() {
-        uuid = INVALID_UUID;
-    }
-
-    std::string Format() const;
-    std::string FormatSwitch() const;
-};
-static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
-
-} // namespace Common

src/common/zstd_compression.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#pragma once
+
 #include <algorithm>
 #include <zstd.h>
 

src/common/zstd_compression.h

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <vector>
 
 #include "common/common_types.h"
@@ -19,7 +17,8 @@ namespace Common::Compression {
  *
  * @return the compressed data.
  */
-std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level);
+[[nodiscard]] std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size,
+                                               s32 compression_level);
 
 /**
  * Compresses a source memory region with Zstandard with the default compression level and returns
@@ -30,7 +29,7 @@ std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32
  *
  * @return the compressed data.
  */
-std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size);
+[[nodiscard]] std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size);
 
 /**
  * Decompresses a source memory region with Zstandard and returns the uncompressed data in a vector.
@@ -39,6 +38,6 @@ std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_siz
  *
  * @return the decompressed data.
  */
-std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed);
+[[nodiscard]] std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed);
 
 } // namespace Common::Compression

src/core/CMakeLists.txt

@@ -5,8 +5,6 @@ add_library(core STATIC
     arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
-    constants.cpp
-    constants.h
     core.cpp
     core.h
     core_cpu.cpp
@@ -90,10 +88,6 @@ add_library(core STATIC
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
-    frontend/applets/error.cpp
-    frontend/applets/error.h
-    frontend/applets/general_frontend.cpp
-    frontend/applets/general_frontend.h
     frontend/applets/profile_select.cpp
     frontend/applets/profile_select.h
     frontend/applets/software_keyboard.cpp
@@ -183,14 +177,12 @@ add_library(core STATIC
     hle/service/am/applet_oe.h
     hle/service/am/applets/applets.cpp
     hle/service/am/applets/applets.h
-    hle/service/am/applets/error.cpp
-    hle/service/am/applets/error.h
-    hle/service/am/applets/general_backend.cpp
-    hle/service/am/applets/general_backend.h
     hle/service/am/applets/profile_select.cpp
     hle/service/am/applets/profile_select.h
     hle/service/am/applets/software_keyboard.cpp
     hle/service/am/applets/software_keyboard.h
+    hle/service/am/applets/stub_applet.cpp
+    hle/service/am/applets/stub_applet.h
     hle/service/am/applets/web_browser.cpp
     hle/service/am/applets/web_browser.h
     hle/service/am/idle.cpp
@@ -312,8 +304,6 @@ add_library(core STATIC
     hle/service/mig/mig.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/mm/mm_u.cpp
     hle/service/mm/mm_u.h
     hle/service/ncm/ncm.cpp
@@ -330,9 +320,6 @@ add_library(core STATIC
     hle/service/nim/nim.h
     hle/service/npns/npns.cpp
     hle/service/npns/npns.h
-    hle/service/ns/errors.h
-    hle/service/ns/language.cpp
-    hle/service/ns/language.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -463,6 +450,9 @@ add_library(core STATIC
     settings.h
     telemetry_session.cpp
     telemetry_session.h
+    tracer/citrace.h
+    tracer/recorder.cpp
+    tracer/recorder.h
 )
 
 create_target_directory_groups(core)

src/core/arm/arm_interface.h

@@ -7,10 +7,6 @@
 #include <array>
 #include "common/common_types.h"
 
-namespace Common {
-struct PageTable;
-}
-
 namespace Kernel {
 enum class VMAPermission : u8;
 }
@@ -53,14 +49,8 @@ public:
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
-    /// Notifies CPU emulation that the current page table has changed.
-    ///
-    /// @param new_page_table                 The new page table.
-    /// @param new_address_space_size_in_bits The new usable size of the address space in bits.
-    ///                                       This can be either 32, 36, or 39 on official software.
-    ///
-    virtual void PageTableChanged(Common::PageTable& new_page_table,
-                                  std::size_t new_address_space_size_in_bits) = 0;
+    /// Notify CPU emulation that page tables have changed
+    virtual void PageTableChanged() = 0;
 
     /**
      * Set the Program Counter to an address

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -14,6 +14,7 @@
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -128,16 +129,18 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit(Common::PageTable& page_table,
-                                                          std::size_t address_space_bits) const {
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
+    auto* current_process = system.Kernel().CurrentProcess();
+    auto** const page_table = current_process->VMManager().page_table.pointers.data();
+
     Dynarmic::A64::UserConfig config;
 
     // Callbacks
     config.callbacks = cb.get();
 
     // Memory
-    config.page_table = reinterpret_cast<void**>(page_table.pointers.data());
-    config.page_table_address_space_bits = address_space_bits;
+    config.page_table = reinterpret_cast<void**>(page_table);
+    config.page_table_address_space_bits = current_process->VMManager().GetAddressSpaceWidth();
     config.silently_mirror_page_table = false;
 
     // Multi-process state
@@ -173,7 +176,12 @@ ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
                            std::size_t core_index)
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{system},
       core_index{core_index}, system{system},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
+    ThreadContext ctx{};
+    inner_unicorn.SaveContext(ctx);
+    PageTableChanged();
+    LoadContext(ctx);
+}
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
@@ -268,9 +276,8 @@ void ARM_Dynarmic::ClearExclusiveState() {
     jit->ClearExclusiveState();
 }
 
-void ARM_Dynarmic::PageTableChanged(Common::PageTable& page_table,
-                                    std::size_t new_address_space_size_in_bits) {
-    jit = MakeJit(page_table, new_address_space_size_in_bits);
+void ARM_Dynarmic::PageTableChanged() {
+    jit = MakeJit();
 }
 
 DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(std::size_t core_count) : monitor(core_count) {}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -48,12 +48,10 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
-    void PageTableChanged(Common::PageTable& new_page_table,
-                          std::size_t new_address_space_size_in_bits) override;
+    void PageTableChanged() override;
 
 private:
-    std::unique_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable& page_table,
-                                                std::size_t address_space_bits) const;
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
 
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;

src/core/arm/unicorn/arm_unicorn.h

@@ -41,7 +41,7 @@ public:
     void Run() override;
     void Step() override;
     void ClearInstructionCache() override;
-    void PageTableChanged(Common::PageTable&, std::size_t) override {}
+    void PageTableChanged() override{};
     void RecordBreak(GDBStub::BreakpointAddress bkpt);
 
 private:

src/core/constants.cpp

@@ -1,17 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/constants.h"
-
-namespace Core::Constants {
-const std::array<u8, 107> ACCOUNT_BACKUP_JPEG{{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-}};
-}

src/core/constants.h

@@ -1,17 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-// This is to consolidate system-wide constants that are used by multiple components of yuzu.
-// This is especially to prevent the case of something in frontend duplicating a constexpr array or
-// directly including some service header for the sole purpose of data.
-namespace Core::Constants {
-
-// ACC Service - Blank JPEG used as user icon in absentia of real one.
-extern const std::array<u8, 107> ACCOUNT_BACKUP_JPEG;
-
-} // namespace Core::Constants

src/core/core.cpp

@@ -3,7 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <array>
+#include <map>
 #include <memory>
+#include <thread>
 #include <utility>
 
 #include "common/file_util.h"
@@ -24,7 +26,7 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/service/am/applets/software_keyboard.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
@@ -32,7 +34,12 @@
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "file_sys/cheat_engine.h"
+#include "frontend/applets/profile_select.h"
+#include "frontend/applets/software_keyboard.h"
+#include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
+#include "video_core/gpu_asynch.h"
+#include "video_core/gpu_synch.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -74,7 +81,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system} {}
+    explicit Impl(System& system) : kernel{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -92,7 +99,6 @@ struct System::Impl {
         LOG_DEBUG(HW_Memory, "initialized OK");
 
         core_timing.Initialize();
-        cpu_core_manager.Initialize();
         kernel.Initialize();
 
         const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
@@ -107,7 +113,15 @@ struct System::Impl {
             content_provider = std::make_unique<FileSys::ContentProviderUnion>();
 
         /// Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();
+        if (profile_selector == nullptr)
+            profile_selector = std::make_unique<Core::Frontend::DefaultProfileSelectApplet>();
+        if (software_keyboard == nullptr)
+            software_keyboard = std::make_unique<Core::Frontend::DefaultSoftwareKeyboardApplet>();
+        if (web_browser == nullptr)
+            web_browser = std::make_unique<Core::Frontend::DefaultWebBrowserApplet>();
+
+        auto main_process = Kernel::Process::Create(system, "main");
+        kernel.MakeCurrentProcess(main_process.get());
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
@@ -120,10 +134,16 @@ struct System::Impl {
             return ResultStatus::ErrorVideoCore;
         }
 
-        gpu_core = VideoCore::CreateGPU(system);
-
         is_powered_on = true;
 
+        if (Settings::values.use_asynchronous_gpu_emulation) {
+            gpu_core = std::make_unique<VideoCommon::GPUAsynch>(system, *renderer);
+        } else {
+            gpu_core = std::make_unique<VideoCommon::GPUSynch>(system, *renderer);
+        }
+
+        cpu_core_manager.Initialize(system);
+
         LOG_DEBUG(Core, "Initialized OK");
 
         // Reset counters and set time origin to current frame
@@ -136,10 +156,20 @@ struct System::Impl {
     ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                       const std::string& filepath) {
         app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
         }
+        std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
+            app_loader->LoadKernelSystemMode();
+
+        if (system_mode.second != Loader::ResultStatus::Success) {
+            LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                         static_cast<int>(system_mode.second));
+
+            return ResultStatus::ErrorSystemMode;
+        }
 
         ResultStatus init_result{Init(system, emu_window)};
         if (init_result != ResultStatus::Success) {
@@ -149,9 +179,7 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader);
-        auto main_process = Kernel::Process::Create(system, "main");
-        const auto [load_result, load_parameters] = app_loader->Load(*main_process);
+        const Loader::ResultStatus load_result{app_loader->Load(*kernel.CurrentProcess())};
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
             Shutdown();
@@ -159,16 +187,6 @@ struct System::Impl {
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
-        kernel.MakeCurrentProcess(main_process.get());
-
-        // Main process has been loaded and been made current.
-        // Begin GPU and CPU execution.
-        gpu_core->Start();
-        cpu_core_manager.StartThreads();
-
-        // All threads are started, begin main process execution, now that we're in the clear.
-        main_process->Run(load_parameters->main_thread_priority,
-                          load_parameters->main_thread_stack_size);
 
         status = ResultStatus::Success;
         return status;
@@ -206,7 +224,9 @@ struct System::Impl {
         app_loader.reset();
 
         // Clear all applets
-        applet_manager.ClearAll();
+        profile_selector.reset();
+        software_keyboard.reset();
+        web_browser.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -245,7 +265,9 @@ struct System::Impl {
     std::unique_ptr<FileSys::CheatEngine> cheat_engine;
 
     /// Frontend applets
-    Service::AM::Applets::AppletManager applet_manager;
+    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_selector;
+    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -455,20 +477,20 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
-    impl->applet_manager.SetAppletFrontendSet(std::move(set));
+void System::SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet) {
+    impl->profile_selector = std::move(applet);
 }
 
-void System::SetDefaultAppletFrontendSet() {
-    impl->applet_manager.SetDefaultAppletFrontendSet();
+const Frontend::ProfileSelectApplet& System::GetProfileSelector() const {
+    return *impl->profile_selector;
 }
 
-Service::AM::Applets::AppletManager& System::GetAppletManager() {
-    return impl->applet_manager;
+void System::SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet) {
+    impl->software_keyboard = std::move(applet);
 }
 
-const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
-    return impl->applet_manager;
+const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
+    return *impl->software_keyboard;
 }
 
 void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
@@ -492,6 +514,18 @@ void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
     impl->content_provider->ClearSlot(slot);
 }
 
+void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
+    impl->web_browser = std::move(applet);
+}
+
+Frontend::WebBrowserApplet& System::GetWebBrowser() {
+    return *impl->web_browser;
+}
+
+const Frontend::WebBrowserApplet& System::GetWebBrowser() const {
+    return *impl->web_browser;
+}
+
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -14,6 +14,9 @@
 
 namespace Core::Frontend {
 class EmuWindow;
+class ProfileSelectApplet;
+class SoftwareKeyboardApplet;
+class WebBrowserApplet;
 } // namespace Core::Frontend
 
 namespace FileSys {
@@ -35,18 +38,9 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader
 
-namespace Service {
-
-namespace AM::Applets {
-struct AppletFrontendSet;
-class AppletManager;
-} // namespace AM::Applets
-
-namespace SM {
+namespace Service::SM {
 class ServiceManager;
-} // namespace SM
-
-} // namespace Service
+} // namespace Service::SM
 
 namespace Tegra {
 class DebugContext;
@@ -98,6 +92,7 @@ public:
         Success,             ///< Succeeded
         ErrorNotInitialized, ///< Error trying to use core prior to initialization
         ErrorGetLoader,      ///< Error finding the correct application loader
+        ErrorSystemMode,     ///< Error determining the system mode
         ErrorSystemFiles,    ///< Error in finding system files
         ErrorSharedFont,     ///< Error in finding shared font
         ErrorVideoCore,      ///< Error in the video core
@@ -265,13 +260,18 @@ public:
     void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
                            VAddr code_region_start, VAddr code_region_end);
 
-    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
+    void SetProfileSelector(std::unique_ptr<Frontend::ProfileSelectApplet> applet);
 
-    void SetDefaultAppletFrontendSet();
+    const Frontend::ProfileSelectApplet& GetProfileSelector() const;
 
-    Service::AM::Applets::AppletManager& GetAppletManager();
+    void SetSoftwareKeyboard(std::unique_ptr<Frontend::SoftwareKeyboardApplet> applet);
 
-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    const Frontend::SoftwareKeyboardApplet& GetSoftwareKeyboard() const;
+
+    void SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet);
+
+    Frontend::WebBrowserApplet& GetWebBrowser();
+    const Frontend::WebBrowserApplet& GetWebBrowser() const;
 
     void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
 

src/core/core_timing_util.cpp

@@ -13,40 +13,52 @@ namespace Core::Timing {
 
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
-s64 msToCycles(std::chrono::milliseconds ms) {
-    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (us > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ms.count() / 1000);
+        return BASE_CLOCK_RATE * (us / 1000000);
     }
-    return (BASE_CLOCK_RATE * ms.count()) / 1000;
+    return (BASE_CLOCK_RATE * us) / 1000000;
 }
 
-s64 usToCycles(std::chrono::microseconds us) {
-    if (static_cast<u64>(us.count() / 1000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (us > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us.count() / 1000000);
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
     }
-    return (BASE_CLOCK_RATE * us.count()) / 1000000;
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
 }
 
-s64 nsToCycles(std::chrono::nanoseconds ns) {
-    if (static_cast<u64>(ns.count() / 1000000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ns.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns.count() / 1000000000);
+        return BASE_CLOCK_RATE * (ns / 1000000000);
     }
-    return (BASE_CLOCK_RATE * ns.count()) / 1000000000;
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks) {

src/core/core_timing_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <chrono>
 #include "common/common_types.h"
 
 namespace Core::Timing {
@@ -14,20 +13,53 @@ namespace Core::Timing {
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
 constexpr u64 CNTFREQ = 19200000;           // Value from fusee.
 
-s64 msToCycles(std::chrono::milliseconds ms);
-s64 usToCycles(std::chrono::microseconds us);
-s64 nsToCycles(std::chrono::nanoseconds ns);
-
-inline std::chrono::milliseconds CyclesToMs(s64 cycles) {
-    return std::chrono::milliseconds(cycles * 1000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
 }
 
-inline std::chrono::nanoseconds CyclesToNs(s64 cycles) {
-    return std::chrono::nanoseconds(cycles * 1000000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
 }
 
-inline std::chrono::microseconds CyclesToUs(s64 cycles) {
-    return std::chrono::microseconds(cycles * 1000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks);

src/core/cpu_core_manager.cpp

@@ -19,19 +19,17 @@ void RunCpuCore(const System& system, Cpu& cpu_state) {
 }
 } // Anonymous namespace
 
-CpuCoreManager::CpuCoreManager(System& system) : system{system} {}
+CpuCoreManager::CpuCoreManager() = default;
 CpuCoreManager::~CpuCoreManager() = default;
 
-void CpuCoreManager::Initialize() {
+void CpuCoreManager::Initialize(System& system) {
     barrier = std::make_unique<CpuBarrier>();
     exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());
 
     for (std::size_t index = 0; index < cores.size(); ++index) {
         cores[index] = std::make_unique<Cpu>(system, *exclusive_monitor, *barrier, index);
     }
-}
 
-void CpuCoreManager::StartThreads() {
     // Create threads for CPU cores 1-3, and build thread_to_cpu map
     // CPU core 0 is run on the main thread
     thread_to_cpu[std::this_thread::get_id()] = cores[0].get();

src/core/cpu_core_manager.h

@@ -18,7 +18,7 @@ class System;
 
 class CpuCoreManager {
 public:
-    explicit CpuCoreManager(System& system);
+    CpuCoreManager();
     CpuCoreManager(const CpuCoreManager&) = delete;
     CpuCoreManager(CpuCoreManager&&) = delete;
 
@@ -27,8 +27,7 @@ public:
     CpuCoreManager& operator=(const CpuCoreManager&) = delete;
     CpuCoreManager& operator=(CpuCoreManager&&) = delete;
 
-    void Initialize();
-    void StartThreads();
+    void Initialize(System& system);
     void Shutdown();
 
     Cpu& GetCore(std::size_t index);
@@ -55,8 +54,6 @@ private:
 
     /// Map of guest threads to CPU cores
     std::map<std::thread::id, Cpu*> thread_to_cpu;
-
-    System& system;
 };
 
 } // namespace Core

src/core/file_sys/control_metadata.cpp

@@ -87,10 +87,6 @@ u64 NACP::GetDefaultJournalSaveSize() const {
     return raw.user_account_save_data_journal_size;
 }
 
-u32 NACP::GetSupportedLanguages() const {
-    return raw.supported_languages;
-}
-
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
     std::memcpy(out.data(), &raw, sizeof(RawNACP));

src/core/file_sys/control_metadata.h

@@ -109,7 +109,6 @@ public:
     std::string GetVersionString() const;
     u64 GetDefaultNormalSaveSize() const;
     u64 GetDefaultJournalSaveSize() const;
-    u32 GetSupportedLanguages() const;
     std::vector<u8> GetRawBytes() const;
 
 private:

src/core/frontend/applets/error.cpp

@@ -1,34 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/frontend/applets/error.h"
-
-namespace Core::Frontend {
-
-ErrorApplet::~ErrorApplet() = default;
-
-void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
-    LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
-}
-
-void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                                std::function<void()> finished) const {
-    LOG_CRITICAL(
-        Service_Fatal,
-        "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
-        static_cast<u32>(error.module.Value()), error.description.Value(), error.raw, time.count());
-}
-
-void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
-                                             std::string detail_text,
-                                             std::function<void()> finished) const {
-    LOG_CRITICAL(Service_Fatal,
-                 "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
-    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
-    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/error.h

@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <functional>
-
-#include "core/hle/result.h"
-
-namespace Core::Frontend {
-
-class ErrorApplet {
-public:
-    virtual ~ErrorApplet();
-
-    virtual void ShowError(ResultCode error, std::function<void()> finished) const = 0;
-
-    virtual void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                        std::function<void()> finished) const = 0;
-
-    virtual void ShowCustomErrorText(ResultCode error, std::string dialog_text,
-                                     std::string fullscreen_text,
-                                     std::function<void()> finished) const = 0;
-};
-
-class DefaultErrorApplet final : public ErrorApplet {
-public:
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
-                                std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string main_text, std::string detail_text,
-                             std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend

src/core/frontend/applets/general_frontend.cpp

@@ -1,27 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/frontend/applets/general_frontend.h"
-
-namespace Core::Frontend {
-
-PhotoViewerApplet::~PhotoViewerApplet() = default;
-
-DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() {}
-
-void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
-                                                        std::function<void()> finished) const {
-    LOG_INFO(Service_AM,
-             "Application requested frontend to display stored photos for title_id={:016X}",
-             title_id);
-    finished();
-}
-
-void DefaultPhotoViewerApplet::ShowAllPhotos(std::function<void()> finished) const {
-    LOG_INFO(Service_AM, "Application requested frontend to display all stored photos.");
-    finished();
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/general_frontend.h

@@ -1,28 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include "common/common_types.h"
-
-namespace Core::Frontend {
-
-class PhotoViewerApplet {
-public:
-    virtual ~PhotoViewerApplet();
-
-    virtual void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const = 0;
-    virtual void ShowAllPhotos(std::function<void()> finished) const = 0;
-};
-
-class DefaultPhotoViewerApplet final : public PhotoViewerApplet {
-public:
-    ~DefaultPhotoViewerApplet() override;
-
-    void ShowPhotosForApplication(u64 title_id, std::function<void()> finished) const override;
-    void ShowAllPhotos(std::function<void()> finished) const override;
-};
-
-} // namespace Core::Frontend

src/core/frontend/applets/profile_select.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/frontend/applets/profile_select.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 
 namespace Core::Frontend {
@@ -11,9 +10,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 

src/core/frontend/applets/profile_select.h

@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <optional>
-#include "common/uuid.h"
+#include "core/hle/service/acc/profile_manager.h"
 
 namespace Core::Frontend {
 
@@ -14,12 +14,14 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.cpp

@@ -10,8 +10,6 @@
 
 namespace Core::Frontend {
 
-GraphicsContext::~GraphicsContext() = default;
-
 class EmuWindow::TouchState : public Input::Factory<Input::TouchDevice>,
                               public std::enable_shared_from_this<TouchState> {
 public:

src/core/frontend/emu_window.h

@@ -19,8 +19,6 @@ namespace Core::Frontend {
  */
 class GraphicsContext {
 public:
-    virtual ~GraphicsContext();
-
     /// Makes the graphics context current for the caller thread
     virtual void MakeCurrent() = 0;
 
@@ -169,7 +167,8 @@ private:
      * For the request to be honored, EmuWindow implementations will usually reimplement this
      * function.
      */
-    virtual void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned>) {
+    virtual void OnMinimalClientAreaChangeRequest(
+        const std::pair<unsigned, unsigned>& minimal_size) {
         // By default, ignore this request and do nothing.
     }
 

src/core/frontend/framebuffer_layout.cpp

@@ -20,7 +20,7 @@ static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
                                 static_cast<T>(std::round(scale * screen_aspect_ratio))};
 }
 
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
     ASSERT(width > 0);
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
@@ -29,23 +29,22 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
 
     const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
                                        ScreenUndocked::Width};
-    const auto window_aspect_ratio = static_cast<float>(height) / width;
+    Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
+    Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
 
-    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
-    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
+    float window_aspect_ratio = static_cast<float>(height) / width;
 
     if (window_aspect_ratio < emulation_aspect_ratio) {
         screen = screen.TranslateX((screen_window_area.GetWidth() - screen.GetWidth()) / 2);
     } else {
         screen = screen.TranslateY((height - screen.GetHeight()) / 2);
     }
-
     res.screen = screen;
     return res;
 }
 
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
-    u32 width, height;
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale) {
+    int width, height;
 
     if (Settings::values.use_docked_mode) {
         width = ScreenDocked::WidthDocked * res_scale;

src/core/frontend/framebuffer_layout.h

@@ -8,22 +8,15 @@
 
 namespace Layout {
 
-enum ScreenUndocked : u32 {
-    Width = 1280,
-    Height = 720,
-};
-
-enum ScreenDocked : u32 {
-    WidthDocked = 1920,
-    HeightDocked = 1080,
-};
+enum ScreenUndocked : unsigned { Width = 1280, Height = 720 };
+enum ScreenDocked : unsigned { WidthDocked = 1920, HeightDocked = 1080 };
 
 /// Describes the layout of the window framebuffer
 struct FramebufferLayout {
-    u32 width{ScreenUndocked::Width};
-    u32 height{ScreenUndocked::Height};
+    unsigned width{ScreenUndocked::Width};
+    unsigned height{ScreenUndocked::Height};
 
-    Common::Rectangle<u32> screen;
+    Common::Rectangle<unsigned> screen;
 
     /**
      * Returns the ration of pixel size of the screen, compared to the native size of the undocked
@@ -40,12 +33,12 @@ struct FramebufferLayout {
  * @param height Window framebuffer height in pixels
  * @return Newly created FramebufferLayout object with default screen regions initialized
  */
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height);
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height);
 
 /**
  * Convenience method to get frame layout by resolution scale
  * @param res_scale resolution scale factor
  */
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale);
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale);
 
 } // namespace Layout

src/core/hle/ipc_helpers.h

@@ -438,7 +438,7 @@ inline float RequestParser::Pop() {
 template <>
 inline double RequestParser::Pop() {
     const u64 value = Pop<u64>();
-    double real;
+    float real;
     std::memcpy(&real, &value, sizeof(real));
     return real;
 }

src/core/hle/kernel/hle_ipc.cpp

@@ -43,7 +43,7 @@ void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& s
 }
 
 SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
-    const std::string& reason, u64 timeout, WakeupCallback&& callback,
+    SharedPtr<Thread> thread, const std::string& reason, u64 timeout, WakeupCallback&& callback,
     SharedPtr<WritableEvent> writable_event) {
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->SetWakeupCallback([context = *this, callback](
@@ -58,7 +58,7 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event) {
         // Create event if not provided
-        const auto pair = WritableEvent::CreateEventPair(kernel, ResetType::Automatic,
+        const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
                                                          "HLE Pause Event: " + reason);
         writable_event = pair.writable;
     }
@@ -76,9 +76,8 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     return writable_event;
 }
 
-HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session,
-                                     SharedPtr<Thread> thread)
-    : server_session(std::move(server_session)), thread(std::move(thread)) {
+HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)
+    : server_session(std::move(server_session)) {
     cmd_buf[0] = 0;
 }
 

src/core/hle/kernel/hle_ipc.h

@@ -97,7 +97,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(SharedPtr<ServerSession> session, SharedPtr<Thread> thread);
+    explicit HLERequestContext(SharedPtr<ServerSession> session);
     ~HLERequestContext();
 
     /// Returns a pointer to the IPC command buffer for this request.
@@ -119,6 +119,7 @@ public:
     /**
      * Puts the specified guest thread to sleep until the returned event is signaled or until the
      * specified timeout expires.
+     * @param thread Thread to be put to sleep.
      * @param reason Reason for pausing the thread, to be used for debugging purposes.
      * @param timeout Timeout in nanoseconds after which the thread will be awoken and the callback
      * invoked with a Timeout reason.
@@ -129,8 +130,8 @@ public:
      * created.
      * @returns Event that when signaled will resume the thread and call the callback function.
      */
-    SharedPtr<WritableEvent> SleepClientThread(const std::string& reason, u64 timeout,
-                                               WakeupCallback&& callback,
+    SharedPtr<WritableEvent> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
+                                               u64 timeout, WakeupCallback&& callback,
                                                SharedPtr<WritableEvent> writable_event = nullptr);
 
     /// Populates this context with data from the requesting process/thread.
@@ -267,7 +268,6 @@ private:
 
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     SharedPtr<Kernel::ServerSession> server_session;
-    SharedPtr<Thread> thread;
     // TODO(yuriks): Check common usage of this and optimize size accordingly
     boost::container::small_vector<SharedPtr<Object>, 8> move_objects;
     boost::container::small_vector<SharedPtr<Object>, 8> copy_objects;

src/core/hle/kernel/kernel.cpp

@@ -46,7 +46,8 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
 
     bool resume = true;
 
-    if (thread->GetStatus() == ThreadStatus::WaitSynch ||
+    if (thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+        thread->GetStatus() == ThreadStatus::WaitSynchAll ||
         thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
         // Remove the thread from each of its waiting objects' waitlists
         for (const auto& object : thread->GetWaitObjects()) {
@@ -181,12 +182,7 @@ void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
 
 void KernelCore::MakeCurrentProcess(Process* process) {
     impl->current_process = process;
-
-    if (process == nullptr) {
-        return;
-    }
-
-    Memory::SetCurrentPageTable(*process);
+    Memory::SetCurrentPageTable(&process->VMManager().page_table);
 }
 
 Process* KernelCore::CurrentProcess() {

src/core/hle/kernel/object.h

@@ -33,8 +33,8 @@ enum class HandleType : u32 {
 };
 
 enum class ResetType {
-    Automatic, ///< Reset automatically on object acquisition
-    Manual,    ///< Never reset automatically
+    OneShot, ///< Reset automatically on object acquisition
+    Sticky,  ///< Never reset automatically
 };
 
 class Object : NonCopyable {

src/core/hle/kernel/process.cpp

@@ -28,20 +28,21 @@ namespace {
  *
  * @param owner_process The parent process for the main thread
  * @param kernel The kernel instance to create the main thread under.
+ * @param entry_point The address at which the thread should start execution
  * @param priority The priority to give the main thread
  */
-void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
-    const auto& vm_manager = owner_process.VMManager();
-    const VAddr entry_point = vm_manager.GetCodeRegionBaseAddress();
-    const VAddr stack_top = vm_manager.GetTLSIORegionEndAddress();
+void SetupMainThread(Process& owner_process, KernelCore& kernel, VAddr entry_point, u32 priority) {
+    // Initialize new "main" thread
+    const VAddr stack_top = owner_process.VMManager().GetTLSIORegionEndAddress();
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
                                      owner_process.GetIdealCore(), stack_top, owner_process);
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
-    thread->GetContext().cpu_registers[1] = thread_handle;
+    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
+    thread->SetGuestHandle(guest_handle);
+    thread->GetContext().cpu_registers[1] = guest_handle;
 
     // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
     thread->ResumeFromWait();
@@ -105,6 +106,8 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
     is_64bit_process = metadata.Is64BitProgram();
 
     vm_manager.Reset(metadata.GetAddressSpaceType());
+    // Ensure that the potentially resized page table is seen by CPU backends.
+    Memory::SetCurrentPageTable(&vm_manager.page_table);
 
     const auto& caps = metadata.GetKernelCapabilities();
     const auto capability_init_result =
@@ -116,7 +119,7 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
     return handle_table.SetSize(capabilities.GetHandleTableSize());
 }
 
-void Process::Run(s32 main_thread_priority, u64 stack_size) {
+void Process::Run(VAddr entry_point, s32 main_thread_priority, u64 stack_size) {
     // The kernel always ensures that the given stack size is page aligned.
     main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
 
@@ -132,7 +135,7 @@ void Process::Run(s32 main_thread_priority, u64 stack_size) {
     vm_manager.LogLayout();
     ChangeStatus(ProcessStatus::Running);
 
-    SetupMainThread(*this, kernel, main_thread_priority);
+    SetupMainThread(*this, kernel, entry_point, main_thread_priority);
 }
 
 void Process::PrepareForTermination() {
@@ -147,7 +150,8 @@ void Process::PrepareForTermination() {
                 continue;
 
             // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynch,
+            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+                           thread->GetStatus() == ThreadStatus::WaitSynchAll,
                        "Exiting processes with non-waiting threads is currently unimplemented");
 
             thread->Stop();
@@ -238,11 +242,13 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
     MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeData);
 
     code_memory_size += module_.memory.size();
+
+    // Clear instruction cache in CPU JIT
+    system.InvalidateCpuInstructionCaches();
 }
 
 Process::Process(Core::System& system)
-    : WaitObject{system.Kernel()}, vm_manager{system},
-      address_arbiter{system}, mutex{system}, system{system} {}
+    : WaitObject{system.Kernel()}, address_arbiter{system}, mutex{system}, system{system} {}
 
 Process::~Process() = default;
 

src/core/hle/kernel/process.h

@@ -10,6 +10,7 @@
 #include <list>
 #include <string>
 #include <vector>
+#include <boost/container/static_vector.hpp>
 #include "common/common_types.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/handle_table.h"
@@ -224,12 +225,9 @@ public:
     ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata);
 
     /**
-     * Starts the main application thread for this process.
-     *
-     * @param main_thread_priority The priority for the main thread.
-     * @param stack_size           The stack size for the main thread in bytes.
+     * Applies address space changes and launches the process main thread.
      */
-    void Run(s32 main_thread_priority, u64 stack_size);
+    void Run(VAddr entry_point, s32 main_thread_priority, u64 stack_size);
 
     /**
      * Prepares a process for termination by stopping all of its threads

src/core/hle/kernel/readable_event.cpp

@@ -21,9 +21,8 @@ bool ReadableEvent::ShouldWait(const Thread* thread) const {
 void ReadableEvent::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 
-    if (reset_type == ResetType::Automatic) {
+    if (reset_type == ResetType::OneShot)
         signaled = false;
-    }
 }
 
 void ReadableEvent::Signal() {

src/core/hle/kernel/server_session.cpp

@@ -130,7 +130,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
     // similar.
-    Kernel::HLERequestContext context(this, thread);
+    Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
     context.PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
 

src/core/hle/kernel/svc.cpp

@@ -424,7 +424,7 @@ static ResultCode GetProcessId(Core::System& system, u64* process_id, Handle han
 /// Default thread wakeup callback for WaitSynchronization
 static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                         SharedPtr<WaitObject> object, std::size_t index) {
-    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynch);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
 
     if (reason == ThreadWakeupReason::Timeout) {
         thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
@@ -502,7 +502,7 @@ static ResultCode WaitSynchronization(Core::System& system, Handle* index, VAddr
     }
 
     thread->SetWaitObjects(std::move(objects));
-    thread->SetStatus(ThreadStatus::WaitSynch);
+    thread->SetStatus(ThreadStatus::WaitSynchAny);
 
     // Create an event to wake the thread up after the specified nanosecond delay has passed
     thread->WakeAfterDelay(nano_seconds);
@@ -518,14 +518,16 @@ static ResultCode CancelSynchronization(Core::System& system, Handle thread_hand
     LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
                   thread_handle);
         return ERR_INVALID_HANDLE;
     }
 
-    thread->CancelWait();
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
+    thread->SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
+    thread->ResumeFromWait();
     return RESULT_SUCCESS;
 }
 
@@ -1187,142 +1189,6 @@ static ResultCode QueryMemory(Core::System& system, VAddr memory_info_address,
                               query_address);
 }
 
-static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
-                                       u64 src_address, u64 size) {
-    LOG_DEBUG(Kernel_SVC,
-              "called. process_handle=0x{:08X}, dst_address=0x{:016X}, "
-              "src_address=0x{:016X}, size=0x{:016X}",
-              process_handle, dst_address, src_address, size);
-
-    if (!Common::Is4KBAligned(src_address)) {
-        LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
-                  src_address);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(dst_address)) {
-        LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
-                  dst_address);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (size == 0 || !Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X})", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!IsValidAddressRange(dst_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Destination address range overflows the address space (dst_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  dst_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!IsValidAddressRange(src_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Source address range overflows the address space (src_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  src_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    auto process = handle_table.Get<Process>(process_handle);
-    if (!process) {
-        LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
-                  process_handle);
-        return ERR_INVALID_HANDLE;
-    }
-
-    auto& vm_manager = process->VMManager();
-    if (!vm_manager.IsWithinAddressSpace(src_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Source address range is not within the address space (src_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  src_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!vm_manager.IsWithinASLRRegion(dst_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  dst_address, size);
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.MapCodeMemory(dst_address, src_address, size);
-}
-
-static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_handle,
-                                         u64 dst_address, u64 src_address, u64 size) {
-    LOG_DEBUG(Kernel_SVC,
-              "called. process_handle=0x{:08X}, dst_address=0x{:016X}, src_address=0x{:016X}, "
-              "size=0x{:016X}",
-              process_handle, dst_address, src_address, size);
-
-    if (!Common::Is4KBAligned(dst_address)) {
-        LOG_ERROR(Kernel_SVC, "dst_address is not page-aligned (dst_address=0x{:016X}).",
-                  dst_address);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(src_address)) {
-        LOG_ERROR(Kernel_SVC, "src_address is not page-aligned (src_address=0x{:016X}).",
-                  src_address);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (size == 0 || Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is zero or not page-aligned (size=0x{:016X}).", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!IsValidAddressRange(dst_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Destination address range overflows the address space (dst_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  dst_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!IsValidAddressRange(src_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Source address range overflows the address space (src_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  src_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
-    auto process = handle_table.Get<Process>(process_handle);
-    if (!process) {
-        LOG_ERROR(Kernel_SVC, "Invalid process handle specified (handle=0x{:08X}).",
-                  process_handle);
-        return ERR_INVALID_HANDLE;
-    }
-
-    auto& vm_manager = process->VMManager();
-    if (!vm_manager.IsWithinAddressSpace(src_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Source address range is not within the address space (src_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  src_address, size);
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (!vm_manager.IsWithinASLRRegion(dst_address, size)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
-                  "size=0x{:016X}).",
-                  dst_address, size);
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.UnmapCodeMemory(dst_address, src_address, size);
-}
-
 /// Exits the current process
 static void ExitProcess(Core::System& system) {
     auto* current_process = system.Kernel().CurrentProcess();
@@ -1342,7 +1208,7 @@ static void ExitProcess(Core::System& system) {
 /// Creates a new thread
 static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
                                VAddr stack_top, u32 priority, s32 processor_id) {
-    LOG_DEBUG(Kernel_SVC,
+    LOG_TRACE(Kernel_SVC,
               "called entrypoint=0x{:08X}, arg=0x{:08X}, stacktop=0x{:08X}, "
               "threadpriority=0x{:08X}, processorid=0x{:08X} : created handle=0x{:08X}",
               entry_point, arg, stack_top, priority, processor_id, *out_handle);
@@ -1378,22 +1244,20 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
         return ERR_INVALID_THREAD_PRIORITY;
     }
 
+    const std::string name = fmt::format("thread-{:X}", entry_point);
     auto& kernel = system.Kernel();
     CASCADE_RESULT(SharedPtr<Thread> thread,
-                   Thread::Create(kernel, "", entry_point, priority, arg, processor_id, stack_top,
+                   Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
                                   *current_process));
 
-    const auto new_thread_handle = current_process->GetHandleTable().Create(thread);
-    if (new_thread_handle.Failed()) {
+    const auto new_guest_handle = current_process->GetHandleTable().Create(thread);
+    if (new_guest_handle.Failed()) {
         LOG_ERROR(Kernel_SVC, "Failed to create handle with error=0x{:X}",
-                  new_thread_handle.Code().raw);
-        return new_thread_handle.Code();
+                  new_guest_handle.Code().raw);
+        return new_guest_handle.Code();
     }
-    *out_handle = *new_thread_handle;
-
-    // Set the thread name for debugging purposes.
-    thread->SetName(
-        fmt::format("thread[entry_point={:X}, handle={:X}]", entry_point, *new_thread_handle));
+    thread->SetGuestHandle(*new_guest_handle);
+    *out_handle = *new_guest_handle;
 
     system.CpuCore(thread->GetProcessorID()).PrepareReschedule();
 
@@ -1402,7 +1266,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
 
 /// Starts the thread for the provided handle
 static ResultCode StartThread(Core::System& system, Handle thread_handle) {
-    LOG_DEBUG(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
+    LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
     const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
@@ -1425,7 +1289,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
 
 /// Called when a thread exits
 static void ExitThread(Core::System& system) {
-    LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC());
+    LOG_TRACE(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC());
 
     auto* const current_thread = system.CurrentScheduler().GetCurrentThread();
     current_thread->Stop();
@@ -1435,7 +1299,7 @@ static void ExitThread(Core::System& system) {
 
 /// Sleep the current thread
 static void SleepThread(Core::System& system, s64 nanoseconds) {
-    LOG_DEBUG(Kernel_SVC, "called nanoseconds={}", nanoseconds);
+    LOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
 
     enum class SleepType : s64 {
         YieldWithoutLoadBalancing = 0,
@@ -1880,51 +1744,11 @@ static ResultCode GetThreadCoreMask(Core::System& system, Handle thread_handle,
 }
 
 static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle, u32 core,
-                                    u64 affinity_mask) {
-    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, core=0x{:X}, affinity_mask=0x{:016X}",
-              thread_handle, core, affinity_mask);
+                                    u64 mask) {
+    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:016X}, core=0x{:X}", thread_handle,
+              mask, core);
 
-    const auto* const current_process = system.Kernel().CurrentProcess();
-
-    if (core == static_cast<u32>(THREADPROCESSORID_IDEAL)) {
-        const u8 ideal_cpu_core = current_process->GetIdealCore();
-
-        ASSERT(ideal_cpu_core != static_cast<u8>(THREADPROCESSORID_IDEAL));
-
-        // Set the target CPU to the ideal core specified by the process.
-        core = ideal_cpu_core;
-        affinity_mask = 1ULL << core;
-    } else {
-        const u64 core_mask = current_process->GetCoreMask();
-
-        if ((core_mask | affinity_mask) != core_mask) {
-            LOG_ERROR(
-                Kernel_SVC,
-                "Invalid processor ID specified (core_mask=0x{:08X}, affinity_mask=0x{:016X})",
-                core_mask, affinity_mask);
-            return ERR_INVALID_PROCESSOR_ID;
-        }
-
-        if (affinity_mask == 0) {
-            LOG_ERROR(Kernel_SVC, "Specfified affinity mask is zero.");
-            return ERR_INVALID_COMBINATION;
-        }
-
-        if (core < Core::NUM_CPU_CORES) {
-            if ((affinity_mask & (1ULL << core)) == 0) {
-                LOG_ERROR(Kernel_SVC,
-                          "Core is not enabled for the current mask, core={}, mask={:016X}", core,
-                          affinity_mask);
-                return ERR_INVALID_COMBINATION;
-            }
-        } else if (core != static_cast<u32>(THREADPROCESSORID_DONT_CARE) &&
-                   core != static_cast<u32>(THREADPROCESSORID_DONT_UPDATE)) {
-            LOG_ERROR(Kernel_SVC, "Invalid processor ID specified (core={}).", core);
-            return ERR_INVALID_PROCESSOR_ID;
-        }
-    }
-
-    const auto& handle_table = current_process->GetHandleTable();
+    const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
     const SharedPtr<Thread> thread = handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         LOG_ERROR(Kernel_SVC, "Thread handle does not exist, thread_handle=0x{:08X}",
@@ -1932,7 +1756,40 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
         return ERR_INVALID_HANDLE;
     }
 
-    thread->ChangeCore(core, affinity_mask);
+    if (core == static_cast<u32>(THREADPROCESSORID_IDEAL)) {
+        const u8 ideal_cpu_core = thread->GetOwnerProcess()->GetIdealCore();
+
+        ASSERT(ideal_cpu_core != static_cast<u8>(THREADPROCESSORID_IDEAL));
+
+        // Set the target CPU to the ideal core specified by the process.
+        core = ideal_cpu_core;
+        mask = 1ULL << core;
+    }
+
+    if (mask == 0) {
+        LOG_ERROR(Kernel_SVC, "Mask is 0");
+        return ERR_INVALID_COMBINATION;
+    }
+
+    /// This value is used to only change the affinity mask without changing the current ideal core.
+    static constexpr u32 OnlyChangeMask = static_cast<u32>(-3);
+
+    if (core == OnlyChangeMask) {
+        core = thread->GetIdealCore();
+    } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
+        LOG_ERROR(Kernel_SVC, "Invalid core specified, got {}", core);
+        return ERR_INVALID_PROCESSOR_ID;
+    }
+
+    // Error out if the input core isn't enabled in the input mask.
+    if (core < Core::NUM_CPU_CORES && (mask & (1ull << core)) == 0) {
+        LOG_ERROR(Kernel_SVC, "Core is not enabled for the current mask, core={}, mask={:016X}",
+                  core, mask);
+        return ERR_INVALID_COMBINATION;
+    }
+
+    thread->ChangeCore(core, mask);
+
     return RESULT_SUCCESS;
 }
 
@@ -1987,7 +1844,7 @@ static ResultCode CreateEvent(Core::System& system, Handle* write_handle, Handle
 
     auto& kernel = system.Kernel();
     const auto [readable_event, writable_event] =
-        WritableEvent::CreateEventPair(kernel, ResetType::Manual, "CreateEvent");
+        WritableEvent::CreateEventPair(kernel, ResetType::Sticky, "CreateEvent");
 
     HandleTable& handle_table = kernel.CurrentProcess()->GetHandleTable();
 
@@ -2190,8 +2047,8 @@ static ResultCode GetProcessList(Core::System& system, u32* out_num_processes,
     return RESULT_SUCCESS;
 }
 
-static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
-                                u32 out_thread_ids_size, Handle debug_handle) {
+ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
+                         u32 out_thread_ids_size, Handle debug_handle) {
     // TODO: Handle this case when debug events are supported.
     UNIMPLEMENTED_IF(debug_handle != InvalidHandle);
 
@@ -2295,7 +2152,7 @@ static const FunctionDef SVC_Table[] = {
     {0x33, SvcWrap<GetThreadContext>, "GetThreadContext"},
     {0x34, SvcWrap<WaitForAddress>, "WaitForAddress"},
     {0x35, SvcWrap<SignalToAddress>, "SignalToAddress"},
-    {0x36, nullptr, "SynchronizePreemptionState"},
+    {0x36, nullptr, "Unknown"},
     {0x37, nullptr, "Unknown"},
     {0x38, nullptr, "Unknown"},
     {0x39, nullptr, "Unknown"},
@@ -2360,8 +2217,8 @@ static const FunctionDef SVC_Table[] = {
     {0x74, nullptr, "MapProcessMemory"},
     {0x75, nullptr, "UnmapProcessMemory"},
     {0x76, SvcWrap<QueryProcessMemory>, "QueryProcessMemory"},
-    {0x77, SvcWrap<MapProcessCodeMemory>, "MapProcessCodeMemory"},
-    {0x78, SvcWrap<UnmapProcessCodeMemory>, "UnmapProcessCodeMemory"},
+    {0x77, nullptr, "MapProcessCodeMemory"},
+    {0x78, nullptr, "UnmapProcessCodeMemory"},
     {0x79, nullptr, "CreateProcess"},
     {0x7A, nullptr, "StartProcess"},
     {0x7B, nullptr, "TerminateProcess"},

src/core/hle/kernel/svc_wrap.h

@@ -44,13 +44,6 @@ void SvcWrap(Core::System& system) {
         func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            Param(system, 2), Param(system, 3))
-                           .raw);
-}
-
 template <ResultCode func(Core::System&, u32*)>
 void SvcWrap(Core::System& system) {
     u32 param = 0;

src/core/hle/kernel/thread.cpp

@@ -75,9 +75,9 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
-    const s64 cycles = Core::Timing::nsToCycles(std::chrono::nanoseconds{nanoseconds});
     Core::System::GetInstance().CoreTiming().ScheduleEventThreadsafe(
-        cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
+        Core::Timing::nsToCycles(nanoseconds), kernel.ThreadWakeupCallbackEventType(),
+        callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
@@ -101,7 +101,8 @@ void Thread::ResumeFromWait() {
     ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");
 
     switch (status) {
-    case ThreadStatus::WaitSynch:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
     case ThreadStatus::WaitHLEEvent:
     case ThreadStatus::WaitSleep:
     case ThreadStatus::WaitIPC:
@@ -141,12 +142,6 @@ void Thread::ResumeFromWait() {
     ChangeScheduler();
 }
 
-void Thread::CancelWait() {
-    ASSERT(GetStatus() == ThreadStatus::WaitSynch);
-    SetWaitSynchronizationResult(ERR_SYNCHRONIZATION_CANCELED);
-    ResumeFromWait();
-}
-
 /**
  * Resets a thread context, making it ready to be scheduled and run by the CPU
  * @param context Thread context to reset
@@ -225,6 +220,11 @@ void Thread::SetPriority(u32 priority) {
     UpdatePriority();
 }
 
+void Thread::BoostPriority(u32 priority) {
+    scheduler->SetThreadPriority(this, priority);
+    current_priority = priority;
+}
+
 void Thread::SetWaitSynchronizationResult(ResultCode result) {
     context.cpu_registers[0] = result.raw;
 }

src/core/hle/kernel/thread.h

@@ -30,21 +30,12 @@ enum ThreadPriority : u32 {
 };
 
 enum ThreadProcessorId : s32 {
-    /// Indicates that no particular processor core is preferred.
-    THREADPROCESSORID_DONT_CARE = -1,
-
-    /// Run thread on the ideal core specified by the process.
-    THREADPROCESSORID_IDEAL = -2,
-
-    /// Indicates that the preferred processor ID shouldn't be updated in
-    /// a core mask setting operation.
-    THREADPROCESSORID_DONT_UPDATE = -3,
-
-    THREADPROCESSORID_0 = 0,   ///< Run thread on core 0
-    THREADPROCESSORID_1 = 1,   ///< Run thread on core 1
-    THREADPROCESSORID_2 = 2,   ///< Run thread on core 2
-    THREADPROCESSORID_3 = 3,   ///< Run thread on core 3
-    THREADPROCESSORID_MAX = 4, ///< Processor ID must be less than this
+    THREADPROCESSORID_IDEAL = -2, ///< Run thread on the ideal core specified by the process.
+    THREADPROCESSORID_0 = 0,      ///< Run thread on core 0
+    THREADPROCESSORID_1 = 1,      ///< Run thread on core 1
+    THREADPROCESSORID_2 = 2,      ///< Run thread on core 2
+    THREADPROCESSORID_3 = 3,      ///< Run thread on core 3
+    THREADPROCESSORID_MAX = 4,    ///< Processor ID must be less than this
 
     /// Allowed CPU mask
     THREADPROCESSORID_DEFAULT_MASK = (1 << THREADPROCESSORID_0) | (1 << THREADPROCESSORID_1) |
@@ -58,7 +49,8 @@ enum class ThreadStatus {
     WaitHLEEvent, ///< Waiting for hle event to finish
     WaitSleep,    ///< Waiting due to a SleepThread SVC
     WaitIPC,      ///< Waiting for the reply from an IPC request
-    WaitSynch,    ///< Waiting due to WaitSynchronization
+    WaitSynchAny, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
+    WaitSynchAll, ///< Waiting due to WaitSynchronizationN with wait_all = true
     WaitMutex,    ///< Waiting due to an ArbitrateLock svc
     WaitCondVar,  ///< Waiting due to an WaitProcessWideKey svc
     WaitArb,      ///< Waiting due to a SignalToAddress/WaitForAddress svc
@@ -110,11 +102,6 @@ public:
     std::string GetName() const override {
         return name;
     }
-
-    void SetName(std::string new_name) {
-        name = std::move(new_name);
-    }
-
     std::string GetTypeName() const override {
         return "Thread";
     }
@@ -149,6 +136,12 @@ public:
      */
     void SetPriority(u32 priority);
 
+    /**
+     * Temporarily boosts the thread's priority until the next time it is scheduled
+     * @param priority The new priority
+     */
+    void BoostPriority(u32 priority);
+
     /// Adds a thread to the list of threads that are waiting for a lock held by this thread.
     void AddMutexWaiter(SharedPtr<Thread> thread);
 
@@ -177,17 +170,11 @@ public:
         return tls_memory;
     }
 
-    /// Resumes a thread from waiting
+    /**
+     * Resumes a thread from waiting
+     */
     void ResumeFromWait();
 
-    /// Cancels a waiting operation that this thread may or may not be within.
-    ///
-    /// When the thread is within a waiting state, this will set the thread's
-    /// waiting result to signal a canceled wait. The function will then resume
-    /// this thread.
-    ///
-    void CancelWait();
-
     /**
      * Schedules an event to wake up the specified thread after the specified delay
      * @param nanoseconds The time this thread will be allowed to sleep for
@@ -198,27 +185,24 @@ public:
     void CancelWakeupTimer();
 
     /**
-     * Sets the result after the thread awakens (from svcWaitSynchronization)
+     * Sets the result after the thread awakens (from either WaitSynchronization SVC)
      * @param result Value to set to the returned result
      */
     void SetWaitSynchronizationResult(ResultCode result);
 
     /**
-     * Sets the output parameter value after the thread awakens (from svcWaitSynchronization)
+     * Sets the output parameter value after the thread awakens (from WaitSynchronizationN SVC only)
      * @param output Value to set to the output parameter
      */
     void SetWaitSynchronizationOutput(s32 output);
 
     /**
      * Retrieves the index that this particular object occupies in the list of objects
-     * that the thread passed to WaitSynchronization, starting the search from the last element.
-     *
-     * It is used to set the output index of WaitSynchronization when the thread is awakened.
-     *
+     * that the thread passed to WaitSynchronizationN, starting the search from the last element.
+     * It is used to set the output value of WaitSynchronizationN when the thread is awakened.
      * When a thread wakes up due to an object signal, the kernel will use the index of the last
      * matching object in the wait objects list in case of having multiple instances of the same
      * object in the list.
-     *
      * @param object Object to query the index of.
      */
     s32 GetWaitObjectIndex(const WaitObject* object) const;
@@ -255,9 +239,13 @@ public:
      */
     VAddr GetCommandBufferAddress() const;
 
-    /// Returns whether this thread is waiting on objects from a WaitSynchronization call.
-    bool IsSleepingOnWait() const {
-        return status == ThreadStatus::WaitSynch;
+    /**
+     * Returns whether this thread is waiting for all the objects in
+     * its wait list to become ready, as a result of a WaitSynchronizationN call
+     * with wait_all = true.
+     */
+    bool IsSleepingOnWaitAll() const {
+        return status == ThreadStatus::WaitSynchAll;
     }
 
     ThreadContext& GetContext() {
@@ -357,6 +345,10 @@ public:
         arb_wait_address = address;
     }
 
+    void SetGuestHandle(Handle handle) {
+        guest_handle = handle;
+    }
+
     bool HasWakeupCallback() const {
         return wakeup_callback != nullptr;
     }
@@ -431,7 +423,7 @@ private:
     Process* owner_process;
 
     /// Objects that the thread is waiting on, in the same order as they were
-    /// passed to WaitSynchronization.
+    /// passed to WaitSynchronization1/N.
     ThreadWaitObjects wait_objects;
 
     /// List of threads that are waiting for a mutex that is held by this thread.
@@ -450,11 +442,14 @@ private:
     /// If waiting for an AddressArbiter, this is the address being waited on.
     VAddr arb_wait_address{0};
 
+    /// Handle used by guest emulated application to access this thread
+    Handle guest_handle = 0;
+
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
     Handle callback_handle = 0;
 
     /// Callback that will be invoked when the thread is resumed from a waiting state. If the thread
-    /// was waiting via WaitSynchronization then the object will be the last object that became
+    /// was waiting via WaitSynchronizationN then the object will be the last object that became
     /// available. In case of a timeout, the object will be nullptr.
     WakeupCallback wakeup_callback;
 

src/core/hle/kernel/vm_manager.cpp

@@ -62,7 +62,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
     return true;
 }
 
-VMManager::VMManager(Core::System& system) : system{system} {
+VMManager::VMManager() {
     // Default to assuming a 39-bit address space. This way we have a sane
     // starting point with executables that don't provide metadata.
     Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
@@ -111,6 +111,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
                                             VMAPermission::ReadWriteExecute);
     system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
@@ -139,6 +140,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
     system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
     system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
@@ -221,6 +223,7 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
 
     ASSERT(FindVMA(target)->second.size >= size);
 
+    auto& system = Core::System::GetInstance();
     system.ArmInterface(0).UnmapMemory(target, size);
     system.ArmInterface(1).UnmapMemory(target, size);
     system.ArmInterface(2).UnmapMemory(target, size);
@@ -299,86 +302,6 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
     return MakeResult<VAddr>(heap_region_base);
 }
 
-ResultCode VMManager::MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
-    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
-    const auto src_check_result = CheckRangeState(
-        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::All,
-        VMAPermission::ReadWrite, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (src_check_result.Failed()) {
-        return src_check_result.Code();
-    }
-
-    const auto mirror_result =
-        MirrorMemory(dst_address, src_address, size, MemoryState::ModuleCode);
-    if (mirror_result.IsError()) {
-        return mirror_result;
-    }
-
-    // Ensure we lock the source memory region.
-    const auto src_vma_result = CarveVMARange(src_address, size);
-    if (src_vma_result.Failed()) {
-        return src_vma_result.Code();
-    }
-    auto src_vma_iter = *src_vma_result;
-    src_vma_iter->second.attribute = MemoryAttribute::Locked;
-    Reprotect(src_vma_iter, VMAPermission::Read);
-
-    // The destination memory region is fine as is, however we need to make it read-only.
-    return ReprotectRange(dst_address, size, VMAPermission::Read);
-}
-
-ResultCode VMManager::UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
-    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
-    const auto src_check_result = CheckRangeState(
-        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::None,
-        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::Locked, ignore_attribute);
-
-    if (src_check_result.Failed()) {
-        return src_check_result.Code();
-    }
-
-    // Yes, the kernel only checks the first page of the region.
-    const auto dst_check_result =
-        CheckRangeState(dst_address, Memory::PAGE_SIZE, MemoryState::FlagModule,
-                        MemoryState::FlagModule, VMAPermission::None, VMAPermission::None,
-                        MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (dst_check_result.Failed()) {
-        return dst_check_result.Code();
-    }
-
-    const auto dst_memory_state = std::get<MemoryState>(*dst_check_result);
-    const auto dst_contiguous_check_result = CheckRangeState(
-        dst_address, size, MemoryState::All, dst_memory_state, VMAPermission::None,
-        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (dst_contiguous_check_result.Failed()) {
-        return dst_contiguous_check_result.Code();
-    }
-
-    const auto unmap_result = UnmapRange(dst_address, size);
-    if (unmap_result.IsError()) {
-        return unmap_result;
-    }
-
-    // With the mirrored portion unmapped, restore the original region's traits.
-    const auto src_vma_result = CarveVMARange(src_address, size);
-    if (src_vma_result.Failed()) {
-        return src_vma_result.Code();
-    }
-    auto src_vma_iter = *src_vma_result;
-    src_vma_iter->second.state = MemoryState::Heap;
-    src_vma_iter->second.attribute = MemoryAttribute::None;
-    Reprotect(src_vma_iter, VMAPermission::ReadWrite);
-
-    if (dst_memory_state == MemoryState::ModuleCode) {
-        system.InvalidateCpuInstructionCaches();
-    }
-
-    return unmap_result;
-}
-
 MemoryInfo VMManager::QueryMemory(VAddr address) const {
     const auto vma = FindVMA(address);
     MemoryInfo memory_info{};

src/core/hle/kernel/vm_manager.h

@@ -14,10 +14,6 @@
 #include "core/hle/result.h"
 #include "core/memory.h"
 
-namespace Core {
-class System;
-}
-
 namespace FileSys {
 enum class ProgramAddressSpaceType : u8;
 }
@@ -47,9 +43,6 @@ enum class VMAPermission : u8 {
     ReadExecute = Read | Execute,
     WriteExecute = Write | Execute,
     ReadWriteExecute = Read | Write | Execute,
-
-    // Used as a wildcard when checking permissions across memory ranges
-    All = 0xFF,
 };
 
 constexpr VMAPermission operator|(VMAPermission lhs, VMAPermission rhs) {
@@ -159,9 +152,6 @@ enum class MemoryState : u32 {
     FlagUncached                    = 1U << 24,
     FlagCodeMemory                  = 1U << 25,
 
-    // Wildcard used in range checking to indicate all states.
-    All                             = 0xFFFFFFFF,
-
     // Convenience flag sets to reduce repetition
     IPCFlags = FlagIPC0 | FlagIPC3 | FlagIPC1,
 
@@ -325,7 +315,7 @@ class VMManager final {
 public:
     using VMAHandle = VMAMap::const_iterator;
 
-    explicit VMManager(Core::System& system);
+    VMManager();
     ~VMManager();
 
     /// Clears the address space map, re-initializing with a single free area.
@@ -425,49 +415,6 @@ public:
     ///
     ResultVal<VAddr> SetHeapSize(u64 size);
 
-    /// Maps a region of memory as code memory.
-    ///
-    /// @param dst_address The base address of the region to create the aliasing memory region.
-    /// @param src_address The base address of the region to be aliased.
-    /// @param size        The total amount of memory to map in bytes.
-    ///
-    /// @pre Both memory regions lie within the actual addressable address space.
-    ///
-    /// @post After this function finishes execution, assuming success, then the address range
-    ///       [dst_address, dst_address+size) will alias the memory region,
-    ///       [src_address, src_address+size).
-    ///       <p>
-    ///       What this also entails is as follows:
-    ///          1. The aliased region gains the Locked memory attribute.
-    ///          2. The aliased region becomes read-only.
-    ///          3. The aliasing region becomes read-only.
-    ///          4. The aliasing region is created with a memory state of MemoryState::CodeModule.
-    ///
-    ResultCode MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
-
-    /// Unmaps a region of memory designated as code module memory.
-    ///
-    /// @param dst_address The base address of the memory region aliasing the source memory region.
-    /// @param src_address The base address of the memory region being aliased.
-    /// @param size        The size of the memory region to unmap in bytes.
-    ///
-    /// @pre Both memory ranges lie within the actual addressable address space.
-    ///
-    /// @pre The memory region being unmapped has been previously been mapped
-    ///      by a call to MapCodeMemory.
-    ///
-    /// @post After execution of the function, if successful. the aliasing memory region
-    ///       will be unmapped and the aliased region will have various traits about it
-    ///       restored to what they were prior to the original mapping call preceding
-    ///       this function call.
-    ///       <p>
-    ///       What this also entails is as follows:
-    ///           1. The state of the memory region will now indicate a general heap region.
-    ///           2. All memory attributes for the memory region are cleared.
-    ///           3. Memory permissions for the region are restored to user read/write.
-    ///
-    ResultCode UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
-
     /// Queries the memory manager for information about the given address.
     ///
     /// @param address The address to query the memory manager about for information.
@@ -716,7 +663,5 @@ private:
     // The end of the currently allocated heap. This is not an inclusive
     // end of the range. This is essentially 'base_address + current_size'.
     VAddr heap_end = 0;
-
-    Core::System& system;
 };
 } // namespace Kernel

src/core/hle/kernel/wait_object.cpp

@@ -30,7 +30,7 @@ void WaitObject::RemoveWaitingThread(Thread* thread) {
         waiting_threads.erase(itr);
 }
 
-SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
+SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
     Thread* candidate = nullptr;
     u32 candidate_priority = THREADPRIO_LOWEST + 1;
 
@@ -38,7 +38,8 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
         const ThreadStatus thread_status = thread->GetStatus();
 
         // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread_status == ThreadStatus::WaitSynch ||
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
+                       thread_status == ThreadStatus::WaitSynchAll ||
                        thread_status == ThreadStatus::WaitHLEEvent,
                    "Inconsistent thread statuses in waiting_threads");
 
@@ -48,10 +49,10 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
         if (ShouldWait(thread.get()))
             continue;
 
-        // A thread is ready to run if it's either in ThreadStatus::WaitSynch
-        // and the rest of the objects it is waiting on are ready.
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
+        // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
         bool ready_to_run = true;
-        if (thread_status == ThreadStatus::WaitSynch) {
+        if (thread_status == ThreadStatus::WaitSynchAll) {
             ready_to_run = thread->AllWaitObjectsReady();
         }
 
@@ -67,35 +68,33 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() const {
 void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
     ASSERT(!ShouldWait(thread.get()));
 
-    if (!thread) {
+    if (!thread)
         return;
-    }
 
-    if (thread->IsSleepingOnWait()) {
+    if (!thread->IsSleepingOnWaitAll()) {
+        Acquire(thread.get());
+    } else {
         for (const auto& object : thread->GetWaitObjects()) {
             ASSERT(!object->ShouldWait(thread.get()));
             object->Acquire(thread.get());
         }
-    } else {
-        Acquire(thread.get());
     }
 
     const std::size_t index = thread->GetWaitObjectIndex(this);
 
-    for (const auto& object : thread->GetWaitObjects()) {
+    for (const auto& object : thread->GetWaitObjects())
         object->RemoveWaitingThread(thread.get());
-    }
     thread->ClearWaitObjects();
 
     thread->CancelWakeupTimer();
 
     bool resume = true;
-    if (thread->HasWakeupCallback()) {
+
+    if (thread->HasWakeupCallback())
         resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
-    }
-    if (resume) {
+
+    if (resume)
         thread->ResumeFromWait();
-    }
 }
 
 void WaitObject::WakeupAllWaitingThreads() {

src/core/hle/kernel/wait_object.h

@@ -54,7 +54,7 @@ public:
     void WakeupWaitingThread(SharedPtr<Thread> thread);
 
     /// Obtains the highest priority thread that is ready to run from this object's waiting list.
-    SharedPtr<Thread> GetHighestPriorityReadyThread() const;
+    SharedPtr<Thread> GetHighestPriorityReadyThread();
 
     /// Get a const reference to the waiting threads list for debug use
     const std::vector<SharedPtr<Thread>>& GetWaitingThreads() const;

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

@@ -10,7 +10,6 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "common/swap.h"
-#include "core/constants.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
@@ -22,7 +21,20 @@
 
 namespace Service::Account {
 
-static std::string GetImagePath(Common::UUID uuid) {
+// Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
+// used as a backup should the one on disk not exist
+constexpr u32 backup_jpeg_size = 107;
+constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
+    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
+    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
+    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
+    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
+    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+}};
+
+static std::string GetImagePath(UUID uuid) {
     return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
            "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
 }
@@ -34,7 +46,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(Common::UUID user_id, ProfileManager& profile_manager)
+    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
         : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
@@ -89,8 +101,8 @@ private:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
-            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
+            ctx.WriteBuffer(backup_jpeg);
+            rb.Push<u32>(backup_jpeg_size);
             return;
         }
 
@@ -112,20 +124,19 @@ private:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
+            rb.Push<u32>(backup_jpeg_size);
         } else {
             rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
         }
     }
 
     const ProfileManager& profile_manager;
-    Common::UUID user_id; ///< The user id this profile refers to.
+    UUID user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
     IManagerForApplication() : ServiceFramework("IManagerForApplication") {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
             {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
@@ -134,10 +145,7 @@ public:
             {130, nullptr, "GetNintendoAccountUserResourceCacheForApplication"},
             {150, nullptr, "CreateAuthorizationRequest"},
             {160, nullptr, "StoreOpenContext"},
-            {170, nullptr, "LoadNetworkServiceLicenseKindAsync"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 
@@ -167,7 +175,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+    UUID user_id = rp.PopRaw<UUID>();
     LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -193,12 +201,12 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
     LOG_INFO(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(RESULT_SUCCESS);
-    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<UUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+    UUID user_id = rp.PopRaw<UUID>();
     LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -233,15 +241,15 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
     IPC::ResponseBuilder rb{ctx, 6};
     if (profile_manager->GetUserCount() != 1) {
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw<u128>(INVALID_UUID);
         return;
     }
 
     const auto user_list = profile_manager->GetAllUsers();
     if (std::all_of(user_list.begin(), user_list.end(),
-                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
+                    [](const auto& user) { return user.uuid == INVALID_UUID; })) {
         rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw<u128>(INVALID_UUID);
         return;
     }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:su") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -31,8 +29,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {200, nullptr, "BeginUserRegistration"},
@@ -52,8 +48,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u0") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U0::GetUserCount, "GetUserCount"},
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
         {102, nullptr, "AuthenticateApplicationAsync"},
@@ -29,13 +27,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {120, nullptr, "CreateGuestLoginRequest"},
         {130, nullptr, "LoadOpenContext"},
-        {131, nullptr, "ListOpenContextStoredUsers"},
-        {140, nullptr, "InitializeApplicationInfo"},
-        {141, nullptr, "ListQualifiedUsers"},
-        {150, nullptr, "IsUserAccountSwitchLocked"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u1") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U1::GetUserCount, "GetUserCount"},
         {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -31,16 +29,12 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {997, nullptr, "DebugInvalidateTokenCacheForUser"},
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -13,8 +13,6 @@
 
 namespace Service::Account {
 
-using Common::UUID;
-
 struct UserRaw {
     UUID uuid;
     UUID uuid2;
@@ -37,6 +35,26 @@ constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
 constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
 
+UUID UUID::Generate() {
+    std::random_device device;
+    std::mt19937 gen(device());
+    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
+    return UUID{distribution(gen), distribution(gen)};
+}
+
+std::string UUID::Format() const {
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
+}
+
+std::string UUID::FormatSwitch() const {
+    std::array<u8, 16> s{};
+    std::memcpy(s.data(), uuid.data(), sizeof(u128));
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
+                       ":02x}{:02x}{:02x}{:02x}{:02x}",
+                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
+                       s[12], s[13], s[14], s[15]);
+}
+
 ProfileManager::ProfileManager() {
     ParseUserSaveFile();
 
@@ -199,7 +217,7 @@ bool ProfileManager::UserExists(UUID uuid) const {
 bool ProfileManager::UserExistsIndex(std::size_t index) const {
     if (index >= MAX_USERS)
         return false;
-    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
+    return profiles[index].user_uuid.uuid != INVALID_UUID;
 }
 
 /// Opens a specific user
@@ -293,7 +311,7 @@ bool ProfileManager::RemoveUser(UUID uuid) {
 
 bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
     const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
+    if (!index || profile_new.user_uuid == UUID(INVALID_UUID)) {
         return false;
     }
 
@@ -324,7 +342,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     for (const auto& user : data.users) {
-        if (user.uuid == UUID(Common::INVALID_UUID)) {
+        if (user.uuid == UUID(INVALID_UUID)) {
             continue;
         }
 

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

@@ -9,15 +9,47 @@
 
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "common/uuid.h"
 #include "core/hle/result.h"
 
 namespace Service::Account {
 constexpr std::size_t MAX_USERS = 8;
+constexpr u128 INVALID_UUID{{0, 0}};
+
+struct UUID {
+    // UUIDs which are 0 are considered invalid!
+    u128 uuid = INVALID_UUID;
+    UUID() = default;
+    explicit UUID(const u128& id) : uuid{id} {}
+    explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
+
+    explicit operator bool() const {
+        return uuid != INVALID_UUID;
+    }
+
+    bool operator==(const UUID& rhs) const {
+        return uuid == rhs.uuid;
+    }
+
+    bool operator!=(const UUID& rhs) const {
+        return !operator==(rhs);
+    }
+
+    // TODO(ogniK): Properly generate uuids based on RFC-4122
+    static UUID Generate();
+
+    // Set the UUID to {0,0} to be considered an invalid user
+    void Invalidate() {
+        uuid = INVALID_UUID;
+    }
+
+    std::string Format() const;
+    std::string FormatSwitch() const;
+};
+static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
 constexpr std::size_t profile_username_size = 32;
 using ProfileUsername = std::array<u8, profile_username_size>;
-using UserIDArray = std::array<Common::UUID, MAX_USERS>;
+using UserIDArray = std::array<UUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -34,7 +66,7 @@ static_assert(sizeof(ProfileData) == 0x80, "ProfileData structure has incorrect
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
-    Common::UUID user_uuid;
+    UUID user_uuid;
     ProfileUsername username;
     u64 creation_time;
     ProfileData data; // TODO(ognik): Work out what this is
@@ -42,7 +74,7 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    Common::UUID user_uuid;
+    UUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
@@ -64,33 +96,33 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
-    ResultCode CreateNewUser(Common::UUID uuid, const std::string& username);
-    std::optional<Common::UUID> GetUser(std::size_t index) const;
-    std::optional<std::size_t> GetUserIndex(const Common::UUID& uuid) const;
+    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
+    ResultCode CreateNewUser(UUID uuid, const std::string& username);
+    std::optional<UUID> GetUser(std::size_t index) const;
+    std::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(Common::UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
     bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                                ProfileData& data) const;
-    bool GetProfileBaseAndData(Common::UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
     bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
                                ProfileData& data) const;
     std::size_t GetUserCount() const;
     std::size_t GetOpenUserCount() const;
-    bool UserExists(Common::UUID uuid) const;
+    bool UserExists(UUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(Common::UUID uuid);
-    void CloseUser(Common::UUID uuid);
+    void OpenUser(UUID uuid);
+    void CloseUser(UUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    Common::UUID GetLastOpenedUser() const;
+    UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(Common::UUID uuid);
-    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
+    bool RemoveUser(UUID uuid);
+    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
 
 private:
     void ParseUserSaveFile();
@@ -100,7 +132,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count = 0;
-    Common::UUID last_opened_user{Common::INVALID_UUID};
+    UUID last_opened_user{INVALID_UUID};
 };
 
 }; // namespace Service::Account