shader/shader_ir: Make Comment() take a std::string by value

This allows for forming comment nodes without making unnecessary copies
of the std::string instance.

e.g. previously:

Comment(fmt::format("Base address is c[0x{:x}][0x{:x}]",
        cbuf->GetIndex(), cbuf_offset));

Would result in a copy of the string being created, as CommentNode()
takes a std::string by value (a const ref passed to a value parameter
results in a copy).

Now, only one instance of the string is ever moved around. (fmt::format
returns a std::string, and since it's returned from a function by value,
this is a prvalue (which can be treated like an rvalue), so it's moved
into Comment's string parameter), we then move it into the CommentNode
constructor, which then moves the string into its member variable).

.github/FUNDING.yml

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

CMakeModules/GenerateSCMRev.cmake

@@ -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/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/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/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>
@@ -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();
+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);
@@ -147,9 +146,9 @@ const std::string& GetExeDirectory();
 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
@@ -258,8 +257,8 @@ 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 {
@@ -287,8 +286,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/math_util.h

@@ -41,7 +41,4 @@ struct Rectangle {
     }
 };
 
-template <typename T>
-Rectangle(T, T, T, T)->Rectangle<T>;
-
 } // 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/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
@@ -312,8 +310,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 +326,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

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

@@ -18,6 +18,11 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/frontend/applets/error.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/frontend/applets/profile_select.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
@@ -32,6 +37,9 @@
 #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/renderer_base.h"
 #include "video_core/video_core.h"
@@ -136,10 +144,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 +167,7 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader);
-        auto main_process =
-            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
+        auto main_process = Kernel::Process::Create(system, "main");
         const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));

src/core/core.h

@@ -98,6 +98,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

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/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/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.h

@@ -169,7 +169,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/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](
@@ -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

@@ -99,8 +99,7 @@ struct KernelCore::Impl {
 
     void Shutdown() {
         next_object_id = 0;
-        next_kernel_process_id = Process::InitialKIPIDMin;
-        next_user_process_id = Process::ProcessIDMin;
+        next_process_id = Process::ProcessIDMin;
         next_thread_id = 1;
 
         process_list.clear();
@@ -133,8 +132,7 @@ struct KernelCore::Impl {
     }
 
     std::atomic<u32> next_object_id{0};
-    std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
-    std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
+    std::atomic<u64> next_process_id{Process::ProcessIDMin};
     std::atomic<u64> next_thread_id{1};
 
     // Lists all processes that exist in the current session.
@@ -228,12 +226,8 @@ u64 KernelCore::CreateNewThreadID() {
     return impl->next_thread_id++;
 }
 
-u64 KernelCore::CreateNewKernelProcessID() {
-    return impl->next_kernel_process_id++;
-}
-
-u64 KernelCore::CreateNewUserProcessID() {
-    return impl->next_user_process_id++;
+u64 KernelCore::CreateNewProcessID() {
+    return impl->next_process_id++;
 }
 
 Core::Timing::EventType* KernelCore::ThreadWakeupCallbackEventType() const {

src/core/hle/kernel/kernel.h

@@ -96,10 +96,7 @@ private:
     u32 CreateNewObjectID();
 
     /// Creates a new process ID, incrementing the internal process ID counter;
-    u64 CreateNewKernelProcessID();
-
-    /// Creates a new process ID, incrementing the internal process ID counter;
-    u64 CreateNewUserProcessID();
+    u64 CreateNewProcessID();
 
     /// Creates a new thread ID, incrementing the internal thread ID counter.
     u64 CreateNewThreadID();

src/core/hle/kernel/process.cpp

@@ -48,8 +48,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
 }
 } // Anonymous namespace
 
-SharedPtr<Process> Process::Create(Core::System& system, std::string name,
-                                   Process::ProcessType type) {
+SharedPtr<Process> Process::Create(Core::System& system, std::string&& name) {
     auto& kernel = system.Kernel();
 
     SharedPtr<Process> process(new Process(system));
@@ -57,8 +56,7 @@ SharedPtr<Process> Process::Create(Core::System& system, std::string name,
     process->resource_limit = kernel.GetSystemResourceLimit();
     process->status = ProcessStatus::Created;
     process->program_id = 0;
-    process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
-                                                              : kernel.CreateNewUserProcessID();
+    process->process_id = kernel.CreateNewProcessID();
     process->capabilities.InitializeForMetadatalessProcess();
 
     std::mt19937 rng(Settings::values.rng_seed.value_or(0));
@@ -74,26 +72,10 @@ SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
     return resource_limit;
 }
 
-u64 Process::GetTotalPhysicalMemoryAvailable() const {
-    return vm_manager.GetTotalPhysicalMemoryAvailable();
-}
-
-u64 Process::GetTotalPhysicalMemoryAvailableWithoutMmHeap() const {
-    // TODO: Subtract the personal heap size from this when the
-    //       personal heap is implemented.
-    return GetTotalPhysicalMemoryAvailable();
-}
-
 u64 Process::GetTotalPhysicalMemoryUsed() const {
     return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }
 
-u64 Process::GetTotalPhysicalMemoryUsedWithoutMmHeap() const {
-    // TODO: Subtract the personal heap size from this when the
-    //       personal heap is implemented.
-    return GetTotalPhysicalMemoryUsed();
-}
-
 void Process::RegisterThread(const Thread* thread) {
     thread_list.push_back(thread);
 }

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"
@@ -73,15 +74,9 @@ public:
         ProcessIDMax = 0xFFFFFFFFFFFFFFFF,
     };
 
-    // Used to determine how process IDs are assigned.
-    enum class ProcessType {
-        KernelInternal,
-        Userland,
-    };
-
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
-    static SharedPtr<Process> Create(Core::System& system, std::string name, ProcessType type);
+    static SharedPtr<Process> Create(Core::System& system, std::string&& name);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -192,20 +187,9 @@ public:
         return random_entropy.at(index);
     }
 
-    /// Retrieves the total physical memory available to this process in bytes.
-    u64 GetTotalPhysicalMemoryAvailable() const;
-
-    /// Retrieves the total physical memory available to this process in bytes,
-    /// without the size of the personal heap added to it.
-    u64 GetTotalPhysicalMemoryAvailableWithoutMmHeap() const;
-
     /// Retrieves the total physical memory used by this process in bytes.
     u64 GetTotalPhysicalMemoryUsed() const;
 
-    /// Retrieves the total physical memory used by this process in bytes,
-    /// without the size of the personal heap added to it.
-    u64 GetTotalPhysicalMemoryUsedWithoutMmHeap() const;
-
     /// Gets the list of all threads created with this process as their owner.
     const std::list<const Thread*>& GetThreadList() const {
         return thread_list;

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

@@ -710,13 +710,13 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         MapRegionSize = 3,
         HeapRegionBaseAddr = 4,
         HeapRegionSize = 5,
-        TotalPhysicalMemoryAvailable = 6,
+        TotalMemoryUsage = 6,
         TotalPhysicalMemoryUsed = 7,
         IsCurrentProcessBeingDebugged = 8,
         RegisterResourceLimit = 9,
         IdleTickCount = 10,
         RandomEntropy = 11,
-        ThreadTickCount = 0xF0000002,
+        PerformanceCounter = 0xF0000002,
         // 2.0.0+
         ASLRRegionBaseAddr = 12,
         ASLRRegionSize = 13,
@@ -730,9 +730,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         PrivilegedProcessId = 19,
         // 5.0.0+
         UserExceptionContextAddr = 20,
-        // 6.0.0+
-        TotalPhysicalMemoryAvailableWithoutMmHeap = 21,
-        TotalPhysicalMemoryUsedWithoutMmHeap = 22,
+        ThreadTickCount = 0xF0000002,
     };
 
     const auto info_id_type = static_cast<GetInfoType>(info_id);
@@ -748,14 +746,12 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
     case GetInfoType::ASLRRegionSize:
     case GetInfoType::NewMapRegionBaseAddr:
     case GetInfoType::NewMapRegionSize:
-    case GetInfoType::TotalPhysicalMemoryAvailable:
+    case GetInfoType::TotalMemoryUsage:
     case GetInfoType::TotalPhysicalMemoryUsed:
     case GetInfoType::IsVirtualAddressMemoryEnabled:
     case GetInfoType::PersonalMmHeapUsage:
     case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr:
-    case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
-    case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap: {
+    case GetInfoType::UserExceptionContextAddr: {
         if (info_sub_id != 0) {
             return ERR_INVALID_ENUM_VALUE;
         }
@@ -808,8 +804,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *result = process->VMManager().GetNewMapRegionSize();
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryAvailable:
-            *result = process->GetTotalPhysicalMemoryAvailable();
+        case GetInfoType::TotalMemoryUsage:
+            *result = process->VMManager().GetTotalMemoryUsage();
             return RESULT_SUCCESS;
 
         case GetInfoType::TotalPhysicalMemoryUsed:
@@ -830,14 +826,6 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *result = 0;
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
-            *result = process->GetTotalPhysicalMemoryAvailable();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap:
-            *result = process->GetTotalPhysicalMemoryUsedWithoutMmHeap();
-            return RESULT_SUCCESS;
-
         default:
             break;
         }

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() {

src/core/hle/kernel/vm_manager.cpp

@@ -758,7 +758,7 @@ VMManager::CheckResults VMManager::CheckRangeState(VAddr address, u64 size, Memo
         std::make_tuple(initial_state, initial_permissions, initial_attributes & ~ignore_mask));
 }
 
-u64 VMManager::GetTotalPhysicalMemoryAvailable() const {
+u64 VMManager::GetTotalMemoryUsage() const {
     LOG_WARNING(Kernel, "(STUBBED) called");
     return 0xF8000000;
 }

src/core/hle/kernel/vm_manager.h

@@ -499,7 +499,7 @@ public:
     void LogLayout() const;
 
     /// Gets the total memory usage, used by svcGetInfo
-    u64 GetTotalPhysicalMemoryAvailable() const;
+    u64 GetTotalMemoryUsage() const;
 
     /// Gets the address space base address
     VAddr GetAddressSpaceBaseAddress() 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,14 +124,14 @@ 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> {
@@ -167,7 +179,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 +205,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 +245,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/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

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

@@ -8,8 +8,6 @@
 #include <cstring>
 #include "audio_core/audio_renderer.h"
 #include "core/core.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
@@ -31,11 +29,9 @@
 #include "core/hle/service/am/tcap.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/set/set.h"
-#include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/settings.h"
 
@@ -1104,42 +1100,10 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
     // TODO(bunnei): This should be configurable
     LOG_DEBUG(Service_AM, "called");
 
-    // Get supported languages from NACP, if possible
-    // Default to 0 (all languages supported)
-    u32 supported_languages = 0;
-    FileSys::PatchManager pm{Core::System::GetInstance().CurrentProcess()->GetTitleID()};
-
-    const auto res = pm.GetControlMetadata();
-    if (res.first != nullptr) {
-        supported_languages = res.first->GetSupportedLanguages();
-    }
-
-    // Call IApplicationManagerInterface implementation.
-    auto& service_manager = Core::System::GetInstance().ServiceManager();
-    auto ns_am2 = service_manager.GetService<Service::NS::NS>("ns:am2");
-    auto app_man = ns_am2->GetApplicationManagerInterface();
-
-    // Get desired application language
-    const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages);
-    if (res_lang.Failed()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_lang.Code());
-        return;
-    }
-
-    // Convert to settings language code.
-    const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang);
-    if (res_code.Failed()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res_code.Code());
-        return;
-    }
-
-    LOG_DEBUG(Service_AM, "got desired_language={:016X}", *res_code);
-
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(*res_code);
+    rb.Push(
+        static_cast<u64>(Service::Set::GetLanguageCodeFromIndex(Settings::values.language_index)));
 }
 
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {

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

@@ -121,21 +121,6 @@ void Applet::Initialize() {
     initialized = true;
 }
 
-AppletFrontendSet::AppletFrontendSet() = default;
-
-AppletFrontendSet::AppletFrontendSet(ErrorApplet error, PhotoViewer photo_viewer,
-                                     ProfileSelect profile_select,
-                                     SoftwareKeyboard software_keyboard, WebBrowser web_browser)
-    : error{std::move(error)}, photo_viewer{std::move(photo_viewer)}, profile_select{std::move(
-                                                                          profile_select)},
-      software_keyboard{std::move(software_keyboard)}, web_browser{std::move(web_browser)} {}
-
-AppletFrontendSet::~AppletFrontendSet() = default;
-
-AppletFrontendSet::AppletFrontendSet(AppletFrontendSet&&) noexcept = default;
-
-AppletFrontendSet& AppletFrontendSet::operator=(AppletFrontendSet&&) noexcept = default;
-
 AppletManager::AppletManager() = default;
 
 AppletManager::~AppletManager() = default;

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

@@ -137,28 +137,11 @@ protected:
 };
 
 struct AppletFrontendSet {
-    using ErrorApplet = std::unique_ptr<Core::Frontend::ErrorApplet>;
-    using PhotoViewer = std::unique_ptr<Core::Frontend::PhotoViewerApplet>;
-    using ProfileSelect = std::unique_ptr<Core::Frontend::ProfileSelectApplet>;
-    using SoftwareKeyboard = std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet>;
-    using WebBrowser = std::unique_ptr<Core::Frontend::WebBrowserApplet>;
-
-    AppletFrontendSet();
-    AppletFrontendSet(ErrorApplet error, PhotoViewer photo_viewer, ProfileSelect profile_select,
-                      SoftwareKeyboard software_keyboard, WebBrowser web_browser);
-    ~AppletFrontendSet();
-
-    AppletFrontendSet(const AppletFrontendSet&) = delete;
-    AppletFrontendSet& operator=(const AppletFrontendSet&) = delete;
-
-    AppletFrontendSet(AppletFrontendSet&&) noexcept;
-    AppletFrontendSet& operator=(AppletFrontendSet&&) noexcept;
-
-    ErrorApplet error;
-    PhotoViewer photo_viewer;
-    ProfileSelect profile_select;
-    SoftwareKeyboard software_keyboard;
-    WebBrowser web_browser;
+    std::unique_ptr<Core::Frontend::ErrorApplet> error;
+    std::unique_ptr<Core::Frontend::PhotoViewerApplet> photo_viewer;
+    std::unique_ptr<Core::Frontend::ProfileSelectApplet> profile_select;
+    std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet> software_keyboard;
+    std::unique_ptr<Core::Frontend::WebBrowserApplet> web_browser;
 };
 
 class AppletManager {

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

@@ -53,19 +53,19 @@ void ProfileSelect::Execute() {
         return;
     }
 
-    frontend.SelectProfile([this](std::optional<Common::UUID> uuid) { SelectionComplete(uuid); });
+    frontend.SelectProfile([this](std::optional<Account::UUID> uuid) { SelectionComplete(uuid); });
 }
 
-void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
+void ProfileSelect::SelectionComplete(std::optional<Account::UUID> uuid) {
     UserSelectionOutput output{};
 
-    if (uuid.has_value() && uuid->uuid != Common::INVALID_UUID) {
+    if (uuid.has_value() && uuid->uuid != Account::INVALID_UUID) {
         output.result = 0;
         output.uuid_selected = uuid->uuid;
     } else {
         status = ERR_USER_CANCELLED_SELECTION;
         output.result = ERR_USER_CANCELLED_SELECTION.raw;
-        output.uuid_selected = Common::INVALID_UUID;
+        output.uuid_selected = Account::INVALID_UUID;
     }
 
     final_data = std::vector<u8>(sizeof(UserSelectionOutput));

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

@@ -7,8 +7,7 @@
 #include <vector>
 
 #include "common/common_funcs.h"
-#include "common/uuid.h"
-#include "core/hle/result.h"
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applets/applets.h"
 
 namespace Service::AM::Applets {
@@ -39,7 +38,7 @@ public:
     void ExecuteInteractive() override;
     void Execute() override;
 
-    void SelectionComplete(std::optional<Common::UUID> uuid);
+    void SelectionComplete(std::optional<Account::UUID> uuid);
 
 private:
     const Core::Frontend::ProfileSelectApplet& frontend;

src/core/hle/service/aoc/aoc_u.cpp

@@ -9,6 +9,7 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/ipc_helpers.h"
@@ -17,6 +18,7 @@
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/aoc/aoc_u.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 #include "core/settings.h"
 
@@ -73,15 +75,7 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
 AOC_U::~AOC_U() = default;
 
 void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        u64 process_id;
-    };
-    static_assert(sizeof(Parameters) == 8);
-
-    IPC::RequestParser rp{ctx};
-    const auto params = rp.PopRaw<Parameters>();
-
-    LOG_DEBUG(Service_AOC, "called. process_id={}", params.process_id);
+    LOG_DEBUG(Service_AOC, "called");
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
@@ -100,33 +94,24 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
 }
 
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        u32 offset;
-        u32 count;
-        u64 process_id;
-    };
-    static_assert(sizeof(Parameters) == 16);
-
     IPC::RequestParser rp{ctx};
-    const auto [offset, count, process_id] = rp.PopRaw<Parameters>();
 
-    LOG_DEBUG(Service_AOC, "called with offset={}, count={}, process_id={}", offset, count,
-              process_id);
+    const auto offset = rp.PopRaw<u32>();
+    auto count = rp.PopRaw<u32>();
+    LOG_DEBUG(Service_AOC, "called with offset={}, count={}", offset, count);
 
     const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
 
     std::vector<u32> out;
-    const auto& disabled = Settings::values.disabled_addons[current];
-    if (std::find(disabled.begin(), disabled.end(), "DLC") == disabled.end()) {
-        for (u64 content_id : add_on_content) {
-            if ((content_id & DLC_BASE_TITLE_ID_MASK) != current) {
-                continue;
-            }
-
-            out.push_back(static_cast<u32>(content_id & 0x7FF));
-        }
+    for (size_t i = 0; i < add_on_content.size(); ++i) {
+        if ((add_on_content[i] & DLC_BASE_TITLE_ID_MASK) == current)
+            out.push_back(static_cast<u32>(add_on_content[i] & 0x7FF));
     }
 
+    const auto& disabled = Settings::values.disabled_addons[current];
+    if (std::find(disabled.begin(), disabled.end(), "DLC") != disabled.end())
+        out = {};
+
     if (out.size() < offset) {
         IPC::ResponseBuilder rb{ctx, 2};
         // TODO(DarkLordZach): Find the correct error code.
@@ -134,31 +119,22 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    const auto out_count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
+    count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
     std::rotate(out.begin(), out.begin() + offset, out.end());
-    out.resize(out_count);
+    out.resize(count);
 
     ctx.WriteBuffer(out);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(out_count);
+    rb.Push(count);
 }
 
 void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        u64 process_id;
-    };
-    static_assert(sizeof(Parameters) == 8);
-
-    IPC::RequestParser rp{ctx};
-    const auto params = rp.PopRaw<Parameters>();
-
-    LOG_DEBUG(Service_AOC, "called. process_id={}", params.process_id);
+    LOG_DEBUG(Service_AOC, "called");
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-
     const auto title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
     FileSys::PatchManager pm{title_id};
 
@@ -172,17 +148,10 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
 }
 
 void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
-    struct Parameters {
-        s32 addon_index;
-        u64 process_id;
-    };
-    static_assert(sizeof(Parameters) == 16);
-
     IPC::RequestParser rp{ctx};
-    const auto [addon_index, process_id] = rp.PopRaw<Parameters>();
 
-    LOG_WARNING(Service_AOC, "(STUBBED) called with addon_index={}, process_id={}", addon_index,
-                process_id);
+    const auto aoc_id = rp.PopRaw<u32>();
+    LOG_WARNING(Service_AOC, "(STUBBED) called with aoc_id={:08X}", aoc_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);

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

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

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

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

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

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

src/core/hle/service/ncm/ncm.cpp

@@ -4,89 +4,15 @@
 
 #include <memory>
 
-#include "core/file_sys/romfs_factory.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ncm/ncm.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::NCM {
 
-class ILocationResolver final : public ServiceFramework<ILocationResolver> {
+class LocationResolver final : public ServiceFramework<LocationResolver> {
 public:
-    explicit ILocationResolver(FileSys::StorageId id)
-        : ServiceFramework{"ILocationResolver"}, storage(id) {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "ResolveProgramPath"},
-            {1, nullptr, "RedirectProgramPath"},
-            {2, nullptr, "ResolveApplicationControlPath"},
-            {3, nullptr, "ResolveApplicationHtmlDocumentPath"},
-            {4, nullptr, "ResolveDataPath"},
-            {5, nullptr, "RedirectApplicationControlPath"},
-            {6, nullptr, "RedirectApplicationHtmlDocumentPath"},
-            {7, nullptr, "ResolveApplicationLegalInformationPath"},
-            {8, nullptr, "RedirectApplicationLegalInformationPath"},
-            {9, nullptr, "Refresh"},
-            {10, nullptr, "RedirectProgramPath2"},
-            {11, nullptr, "Refresh2"},
-            {12, nullptr, "DeleteProgramPath"},
-            {13, nullptr, "DeleteApplicationControlPath"},
-            {14, nullptr, "DeleteApplicationHtmlDocumentPath"},
-            {15, nullptr, "DeleteApplicationLegalInformationPath"},
-            {16, nullptr, ""},
-            {17, nullptr, ""},
-            {18, nullptr, ""},
-            {19, nullptr, ""},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    FileSys::StorageId storage;
-};
-
-class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
-public:
-    explicit IRegisteredLocationResolver() : ServiceFramework{"IRegisteredLocationResolver"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "ResolveProgramPath"},
-            {1, nullptr, "RegisterProgramPath"},
-            {2, nullptr, "UnregisterProgramPath"},
-            {3, nullptr, "RedirectProgramPath"},
-            {4, nullptr, "ResolveHtmlDocumentPath"},
-            {5, nullptr, "RegisterHtmlDocumentPath"},
-            {6, nullptr, "UnregisterHtmlDocumentPath"},
-            {7, nullptr, "RedirectHtmlDocumentPath"},
-            {8, nullptr, ""},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IAddOnContentLocationResolver final : public ServiceFramework<IAddOnContentLocationResolver> {
-public:
-    explicit IAddOnContentLocationResolver() : ServiceFramework{"IAddOnContentLocationResolver"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "ResolveAddOnContentPath"},
-            {1, nullptr, "RegisterAddOnContentStorage"},
-            {2, nullptr, "UnregisterAllAddOnContentPath"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class LR final : public ServiceFramework<LR> {
-public:
-    explicit LR() : ServiceFramework{"lr"} {
+    explicit LocationResolver() : ServiceFramework{"lr"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "OpenLocationResolver"},
@@ -126,7 +52,7 @@ public:
 };
 
 void InstallInterfaces(SM::ServiceManager& sm) {
-    std::make_shared<LR>()->InstallAsService(sm);
+    std::make_shared<LocationResolver>()->InstallAsService(sm);
     std::make_shared<NCM>()->InstallAsService(sm);
 }
 

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

@@ -1,12 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::NS {
-
-constexpr ResultCode ERR_APPLICATION_LANGUAGE_NOT_FOUND{ErrorModule::NS, 300};
-}

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

@@ -1,392 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/ns/language.h"
-#include "core/hle/service/set/set.h"
-
-namespace Service::NS {
-
-constexpr ApplicationLanguagePriorityList priority_list_american_english = {{
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_british_english = {{
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_japanese = {{
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_french = {{
-    ApplicationLanguage::French,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_german = {{
-    ApplicationLanguage::German,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_latin_american_spanish = {{
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_spanish = {{
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_italian = {{
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_dutch = {{
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_canadian_french = {{
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_portuguese = {{
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_russian = {{
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_korean = {{
-    ApplicationLanguage::Korean,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_traditional_chinese = {{
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-}};
-
-constexpr ApplicationLanguagePriorityList priority_list_simplified_chinese = {{
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-}};
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
-    const ApplicationLanguage lang) {
-    switch (lang) {
-    case ApplicationLanguage::AmericanEnglish:
-        return &priority_list_american_english;
-    case ApplicationLanguage::BritishEnglish:
-        return &priority_list_british_english;
-    case ApplicationLanguage::Japanese:
-        return &priority_list_japanese;
-    case ApplicationLanguage::French:
-        return &priority_list_french;
-    case ApplicationLanguage::German:
-        return &priority_list_german;
-    case ApplicationLanguage::LatinAmericanSpanish:
-        return &priority_list_latin_american_spanish;
-    case ApplicationLanguage::Spanish:
-        return &priority_list_spanish;
-    case ApplicationLanguage::Italian:
-        return &priority_list_italian;
-    case ApplicationLanguage::Dutch:
-        return &priority_list_dutch;
-    case ApplicationLanguage::CanadianFrench:
-        return &priority_list_canadian_french;
-    case ApplicationLanguage::Portuguese:
-        return &priority_list_portuguese;
-    case ApplicationLanguage::Russian:
-        return &priority_list_russian;
-    case ApplicationLanguage::Korean:
-        return &priority_list_korean;
-    case ApplicationLanguage::TraditionalChinese:
-        return &priority_list_traditional_chinese;
-    case ApplicationLanguage::SimplifiedChinese:
-        return &priority_list_simplified_chinese;
-    default:
-        return nullptr;
-    }
-}
-
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
-    const Set::LanguageCode language_code) {
-    switch (language_code) {
-    case Set::LanguageCode::EN_US:
-        return ApplicationLanguage::AmericanEnglish;
-    case Set::LanguageCode::EN_GB:
-        return ApplicationLanguage::BritishEnglish;
-    case Set::LanguageCode::JA:
-        return ApplicationLanguage::Japanese;
-    case Set::LanguageCode::FR:
-        return ApplicationLanguage::French;
-    case Set::LanguageCode::DE:
-        return ApplicationLanguage::German;
-    case Set::LanguageCode::ES_419:
-        return ApplicationLanguage::LatinAmericanSpanish;
-    case Set::LanguageCode::ES:
-        return ApplicationLanguage::Spanish;
-    case Set::LanguageCode::IT:
-        return ApplicationLanguage::Italian;
-    case Set::LanguageCode::NL:
-        return ApplicationLanguage::Dutch;
-    case Set::LanguageCode::FR_CA:
-        return ApplicationLanguage::CanadianFrench;
-    case Set::LanguageCode::PT:
-        return ApplicationLanguage::Portuguese;
-    case Set::LanguageCode::RU:
-        return ApplicationLanguage::Russian;
-    case Set::LanguageCode::KO:
-        return ApplicationLanguage::Korean;
-    case Set::LanguageCode::ZH_HANT:
-        return ApplicationLanguage::TraditionalChinese;
-    case Set::LanguageCode::ZH_HANS:
-        return ApplicationLanguage::SimplifiedChinese;
-    default:
-        return std::nullopt;
-    }
-}
-
-std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage lang) {
-    switch (lang) {
-    case ApplicationLanguage::AmericanEnglish:
-        return Set::LanguageCode::EN_US;
-    case ApplicationLanguage::BritishEnglish:
-        return Set::LanguageCode::EN_GB;
-    case ApplicationLanguage::Japanese:
-        return Set::LanguageCode::JA;
-    case ApplicationLanguage::French:
-        return Set::LanguageCode::FR;
-    case ApplicationLanguage::German:
-        return Set::LanguageCode::DE;
-    case ApplicationLanguage::LatinAmericanSpanish:
-        return Set::LanguageCode::ES_419;
-    case ApplicationLanguage::Spanish:
-        return Set::LanguageCode::ES;
-    case ApplicationLanguage::Italian:
-        return Set::LanguageCode::IT;
-    case ApplicationLanguage::Dutch:
-        return Set::LanguageCode::NL;
-    case ApplicationLanguage::CanadianFrench:
-        return Set::LanguageCode::FR_CA;
-    case ApplicationLanguage::Portuguese:
-        return Set::LanguageCode::PT;
-    case ApplicationLanguage::Russian:
-        return Set::LanguageCode::RU;
-    case ApplicationLanguage::Korean:
-        return Set::LanguageCode::KO;
-    case ApplicationLanguage::TraditionalChinese:
-        return Set::LanguageCode::ZH_HANT;
-    case ApplicationLanguage::SimplifiedChinese:
-        return Set::LanguageCode::ZH_HANS;
-    default:
-        return std::nullopt;
-    }
-}
-} // namespace Service::NS

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

@@ -1,45 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <optional>
-#include <string>
-#include "common/common_types.h"
-
-namespace Service::Set {
-enum class LanguageCode : u64;
-}
-
-namespace Service::NS {
-/// This is nn::ns::detail::ApplicationLanguage
-enum class ApplicationLanguage : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish,
-    Japanese,
-    French,
-    German,
-    LatinAmericanSpanish,
-    Spanish,
-    Italian,
-    Dutch,
-    CanadianFrench,
-    Portuguese,
-    Russian,
-    Korean,
-    TraditionalChinese,
-    SimplifiedChinese,
-    Count
-};
-using ApplicationLanguagePriorityList =
-    const std::array<ApplicationLanguage, static_cast<std::size_t>(ApplicationLanguage::Count)>;
-
-constexpr u32 GetSupportedLanguageFlag(const ApplicationLanguage lang) {
-    return 1U << static_cast<u32>(lang);
-}
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(ApplicationLanguage lang);
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(Set::LanguageCode language_code);
-std::optional<Set::LanguageCode> ConvertToLanguageCode(ApplicationLanguage lang);
-} // namespace Service::NS

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

@@ -7,507 +7,445 @@
 #include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/service/ns/errors.h"
-#include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/ns/pl_u.h"
-#include "core/hle/service/set/set.h"
-#include "core/settings.h"
 
 namespace Service::NS {
 
-IAccountProxyInterface::IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "CreateUserAccount"},
-    };
-    // clang-format on
+class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
+public:
+    explicit IAccountProxyInterface() : ServiceFramework{"IAccountProxyInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateUserAccount"},
+        };
+        // clang-format on
 
-    RegisterHandlers(functions);
-}
+        RegisterHandlers(functions);
+    }
+};
 
-IAccountProxyInterface::~IAccountProxyInterface() = default;
+class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
+public:
+    explicit IApplicationManagerInterface() : ServiceFramework{"IApplicationManagerInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ListApplicationRecord"},
+            {1, nullptr, "GenerateApplicationRecordCount"},
+            {2, nullptr, "GetApplicationRecordUpdateSystemEvent"},
+            {3, nullptr, "GetApplicationViewDeprecated"},
+            {4, nullptr, "DeleteApplicationEntity"},
+            {5, nullptr, "DeleteApplicationCompletely"},
+            {6, nullptr, "IsAnyApplicationEntityRedundant"},
+            {7, nullptr, "DeleteRedundantApplicationEntity"},
+            {8, nullptr, "IsApplicationEntityMovable"},
+            {9, nullptr, "MoveApplicationEntity"},
+            {11, nullptr, "CalculateApplicationOccupiedSize"},
+            {16, nullptr, "PushApplicationRecord"},
+            {17, nullptr, "ListApplicationRecordContentMeta"},
+            {19, nullptr, "LaunchApplicationOld"},
+            {21, nullptr, "GetApplicationContentPath"},
+            {22, nullptr, "TerminateApplication"},
+            {23, nullptr, "ResolveApplicationContentPath"},
+            {26, nullptr, "BeginInstallApplication"},
+            {27, nullptr, "DeleteApplicationRecord"},
+            {30, nullptr, "RequestApplicationUpdateInfo"},
+            {32, nullptr, "CancelApplicationDownload"},
+            {33, nullptr, "ResumeApplicationDownload"},
+            {35, nullptr, "UpdateVersionList"},
+            {36, nullptr, "PushLaunchVersion"},
+            {37, nullptr, "ListRequiredVersion"},
+            {38, nullptr, "CheckApplicationLaunchVersion"},
+            {39, nullptr, "CheckApplicationLaunchRights"},
+            {40, nullptr, "GetApplicationLogoData"},
+            {41, nullptr, "CalculateApplicationDownloadRequiredSize"},
+            {42, nullptr, "CleanupSdCard"},
+            {43, nullptr, "CheckSdCardMountStatus"},
+            {44, nullptr, "GetSdCardMountStatusChangedEvent"},
+            {45, nullptr, "GetGameCardAttachmentEvent"},
+            {46, nullptr, "GetGameCardAttachmentInfo"},
+            {47, nullptr, "GetTotalSpaceSize"},
+            {48, nullptr, "GetFreeSpaceSize"},
+            {49, nullptr, "GetSdCardRemovedEvent"},
+            {52, nullptr, "GetGameCardUpdateDetectionEvent"},
+            {53, nullptr, "DisableApplicationAutoDelete"},
+            {54, nullptr, "EnableApplicationAutoDelete"},
+            {55, nullptr, "GetApplicationDesiredLanguage"},
+            {56, nullptr, "SetApplicationTerminateResult"},
+            {57, nullptr, "ClearApplicationTerminateResult"},
+            {58, nullptr, "GetLastSdCardMountUnexpectedResult"},
+            {59, nullptr, "ConvertApplicationLanguageToLanguageCode"},
+            {60, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
+            {61, nullptr, "GetBackgroundDownloadStressTaskInfo"},
+            {62, nullptr, "GetGameCardStopper"},
+            {63, nullptr, "IsSystemProgramInstalled"},
+            {64, nullptr, "StartApplyDeltaTask"},
+            {65, nullptr, "GetRequestServerStopper"},
+            {66, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
+            {67, nullptr, "CancelApplicationApplyDelta"},
+            {68, nullptr, "ResumeApplicationApplyDelta"},
+            {69, nullptr, "CalculateApplicationApplyDeltaRequiredSize"},
+            {70, nullptr, "ResumeAll"},
+            {71, nullptr, "GetStorageSize"},
+            {80, nullptr, "RequestDownloadApplication"},
+            {81, nullptr, "RequestDownloadAddOnContent"},
+            {82, nullptr, "DownloadApplication"},
+            {83, nullptr, "CheckApplicationResumeRights"},
+            {84, nullptr, "GetDynamicCommitEvent"},
+            {85, nullptr, "RequestUpdateApplication2"},
+            {86, nullptr, "EnableApplicationCrashReport"},
+            {87, nullptr, "IsApplicationCrashReportEnabled"},
+            {90, nullptr, "BoostSystemMemoryResourceLimit"},
+            {91, nullptr, "DeprecatedLaunchApplication"},
+            {92, nullptr, "GetRunningApplicationProgramId"},
+            {93, nullptr, "GetMainApplicationProgramIndex"},
+            {94, nullptr, "LaunchApplication"},
+            {95, nullptr, "GetApplicationLaunchInfo"},
+            {96, nullptr, "AcquireApplicationLaunchInfo"},
+            {97, nullptr, "GetMainApplicationProgramIndex2"},
+            {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
+            {100, nullptr, "ResetToFactorySettings"},
+            {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
+            {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
+            {200, nullptr, "CalculateUserSaveDataStatistics"},
+            {201, nullptr, "DeleteUserSaveDataAll"},
+            {210, nullptr, "DeleteUserSystemSaveData"},
+            {211, nullptr, "DeleteSaveData"},
+            {220, nullptr, "UnregisterNetworkServiceAccount"},
+            {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
+            {300, nullptr, "GetApplicationShellEvent"},
+            {301, nullptr, "PopApplicationShellEventInfo"},
+            {302, nullptr, "LaunchLibraryApplet"},
+            {303, nullptr, "TerminateLibraryApplet"},
+            {304, nullptr, "LaunchSystemApplet"},
+            {305, nullptr, "TerminateSystemApplet"},
+            {306, nullptr, "LaunchOverlayApplet"},
+            {307, nullptr, "TerminateOverlayApplet"},
+            {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
+            {401, nullptr, "InvalidateAllApplicationControlCache"},
+            {402, nullptr, "RequestDownloadApplicationControlData"},
+            {403, nullptr, "GetMaxApplicationControlCacheCount"},
+            {404, nullptr, "InvalidateApplicationControlCache"},
+            {405, nullptr, "ListApplicationControlCacheEntryInfo"},
+            {406, nullptr, "GetApplicationControlProperty"},
+            {502, nullptr, "RequestCheckGameCardRegistration"},
+            {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
+            {504, nullptr, "RequestRegisterGameCard"},
+            {505, nullptr, "GetGameCardMountFailureEvent"},
+            {506, nullptr, "IsGameCardInserted"},
+            {507, nullptr, "EnsureGameCardAccess"},
+            {508, nullptr, "GetLastGameCardMountFailureResult"},
+            {509, nullptr, "ListApplicationIdOnGameCard"},
+            {600, nullptr, "CountApplicationContentMeta"},
+            {601, nullptr, "ListApplicationContentMetaStatus"},
+            {602, nullptr, "ListAvailableAddOnContent"},
+            {603, nullptr, "GetOwnedApplicationContentMetaStatus"},
+            {604, nullptr, "RegisterContentsExternalKey"},
+            {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
+            {606, nullptr, "GetContentMetaStorage"},
+            {607, nullptr, "ListAvailableAddOnContent"},
+            {700, nullptr, "PushDownloadTaskList"},
+            {701, nullptr, "ClearTaskStatusList"},
+            {702, nullptr, "RequestDownloadTaskList"},
+            {703, nullptr, "RequestEnsureDownloadTask"},
+            {704, nullptr, "ListDownloadTaskStatus"},
+            {705, nullptr, "RequestDownloadTaskListData"},
+            {800, nullptr, "RequestVersionList"},
+            {801, nullptr, "ListVersionList"},
+            {802, nullptr, "RequestVersionListData"},
+            {900, nullptr, "GetApplicationRecord"},
+            {901, nullptr, "GetApplicationRecordProperty"},
+            {902, nullptr, "EnableApplicationAutoUpdate"},
+            {903, nullptr, "DisableApplicationAutoUpdate"},
+            {904, nullptr, "TouchApplication"},
+            {905, nullptr, "RequestApplicationUpdate"},
+            {906, nullptr, "IsApplicationUpdateRequested"},
+            {907, nullptr, "WithdrawApplicationUpdateRequest"},
+            {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
+            {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
+            {910, nullptr, "HasApplicationRecord"},
+            {911, nullptr, "SetPreInstalledApplication"},
+            {912, nullptr, "ClearPreInstalledApplicationFlag"},
+            {1000, nullptr, "RequestVerifyApplicationDeprecated"},
+            {1001, nullptr, "CorruptApplicationForDebug"},
+            {1002, nullptr, "RequestVerifyAddOnContentsRights"},
+            {1003, nullptr, "RequestVerifyApplication"},
+            {1004, nullptr, "CorruptContentForDebug"},
+            {1200, nullptr, "NeedsUpdateVulnerability"},
+            {1300, nullptr, "IsAnyApplicationEntityInstalled"},
+            {1301, nullptr, "DeleteApplicationContentEntities"},
+            {1302, nullptr, "CleanupUnrecordedApplicationEntity"},
+            {1303, nullptr, "CleanupAddOnContentsWithNoRights"},
+            {1304, nullptr, "DeleteApplicationContentEntity"},
+            {1305, nullptr, "TryDeleteRunningApplicationEntity"},
+            {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
+            {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
+            {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
+            {1309, nullptr, "CleanupUnavailableAddOnContents"},
+            {1400, nullptr, "PrepareShutdown"},
+            {1500, nullptr, "FormatSdCard"},
+            {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
+            {1502, nullptr, "GetLastSdCardFormatUnexpectedResult"},
+            {1504, nullptr, "InsertSdCard"},
+            {1505, nullptr, "RemoveSdCard"},
+            {1600, nullptr, "GetSystemSeedForPseudoDeviceId"},
+            {1601, nullptr, "ResetSystemSeedForPseudoDeviceId"},
+            {1700, nullptr, "ListApplicationDownloadingContentMeta"},
+            {1701, nullptr, "GetApplicationView"},
+            {1702, nullptr, "GetApplicationDownloadTaskStatus"},
+            {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
+            {1800, nullptr, "IsNotificationSetupCompleted"},
+            {1801, nullptr, "GetLastNotificationInfoCount"},
+            {1802, nullptr, "ListLastNotificationInfo"},
+            {1803, nullptr, "ListNotificationTask"},
+            {1900, nullptr, "IsActiveAccount"},
+            {1901, nullptr, "RequestDownloadApplicationPrepurchasedRights"},
+            {1902, nullptr, "GetApplicationTicketInfo"},
+            {2000, nullptr, "GetSystemDeliveryInfo"},
+            {2001, nullptr, "SelectLatestSystemDeliveryInfo"},
+            {2002, nullptr, "VerifyDeliveryProtocolVersion"},
+            {2003, nullptr, "GetApplicationDeliveryInfo"},
+            {2004, nullptr, "HasAllContentsToDeliver"},
+            {2005, nullptr, "CompareApplicationDeliveryInfo"},
+            {2006, nullptr, "CanDeliverApplication"},
+            {2007, nullptr, "ListContentMetaKeyToDeliverApplication"},
+            {2008, nullptr, "NeedsSystemUpdateToDeliverApplication"},
+            {2009, nullptr, "EstimateRequiredSize"},
+            {2010, nullptr, "RequestReceiveApplication"},
+            {2011, nullptr, "CommitReceiveApplication"},
+            {2012, nullptr, "GetReceiveApplicationProgress"},
+            {2013, nullptr, "RequestSendApplication"},
+            {2014, nullptr, "GetSendApplicationProgress"},
+            {2015, nullptr, "CompareSystemDeliveryInfo"},
+            {2016, nullptr, "ListNotCommittedContentMeta"},
+            {2017, nullptr, "CreateDownloadTask"},
+            {2018, nullptr, "GetApplicationDeliveryInfoHash"},
+            {2050, nullptr, "GetApplicationRightsOnClient"},
+            {2100, nullptr, "GetApplicationTerminateResult"},
+            {2101, nullptr, "GetRawApplicationTerminateResult"},
+            {2150, nullptr, "CreateRightsEnvironment"},
+            {2151, nullptr, "DestroyRightsEnvironment"},
+            {2152, nullptr, "ActivateRightsEnvironment"},
+            {2153, nullptr, "DeactivateRightsEnvironment"},
+            {2154, nullptr, "ForceActivateRightsContextForExit"},
+            {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
+            {2161, nullptr, "SetUsersToRightsEnvironment"},
+            {2170, nullptr, "GetRightsEnvironmentStatus"},
+            {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
+            {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
+            {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
+            {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
+            {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
+            {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
+            {2200, nullptr, "GetGameCardApplicationCopyIdentifier"},
+            {2201, nullptr, "GetInstalledApplicationCopyIdentifier"},
+            {2250, nullptr, "RequestReportActiveELicence"},
+            {2300, nullptr, "ListEventLog"},
+        };
+        // clang-format on
 
-IApplicationManagerInterface::IApplicationManagerInterface()
-    : ServiceFramework{"IApplicationManagerInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "ListApplicationRecord"},
-        {1, nullptr, "GenerateApplicationRecordCount"},
-        {2, nullptr, "GetApplicationRecordUpdateSystemEvent"},
-        {3, nullptr, "GetApplicationViewDeprecated"},
-        {4, nullptr, "DeleteApplicationEntity"},
-        {5, nullptr, "DeleteApplicationCompletely"},
-        {6, nullptr, "IsAnyApplicationEntityRedundant"},
-        {7, nullptr, "DeleteRedundantApplicationEntity"},
-        {8, nullptr, "IsApplicationEntityMovable"},
-        {9, nullptr, "MoveApplicationEntity"},
-        {11, nullptr, "CalculateApplicationOccupiedSize"},
-        {16, nullptr, "PushApplicationRecord"},
-        {17, nullptr, "ListApplicationRecordContentMeta"},
-        {19, nullptr, "LaunchApplicationOld"},
-        {21, nullptr, "GetApplicationContentPath"},
-        {22, nullptr, "TerminateApplication"},
-        {23, nullptr, "ResolveApplicationContentPath"},
-        {26, nullptr, "BeginInstallApplication"},
-        {27, nullptr, "DeleteApplicationRecord"},
-        {30, nullptr, "RequestApplicationUpdateInfo"},
-        {32, nullptr, "CancelApplicationDownload"},
-        {33, nullptr, "ResumeApplicationDownload"},
-        {35, nullptr, "UpdateVersionList"},
-        {36, nullptr, "PushLaunchVersion"},
-        {37, nullptr, "ListRequiredVersion"},
-        {38, nullptr, "CheckApplicationLaunchVersion"},
-        {39, nullptr, "CheckApplicationLaunchRights"},
-        {40, nullptr, "GetApplicationLogoData"},
-        {41, nullptr, "CalculateApplicationDownloadRequiredSize"},
-        {42, nullptr, "CleanupSdCard"},
-        {43, nullptr, "CheckSdCardMountStatus"},
-        {44, nullptr, "GetSdCardMountStatusChangedEvent"},
-        {45, nullptr, "GetGameCardAttachmentEvent"},
-        {46, nullptr, "GetGameCardAttachmentInfo"},
-        {47, nullptr, "GetTotalSpaceSize"},
-        {48, nullptr, "GetFreeSpaceSize"},
-        {49, nullptr, "GetSdCardRemovedEvent"},
-        {52, nullptr, "GetGameCardUpdateDetectionEvent"},
-        {53, nullptr, "DisableApplicationAutoDelete"},
-        {54, nullptr, "EnableApplicationAutoDelete"},
-        {55, &IApplicationManagerInterface::GetApplicationDesiredLanguage, "GetApplicationDesiredLanguage"},
-        {56, nullptr, "SetApplicationTerminateResult"},
-        {57, nullptr, "ClearApplicationTerminateResult"},
-        {58, nullptr, "GetLastSdCardMountUnexpectedResult"},
-        {59, &IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode, "ConvertApplicationLanguageToLanguageCode"},
-        {60, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
-        {61, nullptr, "GetBackgroundDownloadStressTaskInfo"},
-        {62, nullptr, "GetGameCardStopper"},
-        {63, nullptr, "IsSystemProgramInstalled"},
-        {64, nullptr, "StartApplyDeltaTask"},
-        {65, nullptr, "GetRequestServerStopper"},
-        {66, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
-        {67, nullptr, "CancelApplicationApplyDelta"},
-        {68, nullptr, "ResumeApplicationApplyDelta"},
-        {69, nullptr, "CalculateApplicationApplyDeltaRequiredSize"},
-        {70, nullptr, "ResumeAll"},
-        {71, nullptr, "GetStorageSize"},
-        {80, nullptr, "RequestDownloadApplication"},
-        {81, nullptr, "RequestDownloadAddOnContent"},
-        {82, nullptr, "DownloadApplication"},
-        {83, nullptr, "CheckApplicationResumeRights"},
-        {84, nullptr, "GetDynamicCommitEvent"},
-        {85, nullptr, "RequestUpdateApplication2"},
-        {86, nullptr, "EnableApplicationCrashReport"},
-        {87, nullptr, "IsApplicationCrashReportEnabled"},
-        {90, nullptr, "BoostSystemMemoryResourceLimit"},
-        {91, nullptr, "DeprecatedLaunchApplication"},
-        {92, nullptr, "GetRunningApplicationProgramId"},
-        {93, nullptr, "GetMainApplicationProgramIndex"},
-        {94, nullptr, "LaunchApplication"},
-        {95, nullptr, "GetApplicationLaunchInfo"},
-        {96, nullptr, "AcquireApplicationLaunchInfo"},
-        {97, nullptr, "GetMainApplicationProgramIndex2"},
-        {98, nullptr, "EnableApplicationAllThreadDumpOnCrash"},
-        {100, nullptr, "ResetToFactorySettings"},
-        {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
-        {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
-        {200, nullptr, "CalculateUserSaveDataStatistics"},
-        {201, nullptr, "DeleteUserSaveDataAll"},
-        {210, nullptr, "DeleteUserSystemSaveData"},
-        {211, nullptr, "DeleteSaveData"},
-        {220, nullptr, "UnregisterNetworkServiceAccount"},
-        {221, nullptr, "UnregisterNetworkServiceAccountWithUserSaveDataDeletion"},
-        {300, nullptr, "GetApplicationShellEvent"},
-        {301, nullptr, "PopApplicationShellEventInfo"},
-        {302, nullptr, "LaunchLibraryApplet"},
-        {303, nullptr, "TerminateLibraryApplet"},
-        {304, nullptr, "LaunchSystemApplet"},
-        {305, nullptr, "TerminateSystemApplet"},
-        {306, nullptr, "LaunchOverlayApplet"},
-        {307, nullptr, "TerminateOverlayApplet"},
-        {400, &IApplicationManagerInterface::GetApplicationControlData, "GetApplicationControlData"},
-        {401, nullptr, "InvalidateAllApplicationControlCache"},
-        {402, nullptr, "RequestDownloadApplicationControlData"},
-        {403, nullptr, "GetMaxApplicationControlCacheCount"},
-        {404, nullptr, "InvalidateApplicationControlCache"},
-        {405, nullptr, "ListApplicationControlCacheEntryInfo"},
-        {406, nullptr, "GetApplicationControlProperty"},
-        {502, nullptr, "RequestCheckGameCardRegistration"},
-        {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
-        {504, nullptr, "RequestRegisterGameCard"},
-        {505, nullptr, "GetGameCardMountFailureEvent"},
-        {506, nullptr, "IsGameCardInserted"},
-        {507, nullptr, "EnsureGameCardAccess"},
-        {508, nullptr, "GetLastGameCardMountFailureResult"},
-        {509, nullptr, "ListApplicationIdOnGameCard"},
-        {600, nullptr, "CountApplicationContentMeta"},
-        {601, nullptr, "ListApplicationContentMetaStatus"},
-        {602, nullptr, "ListAvailableAddOnContent"},
-        {603, nullptr, "GetOwnedApplicationContentMetaStatus"},
-        {604, nullptr, "RegisterContentsExternalKey"},
-        {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
-        {606, nullptr, "GetContentMetaStorage"},
-        {607, nullptr, "ListAvailableAddOnContent"},
-        {700, nullptr, "PushDownloadTaskList"},
-        {701, nullptr, "ClearTaskStatusList"},
-        {702, nullptr, "RequestDownloadTaskList"},
-        {703, nullptr, "RequestEnsureDownloadTask"},
-        {704, nullptr, "ListDownloadTaskStatus"},
-        {705, nullptr, "RequestDownloadTaskListData"},
-        {800, nullptr, "RequestVersionList"},
-        {801, nullptr, "ListVersionList"},
-        {802, nullptr, "RequestVersionListData"},
-        {900, nullptr, "GetApplicationRecord"},
-        {901, nullptr, "GetApplicationRecordProperty"},
-        {902, nullptr, "EnableApplicationAutoUpdate"},
-        {903, nullptr, "DisableApplicationAutoUpdate"},
-        {904, nullptr, "TouchApplication"},
-        {905, nullptr, "RequestApplicationUpdate"},
-        {906, nullptr, "IsApplicationUpdateRequested"},
-        {907, nullptr, "WithdrawApplicationUpdateRequest"},
-        {908, nullptr, "ListApplicationRecordInstalledContentMeta"},
-        {909, nullptr, "WithdrawCleanupAddOnContentsWithNoRightsRecommendation"},
-        {910, nullptr, "HasApplicationRecord"},
-        {911, nullptr, "SetPreInstalledApplication"},
-        {912, nullptr, "ClearPreInstalledApplicationFlag"},
-        {1000, nullptr, "RequestVerifyApplicationDeprecated"},
-        {1001, nullptr, "CorruptApplicationForDebug"},
-        {1002, nullptr, "RequestVerifyAddOnContentsRights"},
-        {1003, nullptr, "RequestVerifyApplication"},
-        {1004, nullptr, "CorruptContentForDebug"},
-        {1200, nullptr, "NeedsUpdateVulnerability"},
-        {1300, nullptr, "IsAnyApplicationEntityInstalled"},
-        {1301, nullptr, "DeleteApplicationContentEntities"},
-        {1302, nullptr, "CleanupUnrecordedApplicationEntity"},
-        {1303, nullptr, "CleanupAddOnContentsWithNoRights"},
-        {1304, nullptr, "DeleteApplicationContentEntity"},
-        {1305, nullptr, "TryDeleteRunningApplicationEntity"},
-        {1306, nullptr, "TryDeleteRunningApplicationCompletely"},
-        {1307, nullptr, "TryDeleteRunningApplicationContentEntities"},
-        {1308, nullptr, "DeleteApplicationCompletelyForDebug"},
-        {1309, nullptr, "CleanupUnavailableAddOnContents"},
-        {1400, nullptr, "PrepareShutdown"},
-        {1500, nullptr, "FormatSdCard"},
-        {1501, nullptr, "NeedsSystemUpdateToFormatSdCard"},
-        {1502, nullptr, "GetLastSdCardFormatUnexpectedResult"},
-        {1504, nullptr, "InsertSdCard"},
-        {1505, nullptr, "RemoveSdCard"},
-        {1600, nullptr, "GetSystemSeedForPseudoDeviceId"},
-        {1601, nullptr, "ResetSystemSeedForPseudoDeviceId"},
-        {1700, nullptr, "ListApplicationDownloadingContentMeta"},
-        {1701, nullptr, "GetApplicationView"},
-        {1702, nullptr, "GetApplicationDownloadTaskStatus"},
-        {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
-        {1800, nullptr, "IsNotificationSetupCompleted"},
-        {1801, nullptr, "GetLastNotificationInfoCount"},
-        {1802, nullptr, "ListLastNotificationInfo"},
-        {1803, nullptr, "ListNotificationTask"},
-        {1900, nullptr, "IsActiveAccount"},
-        {1901, nullptr, "RequestDownloadApplicationPrepurchasedRights"},
-        {1902, nullptr, "GetApplicationTicketInfo"},
-        {2000, nullptr, "GetSystemDeliveryInfo"},
-        {2001, nullptr, "SelectLatestSystemDeliveryInfo"},
-        {2002, nullptr, "VerifyDeliveryProtocolVersion"},
-        {2003, nullptr, "GetApplicationDeliveryInfo"},
-        {2004, nullptr, "HasAllContentsToDeliver"},
-        {2005, nullptr, "CompareApplicationDeliveryInfo"},
-        {2006, nullptr, "CanDeliverApplication"},
-        {2007, nullptr, "ListContentMetaKeyToDeliverApplication"},
-        {2008, nullptr, "NeedsSystemUpdateToDeliverApplication"},
-        {2009, nullptr, "EstimateRequiredSize"},
-        {2010, nullptr, "RequestReceiveApplication"},
-        {2011, nullptr, "CommitReceiveApplication"},
-        {2012, nullptr, "GetReceiveApplicationProgress"},
-        {2013, nullptr, "RequestSendApplication"},
-        {2014, nullptr, "GetSendApplicationProgress"},
-        {2015, nullptr, "CompareSystemDeliveryInfo"},
-        {2016, nullptr, "ListNotCommittedContentMeta"},
-        {2017, nullptr, "CreateDownloadTask"},
-        {2018, nullptr, "GetApplicationDeliveryInfoHash"},
-        {2050, nullptr, "GetApplicationRightsOnClient"},
-        {2100, nullptr, "GetApplicationTerminateResult"},
-        {2101, nullptr, "GetRawApplicationTerminateResult"},
-        {2150, nullptr, "CreateRightsEnvironment"},
-        {2151, nullptr, "DestroyRightsEnvironment"},
-        {2152, nullptr, "ActivateRightsEnvironment"},
-        {2153, nullptr, "DeactivateRightsEnvironment"},
-        {2154, nullptr, "ForceActivateRightsContextForExit"},
-        {2160, nullptr, "AddTargetApplicationToRightsEnvironment"},
-        {2161, nullptr, "SetUsersToRightsEnvironment"},
-        {2170, nullptr, "GetRightsEnvironmentStatus"},
-        {2171, nullptr, "GetRightsEnvironmentStatusChangedEvent"},
-        {2180, nullptr, "RequestExtendRightsInRightsEnvironment"},
-        {2181, nullptr, "GetLastResultOfExtendRightsInRightsEnvironment"},
-        {2182, nullptr, "SetActiveRightsContextUsingStateToRightsEnvironment"},
-        {2190, nullptr, "GetRightsEnvironmentHandleForApplication"},
-        {2199, nullptr, "GetRightsEnvironmentCountForDebug"},
-        {2200, nullptr, "GetGameCardApplicationCopyIdentifier"},
-        {2201, nullptr, "GetInstalledApplicationCopyIdentifier"},
-        {2250, nullptr, "RequestReportActiveELicence"},
-        {2300, nullptr, "ListEventLog"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IApplicationManagerInterface::~IApplicationManagerInterface() = default;
-
-void IApplicationManagerInterface::GetApplicationControlData(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto flag = rp.PopRaw<u64>();
-    LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
-
-    const auto title_id = rp.PopRaw<u64>();
-
-    const auto size = ctx.GetWriteBufferSize();
-
-    const FileSys::PatchManager pm{title_id};
-    const auto control = pm.GetControlMetadata();
-
-    std::vector<u8> out;
-
-    if (control.first != nullptr) {
-        if (size < 0x4000) {
-            LOG_ERROR(Service_NS,
-                      "output buffer is too small! (actual={:016X}, expected_min=0x4000)", size);
-            IPC::ResponseBuilder rb{ctx, 2};
-            // TODO(DarkLordZach): Find a better error code for this.
-            rb.Push(ResultCode(-1));
-            return;
-        }
-
-        out.resize(0x4000);
-        const auto bytes = control.first->GetRawBytes();
-        std::memcpy(out.data(), bytes.data(), bytes.size());
-    } else {
-        LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
-                    title_id);
-        out.resize(std::min<u64>(0x4000, size));
+        RegisterHandlers(functions);
     }
 
-    if (control.second != nullptr) {
-        if (size < 0x4000 + control.second->GetSize()) {
-            LOG_ERROR(Service_NS,
-                      "output buffer is too small! (actual={:016X}, expected_min={:016X})", size,
-                      0x4000 + control.second->GetSize());
-            IPC::ResponseBuilder rb{ctx, 2};
-            // TODO(DarkLordZach): Find a better error code for this.
-            rb.Push(ResultCode(-1));
-            return;
+    void GetApplicationControlData(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto flag = rp.PopRaw<u64>();
+        LOG_DEBUG(Service_NS, "called with flag={:016X}", flag);
+
+        const auto title_id = rp.PopRaw<u64>();
+
+        const auto size = ctx.GetWriteBufferSize();
+
+        const FileSys::PatchManager pm{title_id};
+        const auto control = pm.GetControlMetadata();
+
+        std::vector<u8> out;
+
+        if (control.first != nullptr) {
+            if (size < 0x4000) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                          size);
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
+
+            out.resize(0x4000);
+            const auto bytes = control.first->GetRawBytes();
+            std::memcpy(out.data(), bytes.data(), bytes.size());
+        } else {
+            LOG_WARNING(Service_NS, "missing NACP data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+            out.resize(std::min<u64>(0x4000, size));
         }
 
-        out.resize(0x4000 + control.second->GetSize());
-        control.second->Read(out.data() + 0x4000, control.second->GetSize());
-    } else {
-        LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
-                    title_id);
-    }
+        if (control.second != nullptr) {
+            if (size < 0x4000 + control.second->GetSize()) {
+                LOG_ERROR(Service_NS,
+                          "output buffer is too small! (actual={:016X}, expected_min={:016X})",
+                          size, 0x4000 + control.second->GetSize());
+                IPC::ResponseBuilder rb{ctx, 2};
+                // TODO(DarkLordZach): Find a better error code for this.
+                rb.Push(ResultCode(-1));
+                return;
+            }
 
-    ctx.WriteBuffer(out);
+            out.resize(0x4000 + control.second->GetSize());
+            control.second->Read(out.data() + 0x4000, control.second->GetSize());
+        } else {
+            LOG_WARNING(Service_NS, "missing icon data for title_id={:016X}, defaulting to zeros.",
+                        title_id);
+        }
 
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(static_cast<u32>(out.size()));
-}
+        ctx.WriteBuffer(out);
 
-void IApplicationManagerInterface::GetApplicationDesiredLanguage(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto supported_languages = rp.Pop<u32>();
-
-    const auto res = GetApplicationDesiredLanguage(supported_languages);
-    if (res.Succeeded()) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(*res);
-    } else {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        rb.Push<u32>(static_cast<u32>(out.size()));
     }
-}
+};
 
-ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
-    const u32 supported_languages) {
-    LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
+class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
+public:
+    explicit IApplicationVersionInterface() : ServiceFramework{"IApplicationVersionInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetLaunchRequiredVersion"},
+            {1, nullptr, "UpgradeLaunchRequiredVersion"},
+            {35, nullptr, "UpdateVersionList"},
+            {36, nullptr, "PushLaunchVersion"},
+            {37, nullptr, "ListRequiredVersion"},
+            {800, nullptr, "RequestVersionList"},
+            {801, nullptr, "ListVersionList"},
+            {802, nullptr, "RequestVersionListData"},
+            {1000, nullptr, "PerformAutoUpdate"},
+        };
+        // clang-format on
 
-    // Get language code from settings
-    const auto language_code = Set::GetLanguageCodeFromIndex(Settings::values.language_index);
-
-    // Convert to application language, get priority list
-    const auto application_language = ConvertToApplicationLanguage(language_code);
-    if (application_language == std::nullopt) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+        RegisterHandlers(functions);
     }
-    const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
-    if (!priority_list) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+};
+
+class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
+public:
+    explicit IContentManagerInterface() : ServiceFramework{"IContentManagerInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {11, nullptr, "CalculateApplicationOccupiedSize"},
+            {43, nullptr, "CheckSdCardMountStatus"},
+            {47, nullptr, "GetTotalSpaceSize"},
+            {48, nullptr, "GetFreeSpaceSize"},
+            {600, nullptr, "CountApplicationContentMeta"},
+            {601, nullptr, "ListApplicationContentMetaStatus"},
+            {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
+            {607, nullptr, "IsAnyApplicationRunning"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    // Try to find a valid language.
-    for (const auto lang : *priority_list) {
-        const auto supported_flag = GetSupportedLanguageFlag(lang);
-        if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
-            return MakeResult(static_cast<u8>(lang));
-        }
+class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
+public:
+    explicit IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {21, nullptr, "GetApplicationContentPath"},
+            {23, nullptr, "ResolveApplicationContentPath"},
+            {93, nullptr, "GetRunningApplicationProgramId"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
-}
+class IDownloadTaskInterface final : public ServiceFramework<IDownloadTaskInterface> {
+public:
+    explicit IDownloadTaskInterface() : ServiceFramework{"IDownloadTaskInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {701, nullptr, "ClearTaskStatusList"},
+            {702, nullptr, "RequestDownloadTaskList"},
+            {703, nullptr, "RequestEnsureDownloadTask"},
+            {704, nullptr, "ListDownloadTaskStatus"},
+            {705, nullptr, "RequestDownloadTaskListData"},
+            {706, nullptr, "TryCommitCurrentApplicationDownloadTask"},
+            {707, nullptr, "EnableAutoCommit"},
+            {708, nullptr, "DisableAutoCommit"},
+            {709, nullptr, "TriggerDynamicCommitEvent"},
+        };
+        // clang-format on
 
-void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto application_language = rp.Pop<u8>();
-
-    const auto res = ConvertApplicationLanguageToLanguageCode(application_language);
-    if (res.Succeeded()) {
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(*res);
-    } else {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(res.Code());
+        RegisterHandlers(functions);
     }
-}
+};
 
-ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
-    u8 application_language) {
-    const auto language_code =
-        ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
-    if (language_code == std::nullopt) {
-        return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
+class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
+public:
+    explicit IECommerceInterface() : ServiceFramework{"IECommerceInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestLinkDevice"},
+            {1, nullptr, "RequestCleanupAllPreInstalledApplications"},
+            {2, nullptr, "RequestCleanupPreInstalledApplication"},
+            {3, nullptr, "RequestSyncRights"},
+            {4, nullptr, "RequestUnlinkDevice"},
+            {5, nullptr, "RequestRevokeAllELicense"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
+};
 
-    return MakeResult(static_cast<u64>(*language_code));
-}
-
-IApplicationVersionInterface::IApplicationVersionInterface()
-    : ServiceFramework{"IApplicationVersionInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "GetLaunchRequiredVersion"},
-        {1, nullptr, "UpgradeLaunchRequiredVersion"},
-        {35, nullptr, "UpdateVersionList"},
-        {36, nullptr, "PushLaunchVersion"},
-        {37, nullptr, "ListRequiredVersion"},
-        {800, nullptr, "RequestVersionList"},
-        {801, nullptr, "ListVersionList"},
-        {802, nullptr, "RequestVersionListData"},
-        {1000, nullptr, "PerformAutoUpdate"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IApplicationVersionInterface::~IApplicationVersionInterface() = default;
-
-IContentManagerInterface::IContentManagerInterface()
-    : ServiceFramework{"IContentManagerInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {11, nullptr, "CalculateApplicationOccupiedSize"},
-        {43, nullptr, "CheckSdCardMountStatus"},
-        {47, nullptr, "GetTotalSpaceSize"},
-        {48, nullptr, "GetFreeSpaceSize"},
-        {600, nullptr, "CountApplicationContentMeta"},
-        {601, nullptr, "ListApplicationContentMetaStatus"},
-        {605, nullptr, "ListApplicationContentMetaStatusWithRightsCheck"},
-        {607, nullptr, "IsAnyApplicationRunning"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IContentManagerInterface::~IContentManagerInterface() = default;
-
-IDocumentInterface::IDocumentInterface() : ServiceFramework{"IDocumentInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {21, nullptr, "GetApplicationContentPath"},
-        {23, nullptr, "ResolveApplicationContentPath"},
-        {93, nullptr, "GetRunningApplicationProgramId"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDocumentInterface::~IDocumentInterface() = default;
-
-IDownloadTaskInterface::IDownloadTaskInterface() : ServiceFramework{"IDownloadTaskInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {701, nullptr, "ClearTaskStatusList"},
-        {702, nullptr, "RequestDownloadTaskList"},
-        {703, nullptr, "RequestEnsureDownloadTask"},
-        {704, nullptr, "ListDownloadTaskStatus"},
-        {705, nullptr, "RequestDownloadTaskListData"},
-        {706, nullptr, "TryCommitCurrentApplicationDownloadTask"},
-        {707, nullptr, "EnableAutoCommit"},
-        {708, nullptr, "DisableAutoCommit"},
-        {709, nullptr, "TriggerDynamicCommitEvent"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IDownloadTaskInterface::~IDownloadTaskInterface() = default;
-
-IECommerceInterface::IECommerceInterface() : ServiceFramework{"IECommerceInterface"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "RequestLinkDevice"},
-        {1, nullptr, "RequestCleanupAllPreInstalledApplications"},
-        {2, nullptr, "RequestCleanupPreInstalledApplication"},
-        {3, nullptr, "RequestSyncRights"},
-        {4, nullptr, "RequestUnlinkDevice"},
-        {5, nullptr, "RequestRevokeAllELicense"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IECommerceInterface::~IECommerceInterface() = default;
-
-IFactoryResetInterface::IFactoryResetInterface::IFactoryResetInterface()
-    : ServiceFramework{"IFactoryResetInterface"} {
-    // clang-format off
+class IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
+public:
+    explicit IFactoryResetInterface() : ServiceFramework{"IFactoryResetInterface"} {
+        // clang-format off
         static const FunctionInfo functions[] = {
             {100, nullptr, "ResetToFactorySettings"},
             {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
             {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
         };
-    // clang-format on
+        // clang-format on
 
-    RegisterHandlers(functions);
-}
+        RegisterHandlers(functions);
+    }
+};
 
-IFactoryResetInterface::~IFactoryResetInterface() = default;
+class NS final : public ServiceFramework<NS> {
+public:
+    explicit NS(const char* name) : ServiceFramework{name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {7992, &NS::PushInterface<IECommerceInterface>, "GetECommerceInterface"},
+            {7993, &NS::PushInterface<IApplicationVersionInterface>, "GetApplicationVersionInterface"},
+            {7994, &NS::PushInterface<IFactoryResetInterface>, "GetFactoryResetInterface"},
+            {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
+            {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
+            {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
+            {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
+            {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
+        };
+        // clang-format on
 
-NS::NS(const char* name) : ServiceFramework{name} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {7992, &NS::PushInterface<IECommerceInterface>, "GetECommerceInterface"},
-        {7993, &NS::PushInterface<IApplicationVersionInterface>, "GetApplicationVersionInterface"},
-        {7994, &NS::PushInterface<IFactoryResetInterface>, "GetFactoryResetInterface"},
-        {7995, &NS::PushInterface<IAccountProxyInterface>, "GetAccountProxyInterface"},
-        {7996, &NS::PushInterface<IApplicationManagerInterface>, "GetApplicationManagerInterface"},
-        {7997, &NS::PushInterface<IDownloadTaskInterface>, "GetDownloadTaskInterface"},
-        {7998, &NS::PushInterface<IContentManagerInterface>, "GetContentManagementInterface"},
-        {7999, &NS::PushInterface<IDocumentInterface>, "GetDocumentInterface"},
-    };
-    // clang-format on
+        RegisterHandlers(functions);
+    }
 
-    RegisterHandlers(functions);
-}
+private:
+    template <typename T>
+    void PushInterface(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_NS, "called");
 
-NS::~NS() = default;
-
-std::shared_ptr<IApplicationManagerInterface> NS::GetApplicationManagerInterface() const {
-    return GetInterface<IApplicationManagerInterface>();
-}
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<T>();
+    }
+};
 
 class NS_DEV final : public ServiceFramework<NS_DEV> {
 public:

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

@@ -8,88 +8,6 @@
 
 namespace Service::NS {
 
-class IAccountProxyInterface final : public ServiceFramework<IAccountProxyInterface> {
-public:
-    explicit IAccountProxyInterface();
-    ~IAccountProxyInterface() override;
-};
-
-class IApplicationManagerInterface final : public ServiceFramework<IApplicationManagerInterface> {
-public:
-    explicit IApplicationManagerInterface();
-    ~IApplicationManagerInterface() override;
-
-    ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages);
-    ResultVal<u64> ConvertApplicationLanguageToLanguageCode(u8 application_language);
-
-private:
-    void GetApplicationControlData(Kernel::HLERequestContext& ctx);
-    void GetApplicationDesiredLanguage(Kernel::HLERequestContext& ctx);
-    void ConvertApplicationLanguageToLanguageCode(Kernel::HLERequestContext& ctx);
-};
-
-class IApplicationVersionInterface final : public ServiceFramework<IApplicationVersionInterface> {
-public:
-    explicit IApplicationVersionInterface();
-    ~IApplicationVersionInterface() override;
-};
-
-class IContentManagerInterface final : public ServiceFramework<IContentManagerInterface> {
-public:
-    explicit IContentManagerInterface();
-    ~IContentManagerInterface() override;
-};
-
-class IDocumentInterface final : public ServiceFramework<IDocumentInterface> {
-public:
-    explicit IDocumentInterface();
-    ~IDocumentInterface() override;
-};
-
-class IDownloadTaskInterface final : public ServiceFramework<IDownloadTaskInterface> {
-public:
-    explicit IDownloadTaskInterface();
-    ~IDownloadTaskInterface() override;
-};
-
-class IECommerceInterface final : public ServiceFramework<IECommerceInterface> {
-public:
-    explicit IECommerceInterface();
-    ~IECommerceInterface() override;
-};
-
-class IFactoryResetInterface final : public ServiceFramework<IFactoryResetInterface> {
-public:
-    explicit IFactoryResetInterface();
-    ~IFactoryResetInterface() override;
-};
-
-class NS final : public ServiceFramework<NS> {
-public:
-    explicit NS(const char* name);
-    ~NS() override;
-
-    std::shared_ptr<IApplicationManagerInterface> GetApplicationManagerInterface() const;
-
-private:
-    template <typename T>
-    void PushInterface(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NS, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<T>();
-    }
-
-    template <typename T>
-    std::shared_ptr<T> GetInterface() const {
-        static_assert(std::is_base_of_v<Kernel::SessionRequestHandler, T>,
-                      "Not a base of ServiceFrameworkBase");
-
-        return std::make_shared<T>();
-    }
-};
-
 /// Registers all NS services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

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

@@ -1,42 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-#include <optional>
-#include <string>
-#include "common/common_types.h"
-#include "core/hle/service/set/set.h"
-
-namespace Service::NS {
-/// This is nn::ns::detail::ApplicationLanguage
-enum class ApplicationLanguage : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish,
-    Japanese,
-    French,
-    German,
-    LatinAmericanSpanish,
-    Spanish,
-    Italian,
-    Dutch,
-    CanadianFrench,
-    Portuguese,
-    Russian,
-    Korean,
-    TraditionalChinese,
-    SimplifiedChinese,
-    Count
-};
-using ApplicationLanguagePriorityList =
-    const std::array<ApplicationLanguage, static_cast<std::size_t>(ApplicationLanguage::Count)>;
-
-constexpr u32 GetSupportedLanguageFlag(const ApplicationLanguage lang) {
-    return 1U << static_cast<u32>(lang);
-}
-
-const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(ApplicationLanguage lang);
-std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
-    Service::Set::LanguageCode language_code);
-std::optional<Service::Set::LanguageCode> ConvertToLanguageCode(ApplicationLanguage lang);
-} // namespace Service::NS

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

@@ -185,8 +185,7 @@ u32 nvhost_ctrl_gpu::GetGpuTime(const std::vector<u8>& input, std::vector<u8>& o
 
     IoctlGetGpuTime params{};
     std::memcpy(&params, input.data(), input.size());
-    const auto ns = Core::Timing::CyclesToNs(Core::System::GetInstance().CoreTiming().GetTicks());
-    params.gpu_time = static_cast<u64_le>(ns.count());
+    params.gpu_time = Core::Timing::cyclesToNs(Core::System::GetInstance().CoreTiming().GetTicks());
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }

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

@@ -108,9 +108,8 @@ private:
         LOG_DEBUG(Service_Time, "called");
 
         const auto& core_timing = Core::System::GetInstance().CoreTiming();
-        const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
-        const SteadyClockTimePoint steady_clock_time_point{static_cast<u64_le>(ms.count() / 1000),
-                                                           {}};
+        const SteadyClockTimePoint steady_clock_time_point{
+            Core::Timing::cyclesToMs(core_timing.GetTicks()) / 1000};
         IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(steady_clock_time_point);
@@ -285,8 +284,8 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     }
 
     const auto& core_timing = Core::System::GetInstance().CoreTiming();
-    const auto ms = Core::Timing::CyclesToMs(core_timing.GetTicks());
-    const SteadyClockTimePoint steady_clock_time_point{static_cast<u64_le>(ms.count() / 1000), {}};
+    const SteadyClockTimePoint steady_clock_time_point{
+        Core::Timing::cyclesToMs(core_timing.GetTicks()) / 1000, {}};
 
     CalendarTime calendar_time{};
     calendar_time.year = tm->tm_year + 1900;

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

@@ -556,7 +556,7 @@ private:
             } else {
                 // Wait the current thread until a buffer becomes available
                 ctx.SleepClientThread(
-                    "IHOSBinderDriver::DequeueBuffer", -1,
+                    Kernel::GetCurrentThread(), "IHOSBinderDriver::DequeueBuffer", -1,
                     [=](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
                         Kernel::ThreadWakeupReason reason) {
                         // Repeat TransactParcel DequeueBuffer when a buffer is available

src/core/loader/loader.h

@@ -153,6 +153,17 @@ public:
      */
     virtual LoadResult Load(Kernel::Process& process) = 0;
 
+    /**
+     * Loads the system mode that this application needs.
+     * This function defaults to 2 (96MB allocated to the application) if it can't read the
+     * information.
+     * @returns A pair with the optional system mode, and and the status.
+     */
+    virtual std::pair<std::optional<u32>, ResultStatus> LoadKernelSystemMode() {
+        // 96MB allocated to the application.
+        return std::make_pair(2, ResultStatus::Success);
+    }
+
     /**
      * Get the code (typically .code section) of the application
      * @param buffer Reference to buffer to store data

src/core/loader/nso.cpp

@@ -39,7 +39,7 @@ std::vector<u8> DecompressSegment(const std::vector<u8>& compressed_data,
     const std::vector<u8> uncompressed_data =
         Common::Compression::DecompressDataLZ4(compressed_data, header.size);
 
-    ASSERT_MSG(uncompressed_data.size() == header.size, "{} != {}", header.size,
+    ASSERT_MSG(uncompressed_data.size() == static_cast<int>(header.size), "{} != {}", header.size,
                uncompressed_data.size());
 
     return uncompressed_data;

src/core/settings.cpp

@@ -90,6 +90,7 @@ void LogSettings() {
     LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
     LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
     LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
+    LogSetting("Renderer_UseCompatibilityProfile", Settings::values.use_compatibility_profile);
     LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
     LogSetting("Renderer_UseAccurateGpuEmulation", Settings::values.use_accurate_gpu_emulation);
     LogSetting("Renderer_UseAsynchronousGpuEmulation",

src/core/settings.h

@@ -390,6 +390,7 @@ struct Values {
     float resolution_factor;
     bool use_frame_limit;
     u16 frame_limit;
+    bool use_compatibility_profile;
     bool use_disk_shader_cache;
     bool use_accurate_gpu_emulation;
     bool use_asynchronous_gpu_emulation;

src/core/telemetry_session.cpp

@@ -12,6 +12,7 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 
+#include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/loader/loader.h"
@@ -100,30 +101,7 @@ bool VerifyLogin(const std::string& username, const std::string& token) {
 #endif
 }
 
-TelemetrySession::TelemetrySession() = default;
-
-TelemetrySession::~TelemetrySession() {
-    // Log one-time session end information
-    const s64 shutdown_time{std::chrono::duration_cast<std::chrono::milliseconds>(
-                                std::chrono::system_clock::now().time_since_epoch())
-                                .count()};
-    AddField(Telemetry::FieldType::Session, "Shutdown_Time", shutdown_time);
-
-#ifdef ENABLE_WEB_SERVICE
-    auto backend = std::make_unique<WebService::TelemetryJson>(
-        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
-#else
-    auto backend = std::make_unique<Telemetry::NullVisitor>();
-#endif
-
-    // Complete the session, submitting to the web service backend if necessary
-    field_collection.Accept(*backend);
-    if (Settings::values.enable_telemetry) {
-        backend->Complete();
-    }
-}
-
-void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
+TelemetrySession::TelemetrySession() {
     // Log one-time top-level information
     AddField(Telemetry::FieldType::None, "TelemetryId", GetTelemetryId());
 
@@ -134,28 +112,26 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
     AddField(Telemetry::FieldType::Session, "Init_Time", init_time);
 
     u64 program_id{};
-    const Loader::ResultStatus res{app_loader.ReadProgramId(program_id)};
+    const Loader::ResultStatus res{System::GetInstance().GetAppLoader().ReadProgramId(program_id)};
     if (res == Loader::ResultStatus::Success) {
         const std::string formatted_program_id{fmt::format("{:016X}", program_id)};
         AddField(Telemetry::FieldType::Session, "ProgramId", formatted_program_id);
 
         std::string name;
-        app_loader.ReadTitle(name);
+        System::GetInstance().GetAppLoader().ReadTitle(name);
 
         if (name.empty()) {
             auto [nacp, icon_file] = FileSys::PatchManager(program_id).GetControlMetadata();
-            if (nacp != nullptr) {
+            if (nacp != nullptr)
                 name = nacp->GetApplicationName();
-            }
         }
 
-        if (!name.empty()) {
+        if (!name.empty())
             AddField(Telemetry::FieldType::Session, "ProgramName", name);
-        }
     }
 
     AddField(Telemetry::FieldType::Session, "ProgramFormat",
-             static_cast<u8>(app_loader.GetFileType()));
+             static_cast<u8>(System::GetInstance().GetAppLoader().GetFileType()));
 
     // Log application information
     Telemetry::AppendBuildInfo(field_collection);
@@ -186,6 +162,27 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
              Settings::values.use_docked_mode);
 }
 
+TelemetrySession::~TelemetrySession() {
+    // Log one-time session end information
+    const s64 shutdown_time{std::chrono::duration_cast<std::chrono::milliseconds>(
+                                std::chrono::system_clock::now().time_since_epoch())
+                                .count()};
+    AddField(Telemetry::FieldType::Session, "Shutdown_Time", shutdown_time);
+
+#ifdef ENABLE_WEB_SERVICE
+    auto backend = std::make_unique<WebService::TelemetryJson>(
+        Settings::values.web_api_url, Settings::values.yuzu_username, Settings::values.yuzu_token);
+#else
+    auto backend = std::make_unique<Telemetry::NullVisitor>();
+#endif
+
+    // Complete the session, submitting to web service if necessary
+    field_collection.Accept(*backend);
+    if (Settings::values.enable_telemetry)
+        backend->Complete();
+    backend = nullptr;
+}
+
 bool TelemetrySession::SubmitTestcase() {
 #ifdef ENABLE_WEB_SERVICE
     auto backend = std::make_unique<WebService::TelemetryJson>(

src/core/telemetry_session.h

@@ -4,13 +4,10 @@
 
 #pragma once
 
+#include <memory>
 #include <string>
 #include "common/telemetry.h"
 
-namespace Loader {
-class AppLoader;
-}
-
 namespace Core {
 
 /**
@@ -18,33 +15,11 @@ namespace Core {
  * session, logging any one-time fields. Interfaces with the telemetry backend used for submitting
  * data to the web service. Submits session data on close.
  */
-class TelemetrySession {
+class TelemetrySession : NonCopyable {
 public:
-    explicit TelemetrySession();
+    TelemetrySession();
     ~TelemetrySession();
 
-    TelemetrySession(const TelemetrySession&) = delete;
-    TelemetrySession& operator=(const TelemetrySession&) = delete;
-
-    TelemetrySession(TelemetrySession&&) = delete;
-    TelemetrySession& operator=(TelemetrySession&&) = delete;
-
-    /**
-     * Adds the initial telemetry info necessary when starting up a title.
-     *
-     * This includes information such as:
-     *   - Telemetry ID
-     *   - Initialization time
-     *   - Title ID
-     *   - Title name
-     *   - Title file format
-     *   - Miscellaneous settings values.
-     *
-     * @param app_loader The application loader to use to retrieve
-     *                   title-specific information.
-     */
-    void AddInitialInfo(Loader::AppLoader& app_loader);
-
     /**
      * Wrapper around the Telemetry::FieldCollection::AddField method.
      * @param type Type of the field to add.

src/input_common/sdl/sdl.h

@@ -6,8 +6,15 @@
 
 #include <memory>
 #include <vector>
+#include "core/frontend/input.h"
 #include "input_common/main.h"
 
+union SDL_Event;
+
+namespace Common {
+class ParamPackage;
+} // namespace Common
+
 namespace InputCommon::Polling {
 class DevicePoller;
 enum class DeviceType;

src/input_common/sdl/sdl_impl.cpp

@@ -6,6 +6,7 @@
 #include <atomic>
 #include <cmath>
 #include <functional>
+#include <iterator>
 #include <mutex>
 #include <string>
 #include <thread>
@@ -14,6 +15,7 @@
 #include <utility>
 #include <vector>
 #include <SDL.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/param_package.h"
@@ -21,10 +23,12 @@
 #include "core/frontend/input.h"
 #include "input_common/sdl/sdl_impl.h"
 
-namespace InputCommon::SDL {
+namespace InputCommon {
+
+namespace SDL {
 
 static std::string GetGUID(SDL_Joystick* joystick) {
-    const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
+    SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
     char guid_str[33];
     SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
     return guid_str;
@@ -33,27 +37,26 @@ static std::string GetGUID(SDL_Joystick* joystick) {
 /// Creates a ParamPackage from an SDL_Event that can directly be used to create a ButtonDevice
 static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event);
 
-static int SDLEventWatcher(void* user_data, SDL_Event* event) {
-    auto* const sdl_state = static_cast<SDLState*>(user_data);
-
+static int SDLEventWatcher(void* userdata, SDL_Event* event) {
+    SDLState* sdl_state = reinterpret_cast<SDLState*>(userdata);
     // Don't handle the event if we are configuring
     if (sdl_state->polling) {
         sdl_state->event_queue.Push(*event);
     } else {
         sdl_state->HandleGameControllerEvent(*event);
     }
-
     return 0;
 }
 
 class SDLJoystick {
 public:
-    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick)
-        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose} {}
+    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick,
+                decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose)
+        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, deleter} {}
 
     void SetButton(int button, bool value) {
         std::lock_guard lock{mutex};
-        state.buttons.insert_or_assign(button, value);
+        state.buttons[button] = value;
     }
 
     bool GetButton(int button) const {
@@ -63,7 +66,7 @@ public:
 
     void SetAxis(int axis, Sint16 value) {
         std::lock_guard lock{mutex};
-        state.axes.insert_or_assign(axis, value);
+        state.axes[axis] = value;
     }
 
     float GetAxis(int axis) const {
@@ -90,7 +93,7 @@ public:
 
     void SetHat(int hat, Uint8 direction) {
         std::lock_guard lock{mutex};
-        state.hats.insert_or_assign(hat, direction);
+        state.hats[hat] = direction;
     }
 
     bool GetHatDirection(int hat, Uint8 direction) const {
@@ -115,8 +118,10 @@ public:
         return sdl_joystick.get();
     }
 
-    void SetSDLJoystick(SDL_Joystick* joystick) {
-        sdl_joystick.reset(joystick);
+    void SetSDLJoystick(SDL_Joystick* joystick,
+                        decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose) {
+        sdl_joystick =
+            std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)>(joystick, deleter);
     }
 
 private:
@@ -131,57 +136,59 @@ private:
     mutable std::mutex mutex;
 };
 
+/**
+ * Get the nth joystick with the corresponding GUID
+ */
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& guid, int port) {
     std::lock_guard lock{joystick_map_mutex};
     const auto it = joystick_map.find(guid);
     if (it != joystick_map.end()) {
-        while (it->second.size() <= static_cast<std::size_t>(port)) {
-            auto joystick =
-                std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()), nullptr);
+        while (it->second.size() <= port) {
+            auto joystick = std::make_shared<SDLJoystick>(guid, it->second.size(), nullptr,
+                                                          [](SDL_Joystick*) {});
             it->second.emplace_back(std::move(joystick));
         }
         return it->second[port];
     }
-    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr);
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, [](SDL_Joystick*) {});
     return joystick_map[guid].emplace_back(std::move(joystick));
 }
 
+/**
+ * Check how many identical joysticks (by guid) were connected before the one with sdl_id and so tie
+ * it to a SDLJoystick with the same guid and that port
+ */
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
     auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
     const std::string guid = GetGUID(sdl_joystick);
 
     std::lock_guard lock{joystick_map_mutex};
-    const auto map_it = joystick_map.find(guid);
+    auto map_it = joystick_map.find(guid);
     if (map_it != joystick_map.end()) {
-        const auto vec_it =
-            std::find_if(map_it->second.begin(), map_it->second.end(),
-                         [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
-                             return sdl_joystick == joystick->GetSDLJoystick();
-                         });
+        auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                   [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                                       return sdl_joystick == joystick->GetSDLJoystick();
+                                   });
         if (vec_it != map_it->second.end()) {
             // This is the common case: There is already an existing SDL_Joystick maped to a
             // SDLJoystick. return the SDLJoystick
             return *vec_it;
         }
-
         // Search for a SDLJoystick without a mapped SDL_Joystick...
-        const auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
-                                             [](const std::shared_ptr<SDLJoystick>& joystick) {
-                                                 return !joystick->GetSDLJoystick();
-                                             });
+        auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                       [](const std::shared_ptr<SDLJoystick>& joystick) {
+                                           return !joystick->GetSDLJoystick();
+                                       });
         if (nullptr_it != map_it->second.end()) {
             // ... and map it
             (*nullptr_it)->SetSDLJoystick(sdl_joystick);
             return *nullptr_it;
         }
-
         // There is no SDLJoystick without a mapped SDL_Joystick
         // Create a new SDLJoystick
-        const int port = static_cast<int>(map_it->second.size());
-        auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick);
+        auto joystick = std::make_shared<SDLJoystick>(guid, map_it->second.size(), sdl_joystick);
         return map_it->second.emplace_back(std::move(joystick));
     }
-
     auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick);
     return joystick_map[guid].emplace_back(std::move(joystick));
 }
@@ -208,19 +215,17 @@ void SDLState::InitJoystick(int joystick_index) {
         (*it)->SetSDLJoystick(sdl_joystick);
         return;
     }
-    const int port = static_cast<int>(joystick_guid_list.size());
-    auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick);
+    auto joystick = std::make_shared<SDLJoystick>(guid, joystick_guid_list.size(), sdl_joystick);
     joystick_guid_list.emplace_back(std::move(joystick));
 }
 
 void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
-    const std::string guid = GetGUID(sdl_joystick);
-
+    std::string guid = GetGUID(sdl_joystick);
     std::shared_ptr<SDLJoystick> joystick;
     {
         std::lock_guard lock{joystick_map_mutex};
         // This call to guid is safe since the joystick is guaranteed to be in the map
-        const auto& joystick_guid_list = joystick_map[guid];
+        auto& joystick_guid_list = joystick_map[guid];
         const auto joystick_it =
             std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
                          [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
@@ -228,10 +233,9 @@ void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
                          });
         joystick = *joystick_it;
     }
-
-    // Destruct SDL_Joystick outside the lock guard because SDL can internally call the
-    // event callback which locks the mutex again.
-    joystick->SetSDLJoystick(nullptr);
+    // Destruct SDL_Joystick outside the lock guard because SDL can internally call event calback
+    // which locks the mutex again
+    joystick->SetSDLJoystick(nullptr, [](SDL_Joystick*) {});
 }
 
 void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
@@ -313,10 +317,9 @@ public:
           trigger_if_greater(trigger_if_greater_) {}
 
     bool GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis);
-        if (trigger_if_greater) {
+        float axis_value = joystick->GetAxis(axis);
+        if (trigger_if_greater)
             return axis_value > threshold;
-        }
         return axis_value < threshold;
     }
 
@@ -441,7 +444,7 @@ public:
         const int port = params.Get("port", 0);
         const int axis_x = params.Get("axis_x", 0);
         const int axis_y = params.Get("axis_y", 1);
-        const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+        float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
 
         auto joystick = state.GetSDLJoystickByGUID(guid, port);
 
@@ -467,7 +470,7 @@ SDLState::SDLState() {
         return;
     }
     if (SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1") == SDL_FALSE) {
-        LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
+        LOG_ERROR(Input, "Failed to set Hint for background events", SDL_GetError());
     }
 
     SDL_AddEventWatch(&SDLEventWatcher, this);
@@ -504,12 +507,12 @@ SDLState::~SDLState() {
     }
 }
 
-static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
+Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
     Common::ParamPackage params({{"engine", "sdl"}});
 
     switch (event.type) {
     case SDL_JOYAXISMOTION: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("axis", event.jaxis.axis);
@@ -523,14 +526,14 @@ static Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const
         break;
     }
     case SDL_JOYBUTTONUP: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("button", event.jbutton.button);
         break;
     }
     case SDL_JOYHATMOTION: {
-        const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
+        auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
         params.Set("port", joystick->GetPort());
         params.Set("guid", joystick->GetGUID());
         params.Set("hat", event.jhat.hat);
@@ -604,8 +607,8 @@ public:
         SDLPoller::Start();
 
         // Reset stored axes
-        analog_x_axis = -1;
-        analog_y_axis = -1;
+        analog_xaxis = -1;
+        analog_yaxis = -1;
         analog_axes_joystick = -1;
     }
 
@@ -617,25 +620,25 @@ public:
             }
             // An analog device needs two axes, so we need to store the axis for later and wait for
             // a second SDL event. The axes also must be from the same joystick.
-            const int axis = event.jaxis.axis;
-            if (analog_x_axis == -1) {
-                analog_x_axis = axis;
+            int axis = event.jaxis.axis;
+            if (analog_xaxis == -1) {
+                analog_xaxis = axis;
                 analog_axes_joystick = event.jaxis.which;
-            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+            } else if (analog_yaxis == -1 && analog_xaxis != axis &&
                        analog_axes_joystick == event.jaxis.which) {
-                analog_y_axis = axis;
+                analog_yaxis = axis;
             }
         }
         Common::ParamPackage params;
-        if (analog_x_axis != -1 && analog_y_axis != -1) {
-            const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        if (analog_xaxis != -1 && analog_yaxis != -1) {
+            auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
             params.Set("engine", "sdl");
             params.Set("port", joystick->GetPort());
             params.Set("guid", joystick->GetGUID());
-            params.Set("axis_x", analog_x_axis);
-            params.Set("axis_y", analog_y_axis);
-            analog_x_axis = -1;
-            analog_y_axis = -1;
+            params.Set("axis_x", analog_xaxis);
+            params.Set("axis_y", analog_yaxis);
+            analog_xaxis = -1;
+            analog_yaxis = -1;
             analog_axes_joystick = -1;
             return params;
         }
@@ -643,8 +646,8 @@ public:
     }
 
 private:
-    int analog_x_axis = -1;
-    int analog_y_axis = -1;
+    int analog_xaxis = -1;
+    int analog_yaxis = -1;
     SDL_JoystickID analog_axes_joystick = -1;
 };
 } // namespace Polling
@@ -664,4 +667,5 @@ SDLState::Pollers SDLState::GetPollers(InputCommon::Polling::DeviceType type) {
     return pollers;
 }
 
-} // namespace InputCommon::SDL
+} // namespace SDL
+} // namespace InputCommon

src/input_common/sdl/sdl_impl.h

@@ -6,10 +6,7 @@
 
 #include <atomic>
 #include <memory>
-#include <mutex>
 #include <thread>
-#include <unordered_map>
-#include "common/common_types.h"
 #include "common/threadsafe_queue.h"
 #include "input_common/sdl/sdl.h"
 
@@ -19,9 +16,9 @@ using SDL_JoystickID = s32;
 
 namespace InputCommon::SDL {
 
-class SDLAnalogFactory;
-class SDLButtonFactory;
 class SDLJoystick;
+class SDLButtonFactory;
+class SDLAnalogFactory;
 
 class SDLState : public State {
 public:
@@ -34,13 +31,7 @@ public:
     /// Handle SDL_Events for joysticks from SDL_PollEvent
     void HandleGameControllerEvent(const SDL_Event& event);
 
-    /// Get the nth joystick with the corresponding GUID
     std::shared_ptr<SDLJoystick> GetSDLJoystickBySDLID(SDL_JoystickID sdl_id);
-
-    /**
-     * Check how many identical joysticks (by guid) were connected before the one with sdl_id and so
-     * tie it to a SDLJoystick with the same guid and that port
-     */
     std::shared_ptr<SDLJoystick> GetSDLJoystickByGUID(const std::string& guid, int port);
 
     /// Get all DevicePoller that use the SDL backend for a specific device type

src/tests/core/arm/arm_test_common.cpp

@@ -16,8 +16,7 @@ namespace ArmTests {
 TestEnvironment::TestEnvironment(bool mutable_memory_)
     : mutable_memory(mutable_memory_),
       test_memory(std::make_shared<TestMemory>(this)), kernel{Core::System::GetInstance()} {
-    auto process = Kernel::Process::Create(Core::System::GetInstance(), "",
-                                           Kernel::Process::ProcessType::Userland);
+    auto process = Kernel::Process::Create(Core::System::GetInstance(), "");
     page_table = &process->VMManager().page_table;
 
     std::fill(page_table->pointers.begin(), page_table->pointers.end(), nullptr);

src/video_core/CMakeLists.txt

@@ -42,6 +42,8 @@ add_library(video_core STATIC
     renderer_opengl/gl_device.h
     renderer_opengl/gl_global_cache.cpp
     renderer_opengl/gl_global_cache.h
+    renderer_opengl/gl_primitive_assembler.cpp
+    renderer_opengl/gl_primitive_assembler.h
     renderer_opengl/gl_rasterizer.cpp
     renderer_opengl/gl_rasterizer.h
     renderer_opengl/gl_rasterizer_cache.cpp
@@ -100,9 +102,6 @@ add_library(video_core STATIC
     shader/decode/xmad.cpp
     shader/decode/other.cpp
     shader/decode.cpp
-    shader/node_helper.cpp
-    shader/node_helper.h
-    shader/node.h
     shader/shader_ir.cpp
     shader/shader_ir.h
     shader/track.cpp

src/video_core/engines/kepler_compute.h

@@ -140,7 +140,7 @@ public:
 
         BitField<0, 16, u32> shared_alloc;
 
-        BitField<16, 16, u32> block_dim_x;
+        BitField<0, 31, u32> block_dim_x;
         union {
             BitField<0, 16, u32> block_dim_y;
             BitField<16, 16, u32> block_dim_z;
@@ -153,7 +153,7 @@ public:
 
         INSERT_PADDING_WORDS(0x8);
 
-        struct ConstBufferConfig {
+        struct {
             u32 address_low;
             union {
                 BitField<0, 8, u32> address_high;
@@ -163,8 +163,7 @@ public:
                 return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high.Value()) << 32) |
                                              address_low);
             }
-        };
-        std::array<ConstBufferConfig, NumConstBuffers> const_buffer_config;
+        } const_buffer_config[8];
 
         union {
             BitField<0, 20, u32> local_pos_alloc;

src/video_core/engines/shader_bytecode.h

@@ -529,11 +529,6 @@ union Instruction {
     BitField<39, 8, Register> gpr39;
     BitField<48, 16, u64> opcode;
 
-    union {
-        BitField<8, 8, Register> gpr;
-        BitField<20, 24, s64> offset;
-    } gmem;
-
     union {
         BitField<20, 16, u64> imm20_16;
         BitField<20, 19, u64> imm20_19;
@@ -817,11 +812,13 @@ union Instruction {
     union {
         BitField<48, 3, UniformType> type;
         BitField<46, 2, u64> cache_mode;
+        BitField<20, 24, s64> immediate_offset;
     } ldg;
 
     union {
         BitField<48, 3, UniformType> type;
         BitField<46, 2, u64> cache_mode;
+        BitField<20, 24, s64> immediate_offset;
     } stg;
 
     union {
@@ -830,11 +827,6 @@ union Instruction {
         BitField<20, 11, u64> address;
     } al2p;
 
-    union {
-        BitField<53, 3, UniformType> type;
-        BitField<52, 1, u64> extended;
-    } generic;
-
     union {
         BitField<0, 3, u64> pred0;
         BitField<3, 3, u64> pred3;
@@ -1395,12 +1387,10 @@ public:
         LD_L,
         LD_S,
         LD_C,
-        LD,  // Load from generic memory
-        LDG, // Load from global memory
         ST_A,
         ST_L,
         ST_S,
-        ST,   // Store in generic memory
+        LDG,  // Load from global memory
         STG,  // Store in global memory
         AL2P, // Transforms attribute memory into physical memory
         TEX,
@@ -1663,18 +1653,15 @@ private:
             INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
             INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
             INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
-            INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),
             INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
             INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
             INST("1110111101001---", Id::LD_S, Type::Memory, "LD_S"),
             INST("1110111101000---", Id::LD_L, Type::Memory, "LD_L"),
             INST("1110111110010---", Id::LD_C, Type::Memory, "LD_C"),
-            INST("100-------------", Id::LD, Type::Memory, "LD"),
-            INST("1110111011010---", Id::LDG, Type::Memory, "LDG"),
             INST("1110111111110---", Id::ST_A, Type::Memory, "ST_A"),
             INST("1110111101011---", Id::ST_S, Type::Memory, "ST_S"),
             INST("1110111101010---", Id::ST_L, Type::Memory, "ST_L"),
-            INST("101-------------", Id::ST, Type::Memory, "ST"),
+            INST("1110111011010---", Id::LDG, Type::Memory, "LDG"),
             INST("1110111011011---", Id::STG, Type::Memory, "STG"),
             INST("1110111110100---", Id::AL2P, Type::Memory, "AL2P"),
             INST("110000----111---", Id::TEX, Type::Texture, "TEX"),
@@ -1687,6 +1674,7 @@ private:
             INST("1101111100------", Id::TLD4S, Type::Texture, "TLD4S"),
             INST("110111110110----", Id::TMML_B, Type::Texture, "TMML_B"),
             INST("1101111101011---", Id::TMML, Type::Texture, "TMML"),
+            INST("111000110000----", Id::EXIT, Type::Trivial, "EXIT"),
             INST("11100000--------", Id::IPA, Type::Trivial, "IPA"),
             INST("1111101111100---", Id::OUT_R, Type::Trivial, "OUT_R"),
             INST("1110111111010---", Id::ISBERD, Type::Trivial, "ISBERD"),

src/video_core/gpu_thread.cpp

@@ -75,7 +75,7 @@ void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Tegra::DmaPus
 
 void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
     const u64 fence{PushCommand(SubmitListCommand(std::move(entries)))};
-    const s64 synchronization_ticks{Core::Timing::usToCycles(std::chrono::microseconds{9000})};
+    const s64 synchronization_ticks{Core::Timing::usToCycles(9000)};
     system.CoreTiming().ScheduleEvent(synchronization_ticks, synchronization_event, fence);
 }
 

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -71,6 +71,16 @@ GLintptr OGLBufferCache::UploadHostMemory(const void* raw_pointer, std::size_t s
     return uploaded_offset;
 }
 
+std::tuple<u8*, GLintptr> OGLBufferCache::ReserveMemory(std::size_t size, std::size_t alignment) {
+    AlignBuffer(alignment);
+    u8* const uploaded_ptr = buffer_ptr;
+    const GLintptr uploaded_offset = buffer_offset;
+
+    buffer_ptr += size;
+    buffer_offset += size;
+    return std::make_tuple(uploaded_ptr, uploaded_offset);
+}
+
 bool OGLBufferCache::Map(std::size_t max_size) {
     bool invalidate;
     std::tie(buffer_ptr, buffer_offset_base, invalidate) =

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -61,6 +61,9 @@ public:
     /// Uploads from a host memory. Returns host's buffer offset where it's been allocated.
     GLintptr UploadHostMemory(const void* raw_pointer, std::size_t size, std::size_t alignment = 4);
 
+    /// Reserves memory to be used by host's CPU. Returns mapped address and offset.
+    std::tuple<u8*, GLintptr> ReserveMemory(std::size_t size, std::size_t alignment = 4);
+
     bool Map(std::size_t max_size);
     void Unmap();
 

src/video_core/renderer_opengl/gl_device.cpp

@@ -2,14 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
 #include <cstddef>
 #include <glad/glad.h>
 
 #include "common/logging/log.h"
-#include "common/scope_exit.h"
 #include "video_core/renderer_opengl/gl_device.h"
-#include "video_core/renderer_opengl/gl_resource_manager.h"
 
 namespace OpenGL {
 
@@ -27,7 +24,6 @@ Device::Device() {
     max_vertex_attributes = GetInteger<u32>(GL_MAX_VERTEX_ATTRIBS);
     max_varyings = GetInteger<u32>(GL_MAX_VARYING_VECTORS);
     has_variable_aoffi = TestVariableAoffi();
-    has_component_indexing_bug = TestComponentIndexingBug();
 }
 
 Device::Device(std::nullptr_t) {
@@ -35,12 +31,10 @@ Device::Device(std::nullptr_t) {
     max_vertex_attributes = 16;
     max_varyings = 15;
     has_variable_aoffi = true;
-    has_component_indexing_bug = false;
 }
 
 bool Device::TestVariableAoffi() {
     const GLchar* AOFFI_TEST = R"(#version 430 core
-// This is a unit test, please ignore me on apitrace bug reports.
 uniform sampler2D tex;
 uniform ivec2 variable_offset;
 void main() {
@@ -57,53 +51,4 @@ void main() {
     return supported;
 }
 
-bool Device::TestComponentIndexingBug() {
-    constexpr char log_message[] = "Renderer_ComponentIndexingBug: {}";
-    const GLchar* COMPONENT_TEST = R"(#version 430 core
-layout (std430, binding = 0) buffer OutputBuffer {
-    uint output_value;
-};
-layout (std140, binding = 0) uniform InputBuffer {
-    uvec4 input_value[4096];
-};
-layout (location = 0) uniform uint idx;
-void main() {
-    output_value = input_value[idx >> 2][idx & 3];
-})";
-    const GLuint shader{glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &COMPONENT_TEST)};
-    SCOPE_EXIT({ glDeleteProgram(shader); });
-    glUseProgram(shader);
-
-    OGLVertexArray vao;
-    vao.Create();
-    glBindVertexArray(vao.handle);
-
-    constexpr std::array<GLuint, 8> values{0, 0, 0, 0, 0x1236327, 0x985482, 0x872753, 0x2378432};
-    OGLBuffer ubo;
-    ubo.Create();
-    glNamedBufferData(ubo.handle, sizeof(values), values.data(), GL_STATIC_DRAW);
-    glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo.handle);
-
-    OGLBuffer ssbo;
-    ssbo.Create();
-    glNamedBufferStorage(ssbo.handle, sizeof(GLuint), nullptr, GL_CLIENT_STORAGE_BIT);
-
-    for (GLuint index = 4; index < 8; ++index) {
-        glInvalidateBufferData(ssbo.handle);
-        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, ssbo.handle);
-
-        glProgramUniform1ui(shader, 0, index);
-        glDrawArrays(GL_POINTS, 0, 1);
-
-        GLuint result;
-        glGetNamedBufferSubData(ssbo.handle, 0, sizeof(result), &result);
-        if (result != values.at(index)) {
-            LOG_INFO(Render_OpenGL, log_message, true);
-            return true;
-        }
-    }
-    LOG_INFO(Render_OpenGL, log_message, false);
-    return false;
-}
-
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_device.h

@@ -30,19 +30,13 @@ public:
         return has_variable_aoffi;
     }
 
-    bool HasComponentIndexingBug() const {
-        return has_component_indexing_bug;
-    }
-
 private:
     static bool TestVariableAoffi();
-    static bool TestComponentIndexingBug();
 
     std::size_t uniform_buffer_alignment{};
     u32 max_vertex_attributes{};
     u32 max_varyings{};
     bool has_variable_aoffi{};
-    bool has_component_indexing_bug{};
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_primitive_assembler.cpp

@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <array>
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "core/core.h"
+#include "video_core/memory_manager.h"
+#include "video_core/renderer_opengl/gl_buffer_cache.h"
+#include "video_core/renderer_opengl/gl_primitive_assembler.h"
+
+namespace OpenGL {
+
+constexpr u32 TRIANGLES_PER_QUAD = 6;
+constexpr std::array<u32, TRIANGLES_PER_QUAD> QUAD_MAP = {0, 1, 2, 0, 2, 3};
+
+PrimitiveAssembler::PrimitiveAssembler(OGLBufferCache& buffer_cache) : buffer_cache(buffer_cache) {}
+
+PrimitiveAssembler::~PrimitiveAssembler() = default;
+
+std::size_t PrimitiveAssembler::CalculateQuadSize(u32 count) const {
+    ASSERT_MSG(count % 4 == 0, "Quad count is expected to be a multiple of 4");
+    return (count / 4) * TRIANGLES_PER_QUAD * sizeof(GLuint);
+}
+
+GLintptr PrimitiveAssembler::MakeQuadArray(u32 first, u32 count) {
+    const std::size_t size{CalculateQuadSize(count)};
+    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(size);
+
+    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
+        for (u32 i = 0; i < TRIANGLES_PER_QUAD; ++i) {
+            const u32 index = first + primitive * 4 + QUAD_MAP[i];
+            std::memcpy(dst_pointer, &index, sizeof(index));
+            dst_pointer += sizeof(index);
+        }
+    }
+
+    return index_offset;
+}
+
+GLintptr PrimitiveAssembler::MakeQuadIndexed(GPUVAddr gpu_addr, std::size_t index_size, u32 count) {
+    const std::size_t map_size{CalculateQuadSize(count)};
+    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(map_size);
+
+    auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
+    const u8* source{memory_manager.GetPointer(gpu_addr)};
+
+    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
+        for (std::size_t i = 0; i < TRIANGLES_PER_QUAD; ++i) {
+            const u32 index = primitive * 4 + QUAD_MAP[i];
+            const u8* src_offset = source + (index * index_size);
+
+            std::memcpy(dst_pointer, src_offset, index_size);
+            dst_pointer += index_size;
+        }
+    }
+
+    return index_offset;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_primitive_assembler.h

@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <glad/glad.h>
+
+#include "common/common_types.h"
+
+namespace OpenGL {
+
+class OGLBufferCache;
+
+class PrimitiveAssembler {
+public:
+    explicit PrimitiveAssembler(OGLBufferCache& buffer_cache);
+    ~PrimitiveAssembler();
+
+    /// Calculates the size required by MakeQuadArray and MakeQuadIndexed.
+    std::size_t CalculateQuadSize(u32 count) const;
+
+    GLintptr MakeQuadArray(u32 first, u32 count);
+
+    GLintptr MakeQuadIndexed(GPUVAddr gpu_addr, std::size_t index_size, u32 count);
+
+private:
+    OGLBufferCache& buffer_cache;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -98,11 +98,9 @@ struct FramebufferCacheKey {
     }
 };
 
-RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
-                                   ScreenInfo& info)
-    : res_cache{*this}, shader_cache{*this, system, emu_window, device},
-      global_cache{*this}, system{system}, screen_info{info},
-      buffer_cache(*this, STREAM_BUFFER_SIZE) {
+RasterizerOpenGL::RasterizerOpenGL(Core::System& system, ScreenInfo& info)
+    : res_cache{*this}, shader_cache{*this, system, device}, global_cache{*this}, system{system},
+      screen_info{info}, buffer_cache(*this, STREAM_BUFFER_SIZE) {
     OpenGLState::ApplyDefaultState();
 
     shader_program_manager = std::make_unique<GLShader::ProgramManager>();
@@ -246,6 +244,29 @@ DrawParameters RasterizerOpenGL::SetupDraw() {
     DrawParameters params{};
     params.current_instance = gpu.state.current_instance;
 
+    if (regs.draw.topology == Maxwell::PrimitiveTopology::Quads) {
+        MICROPROFILE_SCOPE(OpenGL_PrimitiveAssembly);
+
+        params.use_indexed = true;
+        params.primitive_mode = GL_TRIANGLES;
+
+        if (is_indexed) {
+            params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
+            params.count = (regs.index_array.count / 4) * 6;
+            params.index_buffer_offset = primitive_assembler.MakeQuadIndexed(
+                regs.index_array.IndexStart(), regs.index_array.FormatSizeInBytes(),
+                regs.index_array.count);
+            params.base_vertex = static_cast<GLint>(regs.vb_element_base);
+        } else {
+            // MakeQuadArray always generates u32 indexes
+            params.index_format = GL_UNSIGNED_INT;
+            params.count = (regs.vertex_buffer.count / 4) * 6;
+            params.index_buffer_offset = primitive_assembler.MakeQuadArray(
+                regs.vertex_buffer.first, regs.vertex_buffer.count);
+        }
+        return params;
+    }
+
     params.use_indexed = is_indexed;
     params.primitive_mode = MaxwellToGL::PrimitiveTopology(regs.draw.topology);
 
@@ -663,19 +684,30 @@ void RasterizerOpenGL::DrawArrays() {
     SyncCullMode();
     SyncPrimitiveRestart();
     SyncScissorTest(state);
+    // Alpha Testing is synced on shaders.
     SyncTransformFeedback();
     SyncPointState();
+    CheckAlphaTests();
     SyncPolygonOffset();
-    SyncAlphaTest();
+    // TODO(bunnei): Sync framebuffer_scale uniform here
+    // TODO(bunnei): Sync scissorbox uniform(s) here
 
     // Draw the vertex batch
     const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
 
     std::size_t buffer_size = CalculateVertexArraysSize();
 
-    // Add space for index buffer
-    if (is_indexed) {
-        buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
+    // Add space for index buffer (keeping in mind non-core primitives)
+    switch (regs.draw.topology) {
+    case Maxwell::PrimitiveTopology::Quads:
+        buffer_size = Common::AlignUp(buffer_size, 4) +
+                      primitive_assembler.CalculateQuadSize(regs.vertex_buffer.count);
+        break;
+    default:
+        if (is_indexed) {
+            buffer_size = Common::AlignUp(buffer_size, 4) + CalculateIndexBufferSize();
+        }
+        break;
     }
 
     // Uniform space for the 5 shader stages
@@ -1118,17 +1150,10 @@ void RasterizerOpenGL::SyncPolygonOffset() {
     state.polygon_offset.clamp = regs.polygon_offset_clamp;
 }
 
-void RasterizerOpenGL::SyncAlphaTest() {
+void RasterizerOpenGL::CheckAlphaTests() {
     const auto& regs = system.GPU().Maxwell3D().regs;
     UNIMPLEMENTED_IF_MSG(regs.alpha_test_enabled != 0 && regs.rt_control.count > 1,
                          "Alpha Testing is enabled with more than one rendertarget");
-
-    state.alpha_test.enabled = regs.alpha_test_enabled;
-    if (!state.alpha_test.enabled) {
-        return;
-    }
-    state.alpha_test.func = MaxwellToGL::ComparisonOp(regs.alpha_test_func);
-    state.alpha_test.ref = regs.alpha_test_ref;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -23,6 +23,7 @@
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_global_cache.h"
+#include "video_core/renderer_opengl/gl_primitive_assembler.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_sampler_cache.h"
@@ -47,8 +48,7 @@ struct FramebufferCacheKey;
 
 class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 public:
-    explicit RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWindow& emu_window,
-                              ScreenInfo& info);
+    explicit RasterizerOpenGL(Core::System& system, ScreenInfo& info);
     ~RasterizerOpenGL() override;
 
     void DrawArrays() override;
@@ -166,8 +166,8 @@ private:
     /// Syncs the polygon offsets
     void SyncPolygonOffset();
 
-    /// Syncs the alpha test state to match the guest state
-    void SyncAlphaTest();
+    /// Check asserts for alpha testing.
+    void CheckAlphaTests();
 
     /// Check for extension that are not strictly required
     /// but are needed for correct emulation
@@ -196,6 +196,7 @@ private:
 
     static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
     OGLBufferCache buffer_cache;
+    PrimitiveAssembler primitive_assembler{buffer_cache};
 
     BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
     BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -2,14 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <mutex>
-#include <thread>
 #include <boost/functional/hash.hpp>
 #include "common/assert.h"
 #include "common/hash.h"
-#include "common/scope_exit.h"
 #include "core/core.h"
-#include "core/frontend/emu_window.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
@@ -35,8 +31,8 @@ struct UnspecializedShader {
 namespace {
 
 /// Gets the address for the specified shader stage program
-GPUVAddr GetShaderAddress(Core::System& system, Maxwell::ShaderProgram program) {
-    const auto& gpu{system.GPU().Maxwell3D()};
+GPUVAddr GetShaderAddress(Maxwell::ShaderProgram program) {
+    const auto& gpu{Core::System::GetInstance().GPU().Maxwell3D()};
     const auto& shader_config{gpu.regs.shader_config[static_cast<std::size_t>(program)]};
     return gpu.regs.code_address.CodeAddress() + shader_config.offset;
 }
@@ -170,8 +166,7 @@ GLShader::ProgramResult CreateProgram(const Device& device, Maxwell::ShaderProgr
 CachedProgram SpecializeShader(const std::string& code, const GLShader::ShaderEntries& entries,
                                Maxwell::ShaderProgram program_type, BaseBindings base_bindings,
                                GLenum primitive_mode, bool hint_retrievable = false) {
-    std::string source = "#version 430 core\n"
-                         "#extension GL_ARB_separate_shader_objects : enable\n\n";
+    std::string source = "#version 430 core\n";
     source += fmt::format("#define EMULATION_UBO_BINDING {}\n", base_bindings.cbuf++);
 
     for (const auto& cbuf : entries.const_buffers) {
@@ -349,9 +344,8 @@ ShaderDiskCacheUsage CachedShader::GetUsage(GLenum primitive_mode,
 }
 
 ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
-                                     Core::Frontend::EmuWindow& emu_window, const Device& device)
-    : RasterizerCache{rasterizer}, system{system}, emu_window{emu_window}, device{device},
-      disk_cache{system} {}
+                                     const Device& device)
+    : RasterizerCache{rasterizer}, device{device}, disk_cache{system} {}
 
 void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
                                       const VideoCore::DiskResourceLoadCallback& callback) {
@@ -359,107 +353,62 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
     if (!transferable) {
         return;
     }
-    const auto [raws, shader_usages] = *transferable;
+    const auto [raws, usages] = *transferable;
 
     auto [decompiled, dumps] = disk_cache.LoadPrecompiled();
 
     const auto supported_formats{GetSupportedFormats()};
-    const auto unspecialized_shaders{
+    const auto unspecialized{
         GenerateUnspecializedShaders(stop_loading, callback, raws, decompiled)};
-    if (stop_loading) {
+    if (stop_loading)
         return;
-    }
 
     // Track if precompiled cache was altered during loading to know if we have to serialize the
     // virtual precompiled cache file back to the hard drive
     bool precompiled_cache_altered = false;
 
-    // Inform the frontend about shader build initialization
-    if (callback) {
-        callback(VideoCore::LoadCallbackStage::Build, 0, shader_usages.size());
-    }
+    // Build shaders
+    if (callback)
+        callback(VideoCore::LoadCallbackStage::Build, 0, usages.size());
+    for (std::size_t i = 0; i < usages.size(); ++i) {
+        if (stop_loading)
+            return;
 
-    std::mutex mutex;
-    std::size_t built_shaders = 0; // It doesn't have be atomic since it's used behind a mutex
-    std::atomic_bool compilation_failed = false;
+        const auto& usage{usages[i]};
+        LOG_INFO(Render_OpenGL, "Building shader {:016x} ({} of {})", usage.unique_identifier,
+                 i + 1, usages.size());
 
-    const auto Worker = [&](Core::Frontend::GraphicsContext* context, std::size_t begin,
-                            std::size_t end, const std::vector<ShaderDiskCacheUsage>& shader_usages,
-                            const ShaderDumpsMap& dumps) {
-        context->MakeCurrent();
-        SCOPE_EXIT({ return context->DoneCurrent(); });
+        const auto& unspec{unspecialized.at(usage.unique_identifier)};
+        const auto dump_it = dumps.find(usage);
 
-        for (std::size_t i = begin; i < end; ++i) {
-            if (stop_loading || compilation_failed) {
-                return;
-            }
-            const auto& usage{shader_usages[i]};
-            LOG_INFO(Render_OpenGL, "Building shader {:016x} (index {} of {})",
-                     usage.unique_identifier, i, shader_usages.size());
-
-            const auto& unspecialized{unspecialized_shaders.at(usage.unique_identifier)};
-            const auto dump{dumps.find(usage)};
-
-            CachedProgram shader;
-            if (dump != dumps.end()) {
-                // If the shader is dumped, attempt to load it with
-                shader = GeneratePrecompiledProgram(dump->second, supported_formats);
-                if (!shader) {
-                    compilation_failed = true;
-                    return;
-                }
-            }
+        CachedProgram shader;
+        if (dump_it != dumps.end()) {
+            // If the shader is dumped, attempt to load it with
+            shader = GeneratePrecompiledProgram(dump_it->second, supported_formats);
             if (!shader) {
-                shader = SpecializeShader(unspecialized.code, unspecialized.entries,
-                                          unspecialized.program_type, usage.bindings,
-                                          usage.primitive, true);
+                // Invalidate the precompiled cache if a shader dumped shader was rejected
+                disk_cache.InvalidatePrecompiled();
+                precompiled_cache_altered = true;
+                dumps.clear();
             }
-
-            std::scoped_lock lock(mutex);
-            if (callback) {
-                callback(VideoCore::LoadCallbackStage::Build, ++built_shaders,
-                         shader_usages.size());
-            }
-
-            precompiled_programs.emplace(usage, std::move(shader));
         }
-    };
+        if (!shader) {
+            shader = SpecializeShader(unspec.code, unspec.entries, unspec.program_type,
+                                      usage.bindings, usage.primitive, true);
+        }
+        precompiled_programs.insert({usage, std::move(shader)});
 
-    const auto num_workers{static_cast<std::size_t>(std::thread::hardware_concurrency() + 1)};
-    const std::size_t bucket_size{shader_usages.size() / num_workers};
-    std::vector<std::unique_ptr<Core::Frontend::GraphicsContext>> contexts(num_workers);
-    std::vector<std::thread> threads(num_workers);
-    for (std::size_t i = 0; i < num_workers; ++i) {
-        const bool is_last_worker = i + 1 == num_workers;
-        const std::size_t start{bucket_size * i};
-        const std::size_t end{is_last_worker ? shader_usages.size() : start + bucket_size};
-
-        // On some platforms the shared context has to be created from the GUI thread
-        contexts[i] = emu_window.CreateSharedContext();
-        threads[i] = std::thread(Worker, contexts[i].get(), start, end, shader_usages, dumps);
-    }
-    for (auto& thread : threads) {
-        thread.join();
-    }
-
-    if (compilation_failed) {
-        // Invalidate the precompiled cache if a shader dumped shader was rejected
-        disk_cache.InvalidatePrecompiled();
-        dumps.clear();
-        precompiled_cache_altered = true;
-        return;
-    }
-    if (stop_loading) {
-        return;
+        if (callback)
+            callback(VideoCore::LoadCallbackStage::Build, i + 1, usages.size());
     }
 
     // TODO(Rodrigo): Do state tracking for transferable shaders and do a dummy draw before
     // precompiling them
 
-    for (std::size_t i = 0; i < shader_usages.size(); ++i) {
-        const auto& usage{shader_usages[i]};
+    for (std::size_t i = 0; i < usages.size(); ++i) {
+        const auto& usage{usages[i]};
         if (dumps.find(usage) == dumps.end()) {
-            const auto& program{precompiled_programs.at(usage)};
+            const auto& program = precompiled_programs.at(usage);
             disk_cache.SaveDump(usage, program->handle);
             precompiled_cache_altered = true;
         }
@@ -547,45 +496,42 @@ std::unordered_map<u64, UnspecializedShader> ShaderCacheOpenGL::GenerateUnspecia
 }
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
-    if (!system.GPU().Maxwell3D().dirty_flags.shaders) {
-        return last_shaders[static_cast<std::size_t>(program)];
+    if (!Core::System::GetInstance().GPU().Maxwell3D().dirty_flags.shaders) {
+        return last_shaders[static_cast<u32>(program)];
     }
 
-    auto& memory_manager{system.GPU().MemoryManager()};
-    const GPUVAddr program_addr{GetShaderAddress(system, program)};
+    auto& memory_manager{Core::System::GetInstance().GPU().MemoryManager()};
+    const GPUVAddr program_addr{GetShaderAddress(program)};
 
     // Look up shader in the cache based on address
-    const auto host_ptr{memory_manager.GetPointer(program_addr)};
+    const auto& host_ptr{memory_manager.GetPointer(program_addr)};
     Shader shader{TryGet(host_ptr)};
-    if (shader) {
-        return last_shaders[static_cast<std::size_t>(program)] = shader;
+
+    if (!shader) {
+        // No shader found - create a new one
+        ProgramCode program_code{GetShaderCode(memory_manager, program_addr, host_ptr)};
+        ProgramCode program_code_b;
+        if (program == Maxwell::ShaderProgram::VertexA) {
+            const GPUVAddr program_addr_b{GetShaderAddress(Maxwell::ShaderProgram::VertexB)};
+            program_code_b = GetShaderCode(memory_manager, program_addr_b,
+                                           memory_manager.GetPointer(program_addr_b));
+        }
+        const u64 unique_identifier = GetUniqueIdentifier(program, program_code, program_code_b);
+        const VAddr cpu_addr{*memory_manager.GpuToCpuAddress(program_addr)};
+        const auto found = precompiled_shaders.find(unique_identifier);
+        if (found != precompiled_shaders.end()) {
+            shader =
+                std::make_shared<CachedShader>(cpu_addr, unique_identifier, program, disk_cache,
+                                               precompiled_programs, found->second, host_ptr);
+        } else {
+            shader = std::make_shared<CachedShader>(
+                device, cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
+                std::move(program_code), std::move(program_code_b), host_ptr);
+        }
+        Register(shader);
     }
 
-    // No shader found - create a new one
-    ProgramCode program_code{GetShaderCode(memory_manager, program_addr, host_ptr)};
-    ProgramCode program_code_b;
-    if (program == Maxwell::ShaderProgram::VertexA) {
-        const GPUVAddr program_addr_b{GetShaderAddress(system, Maxwell::ShaderProgram::VertexB)};
-        program_code_b = GetShaderCode(memory_manager, program_addr_b,
-                                       memory_manager.GetPointer(program_addr_b));
-    }
-
-    const u64 unique_identifier = GetUniqueIdentifier(program, program_code, program_code_b);
-    const VAddr cpu_addr{*memory_manager.GpuToCpuAddress(program_addr)};
-    const auto found = precompiled_shaders.find(unique_identifier);
-    if (found != precompiled_shaders.end()) {
-        // Create a shader from the cache
-        shader = std::make_shared<CachedShader>(cpu_addr, unique_identifier, program, disk_cache,
-                                                precompiled_programs, found->second, host_ptr);
-    } else {
-        // Create a shader from guest memory
-        shader = std::make_shared<CachedShader>(
-            device, cpu_addr, unique_identifier, program, disk_cache, precompiled_programs,
-            std::move(program_code), std::move(program_code_b), host_ptr);
-    }
-    Register(shader);
-
-    return last_shaders[static_cast<std::size_t>(program)] = shader;
+    return last_shaders[static_cast<u32>(program)] = shader;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -22,11 +22,7 @@
 
 namespace Core {
 class System;
-}
-
-namespace Core::Frontend {
-class EmuWindow;
-}
+} // namespace Core
 
 namespace OpenGL {
 
@@ -115,7 +111,7 @@ private:
 class ShaderCacheOpenGL final : public RasterizerCache<Shader> {
 public:
     explicit ShaderCacheOpenGL(RasterizerOpenGL& rasterizer, Core::System& system,
-                               Core::Frontend::EmuWindow& emu_window, const Device& device);
+                               const Device& device);
 
     /// Loads disk cache for the current game
     void LoadDiskCache(const std::atomic_bool& stop_loading,
@@ -137,14 +133,13 @@ private:
     CachedProgram GeneratePrecompiledProgram(const ShaderDiskCacheDump& dump,
                                              const std::set<GLenum>& supported_formats);
 
-    Core::System& system;
-    Core::Frontend::EmuWindow& emu_window;
     const Device& device;
-    ShaderDiskCacheOpenGL disk_cache;
 
+    std::array<Shader, Maxwell::MaxShaderProgram> last_shaders;
+
+    ShaderDiskCacheOpenGL disk_cache;
     PrecompiledShaders precompiled_shaders;
     PrecompiledPrograms precompiled_programs;
-    std::array<Shader, Maxwell::MaxShaderProgram> last_shaders;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -31,8 +31,6 @@ using Tegra::Shader::IpaInterpMode;
 using Tegra::Shader::IpaMode;
 using Tegra::Shader::IpaSampleMode;
 using Tegra::Shader::Register;
-
-using namespace std::string_literals;
 using namespace VideoCommon::Shader;
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
@@ -45,6 +43,7 @@ struct TextureAoffi {};
 using TextureArgument = std::pair<Type, Node>;
 using TextureIR = std::variant<TextureAoffi, TextureArgument>;
 
+enum : u32 { POSITION_VARYING_LOCATION = 0, GENERIC_VARYING_START_LOCATION = 1 };
 constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
     static_cast<u32>(RasterizerOpenGL::MaxConstbufferSize) / (4 * sizeof(float));
 
@@ -94,9 +93,11 @@ private:
 };
 
 /// Generates code to use for a swizzle operation.
-constexpr const char* GetSwizzle(u32 element) {
-    constexpr std::array<const char*, 4> swizzle = {".x", ".y", ".z", ".w"};
-    return swizzle.at(element);
+std::string GetSwizzle(u32 elem) {
+    ASSERT(elem <= 3);
+    std::string swizzle = ".";
+    swizzle += "xyzw"[elem];
+    return swizzle;
 }
 
 /// Translate topology
@@ -123,8 +124,8 @@ bool IsPrecise(Operation operand) {
     return false;
 }
 
-bool IsPrecise(const Node& node) {
-    if (const auto operation = std::get_if<OperationNode>(&*node)) {
+bool IsPrecise(Node node) {
+    if (const auto operation = std::get_if<OperationNode>(node)) {
         return IsPrecise(*operation);
     }
     return false;
@@ -246,12 +247,6 @@ private:
         code.AddLine("layout ({}, max_vertices = {}) out;", topology, max_vertices);
         code.AddNewLine();
 
-        code.AddLine("in gl_PerVertex {{");
-        ++code.scope;
-        code.AddLine("vec4 gl_Position;");
-        --code.scope;
-        code.AddLine("}} gl_in[];");
-
         DeclareVertexRedeclarations();
     }
 
@@ -354,7 +349,7 @@ private:
     }
 
     void DeclareInputAttribute(Attribute::Index index, bool skip_unused) {
-        const u32 location{GetGenericAttributeIndex(index)};
+        const u32 generic_index{GetGenericAttributeIndex(index)};
 
         std::string name{GetInputAttribute(index)};
         if (stage == ShaderStage::Geometry) {
@@ -363,13 +358,19 @@ private:
 
         std::string suffix;
         if (stage == ShaderStage::Fragment) {
-            const auto input_mode{header.ps.GetAttributeUse(location)};
+            const auto input_mode{header.ps.GetAttributeUse(generic_index)};
             if (skip_unused && input_mode == AttributeUse::Unused) {
                 return;
             }
             suffix = GetInputFlags(input_mode);
         }
 
+        u32 location = generic_index;
+        if (stage != ShaderStage::Vertex) {
+            // If inputs are varyings, add an offset
+            location += GENERIC_VARYING_START_LOCATION;
+        }
+
         code.AddLine("layout (location = {}) {} in vec4 {};", location, suffix, name);
     }
 
@@ -394,7 +395,7 @@ private:
     }
 
     void DeclareOutputAttribute(Attribute::Index index) {
-        const u32 location{GetGenericAttributeIndex(index)};
+        const u32 location{GetGenericAttributeIndex(index) + GENERIC_VARYING_START_LOCATION};
         code.AddLine("layout (location = {}) out vec4 {};", location, GetOutputAttribute(index));
     }
 
@@ -497,15 +498,15 @@ private:
     }
 
     void VisitBlock(const NodeBlock& bb) {
-        for (const auto& node : bb) {
+        for (const Node node : bb) {
             if (const std::string expr = Visit(node); !expr.empty()) {
                 code.AddLine(expr);
             }
         }
     }
 
-    std::string Visit(const Node& node) {
-        if (const auto operation = std::get_if<OperationNode>(&*node)) {
+    std::string Visit(Node node) {
+        if (const auto operation = std::get_if<OperationNode>(node)) {
             const auto operation_index = static_cast<std::size_t>(operation->GetCode());
             if (operation_index >= operation_decompilers.size()) {
                 UNREACHABLE_MSG("Out of bounds operation: {}", operation_index);
@@ -519,7 +520,7 @@ private:
             return (this->*decompiler)(*operation);
         }
 
-        if (const auto gpr = std::get_if<GprNode>(&*node)) {
+        if (const auto gpr = std::get_if<GprNode>(node)) {
             const u32 index = gpr->GetIndex();
             if (index == Register::ZeroIndex) {
                 return "0";
@@ -527,7 +528,7 @@ private:
             return GetRegister(index);
         }
 
-        if (const auto immediate = std::get_if<ImmediateNode>(&*node)) {
+        if (const auto immediate = std::get_if<ImmediateNode>(node)) {
             const u32 value = immediate->GetValue();
             if (value < 10) {
                 // For eyecandy avoid using hex numbers on single digits
@@ -536,7 +537,7 @@ private:
             return fmt::format("utof(0x{:x}u)", immediate->GetValue());
         }
 
-        if (const auto predicate = std::get_if<PredicateNode>(&*node)) {
+        if (const auto predicate = std::get_if<PredicateNode>(node)) {
             const auto value = [&]() -> std::string {
                 switch (const auto index = predicate->GetIndex(); index) {
                 case Tegra::Shader::Pred::UnusedIndex:
@@ -553,7 +554,7 @@ private:
             return value;
         }
 
-        if (const auto abuf = std::get_if<AbufNode>(&*node)) {
+        if (const auto abuf = std::get_if<AbufNode>(node)) {
             UNIMPLEMENTED_IF_MSG(abuf->IsPhysicalBuffer() && stage == ShaderStage::Geometry,
                                  "Physical attributes in geometry shaders are not implemented");
             if (abuf->IsPhysicalBuffer()) {
@@ -563,9 +564,9 @@ private:
             return ReadAttribute(abuf->GetIndex(), abuf->GetElement(), abuf->GetBuffer());
         }
 
-        if (const auto cbuf = std::get_if<CbufNode>(&*node)) {
+        if (const auto cbuf = std::get_if<CbufNode>(node)) {
             const Node offset = cbuf->GetOffset();
-            if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(offset)) {
                 // Direct access
                 const u32 offset_imm = immediate->GetValue();
                 ASSERT_MSG(offset_imm % 4 == 0, "Unaligned cbuf direct access");
@@ -576,47 +577,30 @@ private:
             if (std::holds_alternative<OperationNode>(*offset)) {
                 // Indirect access
                 const std::string final_offset = code.GenerateTemporary();
-                code.AddLine("uint {} = ftou({}) >> 2;", final_offset, Visit(offset));
-
-                if (!device.HasComponentIndexingBug()) {
-                    return fmt::format("{}[{} >> 2][{} & 3]", GetConstBuffer(cbuf->GetIndex()),
-                                       final_offset, final_offset);
-                }
-
-                // AMD's proprietary GLSL compiler emits ill code for variable component access.
-                // To bypass this driver bug generate 4 ifs, one per each component.
-                const std::string pack = code.GenerateTemporary();
-                code.AddLine("vec4 {} = {}[{} >> 2];", pack, GetConstBuffer(cbuf->GetIndex()),
-                             final_offset);
-
-                const std::string result = code.GenerateTemporary();
-                code.AddLine("float {};", result);
-                for (u32 swizzle = 0; swizzle < 4; ++swizzle) {
-                    code.AddLine("if (({} & 3) == {}) {} = {}{};", final_offset, swizzle, result,
-                                 pack, GetSwizzle(swizzle));
-                }
-                return result;
+                code.AddLine("uint {} = (ftou({}) / 4);", final_offset, Visit(offset));
+                return fmt::format("{}[{} / 4][{} % 4]", GetConstBuffer(cbuf->GetIndex()),
+                                   final_offset, final_offset);
             }
 
             UNREACHABLE_MSG("Unmanaged offset node type");
         }
 
-        if (const auto gmem = std::get_if<GmemNode>(&*node)) {
+        if (const auto gmem = std::get_if<GmemNode>(node)) {
             const std::string real = Visit(gmem->GetRealAddress());
             const std::string base = Visit(gmem->GetBaseAddress());
             const std::string final_offset = fmt::format("(ftou({}) - ftou({})) / 4", real, base);
             return fmt::format("{}[{}]", GetGlobalMemory(gmem->GetDescriptor()), final_offset);
         }
 
-        if (const auto lmem = std::get_if<LmemNode>(&*node)) {
+        if (const auto lmem = std::get_if<LmemNode>(node)) {
             return fmt::format("{}[ftou({}) / 4]", GetLocalMemory(), Visit(lmem->GetAddress()));
         }
 
-        if (const auto internal_flag = std::get_if<InternalFlagNode>(&*node)) {
+        if (const auto internal_flag = std::get_if<InternalFlagNode>(node)) {
             return GetInternalFlag(internal_flag->GetFlag());
         }
 
-        if (const auto conditional = std::get_if<ConditionalNode>(&*node)) {
+        if (const auto conditional = std::get_if<ConditionalNode>(node)) {
             // It's invalid to call conditional on nested nodes, use an operation instead
             code.AddLine("if ({}) {{", Visit(conditional->GetCondition()));
             ++code.scope;
@@ -628,7 +612,7 @@ private:
             return {};
         }
 
-        if (const auto comment = std::get_if<CommentNode>(&*node)) {
+        if (const auto comment = std::get_if<CommentNode>(node)) {
             return "// " + comment->GetText();
         }
 
@@ -636,7 +620,7 @@ private:
         return {};
     }
 
-    std::string ReadAttribute(Attribute::Index attribute, u32 element, const Node& buffer = {}) {
+    std::string ReadAttribute(Attribute::Index attribute, u32 element, Node buffer = {}) {
         const auto GeometryPass = [&](std::string_view name) {
             if (stage == ShaderStage::Geometry && buffer) {
                 // TODO(Rodrigo): Guard geometry inputs against out of bound reads. Some games
@@ -649,14 +633,10 @@ private:
 
         switch (attribute) {
         case Attribute::Index::Position:
-            switch (stage) {
-            case ShaderStage::Geometry:
-                return fmt::format("gl_in[ftou({})].gl_Position{}", Visit(buffer),
-                                   GetSwizzle(element));
-            case ShaderStage::Fragment:
-                return element == 3 ? "1.0f" : ("gl_FragCoord"s + GetSwizzle(element));
-            default:
-                UNREACHABLE();
+            if (stage != ShaderStage::Fragment) {
+                return GeometryPass("position") + GetSwizzle(element);
+            } else {
+                return element == 3 ? "1.0f" : "gl_FragCoord" + GetSwizzle(element);
             }
         case Attribute::Index::PointCoord:
             switch (element) {
@@ -872,7 +852,7 @@ private:
         std::string expr = ", ";
         switch (type) {
         case Type::Int:
-            if (const auto immediate = std::get_if<ImmediateNode>(&*operand)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(operand)) {
                 // Inline the string as an immediate integer in GLSL (some extra arguments are
                 // required to be constant)
                 expr += std::to_string(static_cast<s32>(immediate->GetValue()));
@@ -904,7 +884,7 @@ private:
 
         for (std::size_t index = 0; index < aoffi.size(); ++index) {
             const auto operand{aoffi.at(index)};
-            if (const auto immediate = std::get_if<ImmediateNode>(&*operand)) {
+            if (const auto immediate = std::get_if<ImmediateNode>(operand)) {
                 // Inline the string as an immediate integer in GLSL (AOFFI arguments are required
                 // to be constant by the standard).
                 expr += std::to_string(static_cast<s32>(immediate->GetValue()));
@@ -925,23 +905,23 @@ private:
     }
 
     std::string Assign(Operation operation) {
-        const Node& dest = operation[0];
-        const Node& src = operation[1];
+        const Node dest = operation[0];
+        const Node src = operation[1];
 
         std::string target;
-        if (const auto gpr = std::get_if<GprNode>(&*dest)) {
+        if (const auto gpr = std::get_if<GprNode>(dest)) {
             if (gpr->GetIndex() == Register::ZeroIndex) {
                 // Writing to Register::ZeroIndex is a no op
                 return {};
             }
             target = GetRegister(gpr->GetIndex());
-        } else if (const auto abuf = std::get_if<AbufNode>(&*dest)) {
+        } else if (const auto abuf = std::get_if<AbufNode>(dest)) {
             UNIMPLEMENTED_IF(abuf->IsPhysicalBuffer());
 
             target = [&]() -> std::string {
                 switch (const auto attribute = abuf->GetIndex(); abuf->GetIndex()) {
                 case Attribute::Index::Position:
-                    return "gl_Position"s + GetSwizzle(abuf->GetElement());
+                    return "position" + GetSwizzle(abuf->GetElement());
                 case Attribute::Index::PointSize:
                     return "gl_PointSize";
                 case Attribute::Index::ClipDistances0123:
@@ -957,9 +937,9 @@ private:
                     return "0";
                 }
             }();
-        } else if (const auto lmem = std::get_if<LmemNode>(&*dest)) {
+        } else if (const auto lmem = std::get_if<LmemNode>(dest)) {
             target = fmt::format("{}[ftou({}) / 4]", GetLocalMemory(), Visit(lmem->GetAddress()));
-        } else if (const auto gmem = std::get_if<GmemNode>(&*dest)) {
+        } else if (const auto gmem = std::get_if<GmemNode>(dest)) {
             const std::string real = Visit(gmem->GetRealAddress());
             const std::string base = Visit(gmem->GetBaseAddress());
             const std::string final_offset = fmt::format("(ftou({}) - ftou({})) / 4", real, base);
@@ -1236,12 +1216,12 @@ private:
     }
 
     std::string LogicalAssign(Operation operation) {
-        const Node& dest = operation[0];
-        const Node& src = operation[1];
+        const Node dest = operation[0];
+        const Node src = operation[1];
 
         std::string target;
 
-        if (const auto pred = std::get_if<PredicateNode>(&*dest)) {
+        if (const auto pred = std::get_if<PredicateNode>(dest)) {
             ASSERT_MSG(!pred->IsNegated(), "Negating logical assignment");
 
             const auto index = pred->GetIndex();
@@ -1252,7 +1232,7 @@ private:
                 return {};
             }
             target = GetPredicate(index);
-        } else if (const auto flag = std::get_if<InternalFlagNode>(&*dest)) {
+        } else if (const auto flag = std::get_if<InternalFlagNode>(dest)) {
             target = GetInternalFlag(flag->GetFlag());
         }
 
@@ -1429,7 +1409,7 @@ private:
     }
 
     std::string Branch(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
+        const auto target = std::get_if<ImmediateNode>(operation[0]);
         UNIMPLEMENTED_IF(!target);
 
         code.AddLine("jmp_to = 0x{:x}u;", target->GetValue());
@@ -1438,7 +1418,7 @@ private:
     }
 
     std::string PushFlowStack(Operation operation) {
-        const auto target = std::get_if<ImmediateNode>(&*operation[0]);
+        const auto target = std::get_if<ImmediateNode>(operation[0]);
         UNIMPLEMENTED_IF(!target);
 
         code.AddLine("flow_stack[flow_stack_top++] = 0x{:x}u;", target->GetValue());
@@ -1467,9 +1447,27 @@ private:
 
         UNIMPLEMENTED_IF_MSG(header.ps.omap.sample_mask != 0, "Sample mask write is unimplemented");
 
+        code.AddLine("if (alpha_test[0] != 0) {{");
+        ++code.scope;
+        // We start on the register containing the alpha value in the first RT.
+        u32 current_reg = 3;
+        for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
+            // TODO(Blinkhawk): verify the behavior of alpha testing on hardware when
+            // multiple render targets are used.
+            if (header.ps.IsColorComponentOutputEnabled(render_target, 0) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 1) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 2) ||
+                header.ps.IsColorComponentOutputEnabled(render_target, 3)) {
+                code.AddLine("if (!AlphaFunc({})) discard;", SafeGetRegister(current_reg));
+                current_reg += 4;
+            }
+        }
+        --code.scope;
+        code.AddLine("}}");
+
         // Write the color outputs using the data in the shader registers, disabled
         // rendertargets/components are skipped in the register assignment.
-        u32 current_reg = 0;
+        current_reg = 0;
         for (u32 render_target = 0; render_target < Maxwell::NumRenderTargets; ++render_target) {
             // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
             for (u32 component = 0; component < 4; ++component) {
@@ -1508,7 +1506,9 @@ private:
 
         // If a geometry shader is attached, it will always flip (it's the last stage before
         // fragment). For more info about flipping, refer to gl_shader_gen.cpp.
-        code.AddLine("gl_Position.xy *= viewport_flip.xy;");
+        code.AddLine("position.xy *= viewport_flip.xy;");
+        code.AddLine("gl_Position = position;");
+        code.AddLine("position.w = 1.0;");
         code.AddLine("EmitVertex();");
         return {};
     }
@@ -1526,16 +1526,6 @@ private:
         return "uintBitsToFloat(config_pack[2])";
     }
 
-    template <u32 element>
-    std::string LocalInvocationId(Operation) {
-        return "utof(gl_LocalInvocationID"s + GetSwizzle(element) + ')';
-    }
-
-    template <u32 element>
-    std::string WorkGroupId(Operation) {
-        return "utof(gl_WorkGroupID"s + GetSwizzle(element) + ')';
-    }
-
     static constexpr OperationDecompilersArray operation_decompilers = {
         &GLSLDecompiler::Assign,
 
@@ -1675,12 +1665,6 @@ private:
         &GLSLDecompiler::EndPrimitive,
 
         &GLSLDecompiler::YNegate,
-        &GLSLDecompiler::LocalInvocationId<0>,
-        &GLSLDecompiler::LocalInvocationId<1>,
-        &GLSLDecompiler::LocalInvocationId<2>,
-        &GLSLDecompiler::WorkGroupId<0>,
-        &GLSLDecompiler::WorkGroupId<1>,
-        &GLSLDecompiler::WorkGroupId<2>,
     };
 
     std::string GetRegister(u32 index) const {
@@ -1746,7 +1730,8 @@ private:
     }
 
     u32 GetNumPhysicalVaryings() const {
-        return std::min<u32>(device.GetMaxVaryings(), Maxwell::NumVaryings);
+        return std::min<u32>(device.GetMaxVaryings() - GENERIC_VARYING_START_LOCATION,
+                             Maxwell::NumVaryings);
     }
 
     const Device& device;

src/video_core/renderer_opengl/gl_shader_disk_cache.cpp

@@ -183,7 +183,8 @@ ShaderDiskCacheOpenGL::LoadTransferable() {
     return {{raws, usages}};
 }
 
-std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>, ShaderDumpsMap>
+std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+          std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>
 ShaderDiskCacheOpenGL::LoadPrecompiled() {
     if (!IsUsable())
         return {};
@@ -207,7 +208,8 @@ ShaderDiskCacheOpenGL::LoadPrecompiled() {
     return *result;
 }
 
-std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>, ShaderDumpsMap>>
+std::optional<std::pair<std::unordered_map<u64, ShaderDiskCacheDecompiled>,
+                        std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>>>
 ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
     // Read compressed file from disk and decompress to virtual precompiled cache file
     std::vector<u8> compressed(file.GetSize());
@@ -228,7 +230,7 @@ ShaderDiskCacheOpenGL::LoadPrecompiledFile(FileUtil::IOFile& file) {
     }
 
     std::unordered_map<u64, ShaderDiskCacheDecompiled> decompiled;
-    ShaderDumpsMap dumps;
+    std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump> dumps;
     while (precompiled_cache_virtual_file_offset < precompiled_cache_virtual_file.GetSize()) {
         PrecompiledEntryKind kind{};
         if (!LoadObjectFromPrecompiled(kind)) {

src/video_core/renderer_opengl/gl_shader_disk_cache.h

@@ -33,11 +33,6 @@ namespace OpenGL {
 using ProgramCode = std::vector<u64>;
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
-struct ShaderDiskCacheUsage;
-struct ShaderDiskCacheDump;
-
-using ShaderDumpsMap = std::unordered_map<ShaderDiskCacheUsage, ShaderDiskCacheDump>;
-
 /// Allocated bindings used by an OpenGL shader program
 struct BaseBindings {
     u32 cbuf{};
@@ -299,4 +294,4 @@ private:
     bool tried_to_load{};
 };
 
-} // namespace OpenGL
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -19,13 +19,17 @@ static constexpr u32 PROGRAM_OFFSET{10};
 ProgramResult GenerateVertexShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "// Shader Unique Id: VS" + id + "\n\n";
+    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
+    out += "// Shader Unique Id: VS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
+layout (location = 0) out vec4 position;
+
 layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
+    uvec4 alpha_test;
 };
 
 )";
@@ -45,6 +49,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
 
     out += R"(
 void main() {
+    position = vec4(0.0, 0.0, 0.0, 0.0);
     execute_vertex();
 )";
 
@@ -55,12 +60,19 @@ void main() {
     out += R"(
 
     // Set Position Y direction
-    gl_Position.y *= utof(config_pack[2]);
+    position.y *= utof(config_pack[2]);
     // Check if the flip stage is VertexB
     // Config pack's second value is flip_stage
     if (config_pack[1] == 1) {
         // Viewport can be flipped, which is unsupported by glViewport
-        gl_Position.xy *= viewport_flip.xy;
+        position.xy *= viewport_flip.xy;
+    }
+    gl_Position = position;
+
+    // TODO(bunnei): This is likely a hack, position.w should be interpolated as 1.0
+    // For now, this is here to bring order in lieu of proper emulation
+    if (config_pack[1] == 1) {
+        position.w = 1.0;
     }
 })";
 
@@ -70,13 +82,18 @@ void main() {
 ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "// Shader Unique Id: GS" + id + "\n\n";
+    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
+    out += "// Shader Unique Id: GS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
+layout (location = 0) in vec4 gs_position[];
+layout (location = 0) out vec4 position;
+
 layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
+    uvec4 alpha_test;
 };
 
 )";
@@ -96,7 +113,8 @@ void main() {
 ProgramResult GenerateFragmentShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "// Shader Unique Id: FS" + id + "\n\n";
+    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
+    out += "// Shader Unique Id: FS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
@@ -109,11 +127,38 @@ layout (location = 5) out vec4 FragColor5;
 layout (location = 6) out vec4 FragColor6;
 layout (location = 7) out vec4 FragColor7;
 
+layout (location = 0) in noperspective vec4 position;
+
 layout (std140, binding = EMULATION_UBO_BINDING) uniform fs_config {
     vec4 viewport_flip;
     uvec4 config_pack; // instance_id, flip_stage, y_direction, padding
+    uvec4 alpha_test;
 };
 
+bool AlphaFunc(in float value) {
+    float ref = uintBitsToFloat(alpha_test[2]);
+    switch (alpha_test[1]) {
+        case 1:
+            return false;
+        case 2:
+            return value < ref;
+        case 3:
+            return value == ref;
+        case 4:
+            return value <= ref;
+        case 5:
+            return value > ref;
+        case 6:
+            return value != ref;
+        case 7:
+            return value >= ref;
+        case 8:
+            return true;
+        default:
+            return false;
+    }
+}
+
 )";
     const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
     ProgramResult program =

src/video_core/renderer_opengl/gl_shader_manager.cpp

@@ -48,6 +48,17 @@ void MaxwellUniformData::SetFromRegs(const Maxwell3D& maxwell, std::size_t shade
     viewport_flip[0] = regs.viewport_transform[0].scale_x < 0.0 ? -1.0f : 1.0f;
     viewport_flip[1] = regs.viewport_transform[0].scale_y < 0.0 ? -1.0f : 1.0f;
 
+    auto func{static_cast<u32>(regs.alpha_test_func)};
+    // Normalize the gl variants of opCompare to be the same as the normal variants
+    const u32 op_gl_variant_base = static_cast<u32>(Maxwell3D::Regs::ComparisonOp::Never);
+    if (func >= op_gl_variant_base) {
+        func = func - op_gl_variant_base + 1U;
+    }
+
+    alpha_test.enabled = regs.alpha_test_enabled;
+    alpha_test.func = func;
+    alpha_test.ref = regs.alpha_test_ref;
+
     instance_id = state.current_instance;
 
     // Assign in which stage the position has to be flipped

src/video_core/renderer_opengl/gl_shader_manager.h

@@ -27,8 +27,14 @@ struct MaxwellUniformData {
         GLuint flip_stage;
         GLfloat y_direction;
     };
+    struct alignas(16) {
+        GLuint enabled;
+        GLuint func;
+        GLfloat ref;
+        GLuint padding;
+    } alpha_test;
 };
-static_assert(sizeof(MaxwellUniformData) == 32, "MaxwellUniformData structure size is incorrect");
+static_assert(sizeof(MaxwellUniformData) == 48, "MaxwellUniformData structure size is incorrect");
 static_assert(sizeof(MaxwellUniformData) < 16384,
               "MaxwellUniformData structure must be less than 16kb as per the OpenGL spec");
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -156,10 +156,6 @@ OpenGLState::OpenGLState() {
     polygon_offset.factor = 0.0f;
     polygon_offset.units = 0.0f;
     polygon_offset.clamp = 0.0f;
-
-    alpha_test.enabled = false;
-    alpha_test.func = GL_ALWAYS;
-    alpha_test.ref = 0.0f;
 }
 
 void OpenGLState::ApplyDefaultState() {
@@ -465,14 +461,6 @@ void OpenGLState::ApplyPolygonOffset() const {
     }
 }
 
-void OpenGLState::ApplyAlphaTest() const {
-    Enable(GL_ALPHA_TEST, cur_state.alpha_test.enabled, alpha_test.enabled);
-    if (UpdateTie(std::tie(cur_state.alpha_test.func, cur_state.alpha_test.ref),
-                  std::tie(alpha_test.func, alpha_test.ref))) {
-        glAlphaFunc(alpha_test.func, alpha_test.ref);
-    }
-}
-
 void OpenGLState::ApplyTextures() const {
     bool has_delta{};
     std::size_t first{};
@@ -545,7 +533,6 @@ void OpenGLState::Apply() const {
     ApplyTextures();
     ApplySamplers();
     ApplyPolygonOffset();
-    ApplyAlphaTest();
 }
 
 void OpenGLState::EmulateViewportWithScissor() {

src/video_core/renderer_opengl/gl_state.h

@@ -172,12 +172,6 @@ public:
         GLfloat clamp;
     } polygon_offset;
 
-    struct {
-        bool enabled; // GL_ALPHA_TEST
-        GLenum func;  // GL_ALPHA_TEST_FUNC
-        GLfloat ref;  // GL_ALPHA_TEST_REF
-    } alpha_test;
-
     std::array<bool, 8> clip_distance; // GL_CLIP_DISTANCE
 
     OpenGLState();
@@ -221,7 +215,6 @@ public:
     void ApplySamplers() const;
     void ApplyDepthClamp() const;
     void ApplyPolygonOffset() const;
-    void ApplyAlphaTest() const;
 
     /// Set the initial OpenGL state
     static void ApplyDefaultState();

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -128,8 +128,6 @@ inline GLenum PrimitiveTopology(Maxwell::PrimitiveTopology topology) {
         return GL_TRIANGLE_STRIP;
     case Maxwell::PrimitiveTopology::TriangleFan:
         return GL_TRIANGLE_FAN;
-    case Maxwell::PrimitiveTopology::Quads:
-        return GL_QUADS;
     default:
         LOG_CRITICAL(Render_OpenGL, "Unimplemented topology={}", static_cast<u32>(topology));
         UNREACHABLE();
@@ -175,8 +173,11 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
         return GL_CLAMP_TO_EDGE;
     case Tegra::Texture::WrapMode::Border:
         return GL_CLAMP_TO_BORDER;
-    case Tegra::Texture::WrapMode::Clamp:
-        return GL_CLAMP;
+    case Tegra::Texture::WrapMode::ClampOGL:
+        // TODO(Subv): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
+        // GL_CLAMP_TO_BORDER to get the border color of the texture, and then sample the edge to
+        // manually mix them. However the shader part of this is not yet implemented.
+        return GL_CLAMP_TO_BORDER;
     case Tegra::Texture::WrapMode::MirrorOnceClampToEdge:
         return GL_MIRROR_CLAMP_TO_EDGE;
     case Tegra::Texture::WrapMode::MirrorOnceBorder:

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -97,8 +97,8 @@ static std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(const float width, cons
     return matrix;
 }
 
-RendererOpenGL::RendererOpenGL(Core::Frontend::EmuWindow& emu_window, Core::System& system)
-    : VideoCore::RendererBase{emu_window}, emu_window{emu_window}, system{system} {}
+RendererOpenGL::RendererOpenGL(Core::Frontend::EmuWindow& window, Core::System& system)
+    : VideoCore::RendererBase{window}, system{system} {}
 
 RendererOpenGL::~RendererOpenGL() = default;
 
@@ -265,7 +265,7 @@ void RendererOpenGL::CreateRasterizer() {
     }
     // Initialize sRGB Usage
     OpenGLState::ClearsRGBUsed();
-    rasterizer = std::make_unique<RasterizerOpenGL>(system, emu_window, screen_info);
+    rasterizer = std::make_unique<RasterizerOpenGL>(system, screen_info);
 }
 
 void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,

src/video_core/renderer_opengl/renderer_opengl.h

@@ -45,7 +45,7 @@ struct ScreenInfo {
 
 class RendererOpenGL : public VideoCore::RendererBase {
 public:
-    explicit RendererOpenGL(Core::Frontend::EmuWindow& emu_window, Core::System& system);
+    explicit RendererOpenGL(Core::Frontend::EmuWindow& window, Core::System& system);
     ~RendererOpenGL() override;
 
     /// Swap buffers (render frame)
@@ -77,7 +77,6 @@ private:
     void LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color_b, u8 color_a,
                                     const TextureInfo& texture);
 
-    Core::Frontend::EmuWindow& emu_window;
     Core::System& system;
 
     OpenGLState state;

src/video_core/renderer_opengl/utils.cpp

@@ -38,27 +38,27 @@ void BindBuffersRangePushBuffer::Bind() const {
                        sizes.data());
 }
 
-void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info) {
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info) {
     if (!GLAD_GL_KHR_debug) {
-        // We don't need to throw an error as this is just for debugging
-        return;
+        return; // We don't need to throw an error as this is just for debugging
     }
-
+    const std::string nice_addr = fmt::format("0x{:016x}", addr);
     std::string object_label;
+
     if (extra_info.empty()) {
         switch (identifier) {
         case GL_TEXTURE:
-            object_label = fmt::format("Texture@0x{:016X}", addr);
+            object_label = "Texture@" + nice_addr;
             break;
         case GL_PROGRAM:
-            object_label = fmt::format("Shader@0x{:016X}", addr);
+            object_label = "Shader@" + nice_addr;
             break;
         default:
-            object_label = fmt::format("Object(0x{:X})@0x{:016X}", identifier, addr);
+            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
             break;
         }
     } else {
-        object_label = fmt::format("{}@0x{:016X}", extra_info, addr);
+        object_label = extra_info + '@' + nice_addr;
     }
     glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
 }

src/video_core/renderer_opengl/utils.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include <string_view>
+#include <string>
 #include <vector>
 #include <glad/glad.h>
 #include "common/common_types.h"
@@ -30,6 +30,6 @@ private:
     std::vector<GLsizeiptr> sizes;
 };
 
-void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info = {});
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string extra_info = "");
 
 } // namespace OpenGL

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -52,7 +52,7 @@ vk::SamplerAddressMode WrapMode(Tegra::Texture::WrapMode wrap_mode) {
         return vk::SamplerAddressMode::eClampToEdge;
     case Tegra::Texture::WrapMode::Border:
         return vk::SamplerAddressMode::eClampToBorder;
-    case Tegra::Texture::WrapMode::Clamp:
+    case Tegra::Texture::WrapMode::ClampOGL:
         // TODO(Rodrigo): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
         // eClampToBorder to get the border color of the texture, and then sample the edge to
         // manually mix them. However the shader part of this is not yet implemented.

src/video_core/renderer_vulkan/vk_device.cpp

@@ -18,7 +18,6 @@ constexpr std::array<vk::Format, 3> Depth24UnormS8Uint = {
     vk::Format::eD32SfloatS8Uint, vk::Format::eD16UnormS8Uint, {}};
 constexpr std::array<vk::Format, 3> Depth16UnormS8Uint = {
     vk::Format::eD24UnormS8Uint, vk::Format::eD32SfloatS8Uint, {}};
-constexpr std::array<vk::Format, 2> Astc = {vk::Format::eA8B8G8R8UnormPack32, {}};
 
 } // namespace Alternatives
 
@@ -52,19 +51,15 @@ VKDevice::VKDevice(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice phy
     : physical{physical}, format_properties{GetFormatProperties(dldi, physical)} {
     SetupFamilies(dldi, surface);
     SetupProperties(dldi);
-    SetupFeatures(dldi);
 }
 
 VKDevice::~VKDevice() = default;
 
 bool VKDevice::Create(const vk::DispatchLoaderDynamic& dldi, vk::Instance instance) {
-    vk::PhysicalDeviceFeatures device_features;
-    device_features.vertexPipelineStoresAndAtomics = true;
-    device_features.independentBlend = true;
-    device_features.textureCompressionASTC_LDR = is_optimal_astc_supported;
-
     const auto queue_cis = GetDeviceQueueCreateInfos();
-    const std::vector<const char*> extensions = LoadExtensions(dldi);
+    vk::PhysicalDeviceFeatures device_features{};
+
+    const std::vector<const char*> extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
     const vk::DeviceCreateInfo device_ci({}, static_cast<u32>(queue_cis.size()), queue_cis.data(),
                                          0, nullptr, static_cast<u32>(extensions.size()),
                                          extensions.data(), &device_features);
@@ -95,7 +90,7 @@ vk::Format VKDevice::GetSupportedFormat(vk::Format wanted_format,
         LOG_CRITICAL(Render_Vulkan,
                      "Format={} with usage={} and type={} has no defined alternatives and host "
                      "hardware does not support it",
-                     vk::to_string(wanted_format), vk::to_string(wanted_usage),
+                     static_cast<u32>(wanted_format), static_cast<u32>(wanted_usage),
                      static_cast<u32>(format_type));
         UNREACHABLE();
         return wanted_format;
@@ -123,30 +118,6 @@ vk::Format VKDevice::GetSupportedFormat(vk::Format wanted_format,
     return wanted_format;
 }
 
-bool VKDevice::IsOptimalAstcSupported(const vk::PhysicalDeviceFeatures& features,
-                                      const vk::DispatchLoaderDynamic& dldi) const {
-    if (!features.textureCompressionASTC_LDR) {
-        return false;
-    }
-    const auto format_feature_usage{
-        vk::FormatFeatureFlagBits::eSampledImage | vk::FormatFeatureFlagBits::eBlitSrc |
-        vk::FormatFeatureFlagBits::eBlitDst | vk::FormatFeatureFlagBits::eTransferSrc |
-        vk::FormatFeatureFlagBits::eTransferDst};
-    constexpr std::array<vk::Format, 9> astc_formats = {
-        vk::Format::eAstc4x4UnormBlock, vk::Format::eAstc4x4SrgbBlock,
-        vk::Format::eAstc8x8SrgbBlock,  vk::Format::eAstc8x6SrgbBlock,
-        vk::Format::eAstc5x4SrgbBlock,  vk::Format::eAstc5x5UnormBlock,
-        vk::Format::eAstc5x5SrgbBlock,  vk::Format::eAstc10x8UnormBlock,
-        vk::Format::eAstc10x8SrgbBlock};
-    for (const auto format : astc_formats) {
-        const auto format_properties{physical.getFormatProperties(format, dldi)};
-        if (!(format_properties.optimalTilingFeatures & format_feature_usage)) {
-            return false;
-        }
-    }
-    return true;
-}
-
 bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlags wanted_usage,
                                  FormatType format_type) const {
     const auto it = format_properties.find(wanted_format);
@@ -161,9 +132,11 @@ bool VKDevice::IsFormatSupported(vk::Format wanted_format, vk::FormatFeatureFlag
 
 bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical,
                           vk::SurfaceKHR surface) {
+    const std::string swapchain_extension = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+
     bool has_swapchain{};
     for (const auto& prop : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
-        has_swapchain |= prop.extensionName == std::string(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+        has_swapchain |= prop.extensionName == swapchain_extension;
     }
     if (!has_swapchain) {
         // The device doesn't support creating swapchains.
@@ -187,14 +160,8 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
     }
 
     // TODO(Rodrigo): Check if the device matches all requeriments.
-    const auto properties{physical.getProperties(dldi)};
-    const auto limits{properties.limits};
-    if (limits.maxUniformBufferRange < 65536) {
-        return false;
-    }
-
-    const vk::PhysicalDeviceFeatures features{physical.getFeatures(dldi)};
-    if (!features.vertexPipelineStoresAndAtomics || !features.independentBlend) {
+    const vk::PhysicalDeviceProperties props = physical.getProperties(dldi);
+    if (props.limits.maxUniformBufferRange < 65536) {
         return false;
     }
 
@@ -202,30 +169,6 @@ bool VKDevice::IsSuitable(const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDev
     return true;
 }
 
-std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynamic& dldi) {
-    std::vector<const char*> extensions;
-    extensions.reserve(2);
-    extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-
-    const auto Test = [&](const vk::ExtensionProperties& extension,
-                          std::optional<std::reference_wrapper<bool>> status, const char* name,
-                          u32 revision) {
-        if (extension.extensionName != std::string(name)) {
-            return;
-        }
-        extensions.push_back(name);
-        if (status) {
-            status->get() = true;
-        }
-    };
-
-    for (const auto& extension : physical.enumerateDeviceExtensionProperties(nullptr, dldi)) {
-        Test(extension, ext_scalar_block_layout, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, 1);
-    }
-
-    return extensions;
-}
-
 void VKDevice::SetupFamilies(const vk::DispatchLoaderDynamic& dldi, vk::SurfaceKHR surface) {
     std::optional<u32> graphics_family_, present_family_;
 
@@ -253,16 +196,10 @@ void VKDevice::SetupProperties(const vk::DispatchLoaderDynamic& dldi) {
     const vk::PhysicalDeviceProperties props = physical.getProperties(dldi);
     device_type = props.deviceType;
     uniform_buffer_alignment = static_cast<u64>(props.limits.minUniformBufferOffsetAlignment);
-    max_storage_buffer_range = static_cast<u64>(props.limits.maxStorageBufferRange);
-}
-
-void VKDevice::SetupFeatures(const vk::DispatchLoaderDynamic& dldi) {
-    const auto supported_features{physical.getFeatures(dldi)};
-    is_optimal_astc_supported = IsOptimalAstcSupported(supported_features, dldi);
 }
 
 std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() const {
-    static const float QUEUE_PRIORITY = 1.0f;
+    static const float QUEUE_PRIORITY = 1.f;
 
     std::set<u32> unique_queue_families = {graphics_family, present_family};
     std::vector<vk::DeviceQueueCreateInfo> queue_cis;
@@ -275,43 +212,26 @@ std::vector<vk::DeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() con
 
 std::map<vk::Format, vk::FormatProperties> VKDevice::GetFormatProperties(
     const vk::DispatchLoaderDynamic& dldi, vk::PhysicalDevice physical) {
-    static constexpr std::array formats{vk::Format::eA8B8G8R8UnormPack32,
-                                        vk::Format::eB5G6R5UnormPack16,
-                                        vk::Format::eA2B10G10R10UnormPack32,
-                                        vk::Format::eR32G32B32A32Sfloat,
-                                        vk::Format::eR16G16Unorm,
-                                        vk::Format::eR16G16Snorm,
-                                        vk::Format::eR8G8B8A8Srgb,
-                                        vk::Format::eR8Unorm,
-                                        vk::Format::eB10G11R11UfloatPack32,
-                                        vk::Format::eR32Sfloat,
-                                        vk::Format::eR16Sfloat,
-                                        vk::Format::eR16G16B16A16Sfloat,
-                                        vk::Format::eD32Sfloat,
-                                        vk::Format::eD16Unorm,
-                                        vk::Format::eD16UnormS8Uint,
-                                        vk::Format::eD24UnormS8Uint,
-                                        vk::Format::eD32SfloatS8Uint,
-                                        vk::Format::eBc1RgbaUnormBlock,
-                                        vk::Format::eBc2UnormBlock,
-                                        vk::Format::eBc3UnormBlock,
-                                        vk::Format::eBc4UnormBlock,
-                                        vk::Format::eBc5UnormBlock,
-                                        vk::Format::eBc5SnormBlock,
-                                        vk::Format::eBc7UnormBlock,
-                                        vk::Format::eAstc4x4UnormBlock,
-                                        vk::Format::eAstc4x4SrgbBlock,
-                                        vk::Format::eAstc8x8SrgbBlock,
-                                        vk::Format::eAstc8x6SrgbBlock,
-                                        vk::Format::eAstc5x4SrgbBlock,
-                                        vk::Format::eAstc5x5UnormBlock,
-                                        vk::Format::eAstc5x5SrgbBlock,
-                                        vk::Format::eAstc10x8UnormBlock,
-                                        vk::Format::eAstc10x8SrgbBlock};
     std::map<vk::Format, vk::FormatProperties> format_properties;
-    for (const auto format : formats) {
+
+    const auto AddFormatQuery = [&format_properties, &dldi, physical](vk::Format format) {
         format_properties.emplace(format, physical.getFormatProperties(format, dldi));
-    }
+    };
+    AddFormatQuery(vk::Format::eA8B8G8R8UnormPack32);
+    AddFormatQuery(vk::Format::eB5G6R5UnormPack16);
+    AddFormatQuery(vk::Format::eA2B10G10R10UnormPack32);
+    AddFormatQuery(vk::Format::eR8G8B8A8Srgb);
+    AddFormatQuery(vk::Format::eR8Unorm);
+    AddFormatQuery(vk::Format::eD32Sfloat);
+    AddFormatQuery(vk::Format::eD16Unorm);
+    AddFormatQuery(vk::Format::eD16UnormS8Uint);
+    AddFormatQuery(vk::Format::eD24UnormS8Uint);
+    AddFormatQuery(vk::Format::eD32SfloatS8Uint);
+    AddFormatQuery(vk::Format::eBc1RgbaUnormBlock);
+    AddFormatQuery(vk::Format::eBc2UnormBlock);
+    AddFormatQuery(vk::Format::eBc3UnormBlock);
+    AddFormatQuery(vk::Format::eBc4UnormBlock);
+
     return format_properties;
 }