shader_bytecode: Mark EXIT as flow instruction

Makes the conversions explicit, as opposed to implicit.

src/common/CMakeLists.txt

@@ -123,6 +123,8 @@ 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,16 +78,17 @@ namespace FileUtil {
 // Remove any ending forward slashes from directory paths
 // Modifies argument.
 static void StripTailDirSlashes(std::string& fname) {
-    if (fname.length() > 1) {
-        std::size_t i = fname.length();
-        while (i > 0 && fname[i - 1] == DIR_SEP_CHR)
-            --i;
-        fname.resize(i);
+    if (fname.length() <= 1) {
+        return;
     }
-    return;
+
+    std::size_t i = fname.length();
+    while (i > 0 && fname[i - 1] == DIR_SEP_CHR) {
+        --i;
+    }
+    fname.resize(i);
 }
 
-// Returns true if file filename exists
 bool Exists(const std::string& filename) {
     struct stat file_info;
 
@@ -107,7 +108,6 @@ 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,8 +132,6 @@ 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);
 
@@ -165,7 +163,6 @@ 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
@@ -194,7 +191,6 @@ 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);
@@ -230,7 +226,6 @@ 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);
 
@@ -252,7 +247,6 @@ 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
@@ -268,7 +262,6 @@ 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
@@ -324,7 +317,6 @@ 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);
@@ -351,7 +343,6 @@ 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) {
@@ -361,7 +352,6 @@ 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);
@@ -377,7 +367,6 @@ 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);
 
@@ -502,7 +491,6 @@ 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)
@@ -539,8 +527,7 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #endif
 }
 
-// Returns the current directory
-std::string GetCurrentDir() {
+std::optional<std::string> GetCurrentDir() {
 // Get the current working directory (getcwd uses malloc)
 #ifdef _WIN32
     wchar_t* dir;
@@ -550,7 +537,7 @@ std::string GetCurrentDir() {
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
         LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
-        return nullptr;
+        return {};
     }
 #ifdef _WIN32
     std::string strDir = Common::UTF16ToUTF8(dir);
@@ -561,7 +548,6 @@ 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;
@@ -673,8 +659,6 @@ 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];
@@ -762,11 +746,11 @@ std::string GetNANDRegistrationDir(bool system) {
     return GetUserPath(UserPath::NANDDir) + "user/Contents/registered/";
 }
 
-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 WriteStringToFile(bool text_file, const std::string& filename, std::string_view str) {
+    return IOFile(filename, text_file ? "w" : "wb").WriteString(str);
 }
 
-std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
+std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
     if (!file.IsOpen())
@@ -776,13 +760,6 @@ std::size_t ReadFileToString(bool text_file, const char* filename, std::string&
     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,6 +9,7 @@
 #include <fstream>
 #include <functional>
 #include <limits>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -118,7 +119,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::string GetCurrentDir();
+std::optional<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);
@@ -146,9 +147,9 @@ const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
-std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename);
+std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
 
-std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
+std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
 
 /**
  * Splits the filename into 8.3 format
@@ -257,8 +258,8 @@ public:
         return WriteArray(&object, 1);
     }
 
-    std::size_t WriteString(const std::string& str) {
-        return WriteArray(str.c_str(), str.length());
+    std::size_t WriteString(std::string_view str) {
+        return WriteArray(str.data(), str.length());
     }
 
     bool IsOpen() const {
@@ -286,8 +287,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).c_str(), openmode);
+    fstream.open(Common::UTF8ToUTF16W(filename), openmode);
 #else
-    fstream.open(filename.c_str(), openmode);
+    fstream.open(filename, openmode);
 #endif
 }

src/common/math_util.h

@@ -41,4 +41,7 @@ struct Rectangle {
     }
 };
 
+template <typename T>
+Rectangle(T, T, T, T)->Rectangle<T>;
+
 } // namespace Common

src/common/uuid.cpp

@@ -0,0 +1,33 @@
+// 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

@@ -0,0 +1,48 @@
+// 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

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

src/core/core_timing_util.cpp

@@ -14,11 +14,11 @@ namespace Core::Timing {
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(us / 1000000) > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(us) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
         return BASE_CLOCK_RATE * (us / 1000000);
     }
@@ -38,11 +38,11 @@ s64 usToCycles(u64 us) {
 }
 
 s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+    if (static_cast<u64>(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) {
+    if (static_cast<u64>(ns) > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
         return BASE_CLOCK_RATE * (ns / 1000000000);
     }

src/core/frontend/applets/profile_select.cpp

@@ -3,6 +3,7 @@
 // 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 {
@@ -10,9 +11,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
+    std::function<void(std::optional<Common::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Common::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 "core/hle/service/acc/profile_manager.h"
+#include "common/uuid.h"
 
 namespace Core::Frontend {
 
@@ -14,14 +14,12 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
+    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -169,8 +169,7 @@ private:
      * For the request to be honored, EmuWindow implementations will usually reimplement this
      * function.
      */
-    virtual void OnMinimalClientAreaChangeRequest(
-        const std::pair<unsigned, unsigned>& minimal_size) {
+    virtual void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned>) {
         // By default, ignore this request and do nothing.
     }
 

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

@@ -34,7 +34,7 @@ constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 }};
 
-static std::string GetImagePath(UUID uuid) {
+static std::string GetImagePath(Common::UUID uuid) {
     return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
            "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
 }
@@ -46,7 +46,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
+    explicit IProfile(Common::UUID user_id, ProfileManager& profile_manager)
         : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
@@ -131,7 +131,7 @@ private:
     }
 
     const ProfileManager& profile_manager;
-    UUID user_id; ///< The user id this profile refers to.
+    Common::UUID user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -179,7 +179,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -205,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<UUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    UUID user_id = rp.PopRaw<UUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -245,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>(INVALID_UUID);
+        rb.PushRaw<u128>(Common::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 == INVALID_UUID; })) {
+                    [](const auto& user) { return user.uuid == Common::INVALID_UUID; })) {
         rb.Push(ResultCode(-1)); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(INVALID_UUID);
+        rb.PushRaw<u128>(Common::INVALID_UUID);
         return;
     }
 

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

@@ -13,6 +13,8 @@
 
 namespace Service::Account {
 
+using Common::UUID;
+
 struct UserRaw {
     UUID uuid;
     UUID uuid2;
@@ -35,26 +37,6 @@ 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();
 
@@ -217,7 +199,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 != INVALID_UUID;
+    return profiles[index].user_uuid.uuid != Common::INVALID_UUID;
 }
 
 /// Opens a specific user
@@ -311,7 +293,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(INVALID_UUID)) {
+    if (!index || profile_new.user_uuid == UUID(Common::INVALID_UUID)) {
         return false;
     }
 
@@ -342,7 +324,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     for (const auto& user : data.users) {
-        if (user.uuid == UUID(INVALID_UUID)) {
+        if (user.uuid == UUID(Common::INVALID_UUID)) {
             continue;
         }
 

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

@@ -9,47 +9,15 @@
 
 #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<UUID, MAX_USERS>;
+using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -66,7 +34,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 {
-    UUID user_uuid;
+    Common::UUID user_uuid;
     ProfileUsername username;
     u64 creation_time;
     ProfileData data; // TODO(ognik): Work out what this is
@@ -74,7 +42,7 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    UUID user_uuid;
+    Common::UUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
@@ -96,33 +64,33 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    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;
+    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;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(Common::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(UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(Common::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(UUID uuid) const;
+    bool UserExists(Common::UUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(UUID uuid);
-    void CloseUser(UUID uuid);
+    void OpenUser(Common::UUID uuid);
+    void CloseUser(Common::UUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    UUID GetLastOpenedUser() const;
+    Common::UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(UUID uuid);
-    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
+    bool RemoveUser(Common::UUID uuid);
+    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
 
 private:
     void ParseUserSaveFile();
@@ -132,7 +100,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count = 0;
-    UUID last_opened_user{INVALID_UUID};
+    Common::UUID last_opened_user{Common::INVALID_UUID};
 };
 
 }; // namespace Service::Account

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

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

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

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

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

@@ -9,7 +9,6 @@
 #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"
@@ -18,7 +17,6 @@
 #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"
 
@@ -75,7 +73,15 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
 AOC_U::~AOC_U() = default;
 
 void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AOC, "called");
+    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);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
@@ -94,23 +100,32 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
 }
 
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        u32 offset;
+        u32 count;
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 16);
 
-    const auto offset = rp.PopRaw<u32>();
-    auto count = rp.PopRaw<u32>();
-    LOG_DEBUG(Service_AOC, "called with offset={}, count={}", offset, count);
+    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 current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
 
     std::vector<u32> out;
-    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 (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));
+        }
+    }
 
     if (out.size() < offset) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -119,22 +134,31 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
+    const auto out_count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
     std::rotate(out.begin(), out.begin() + offset, out.end());
-    out.resize(count);
+    out.resize(out_count);
 
     ctx.WriteBuffer(out);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(count);
+    rb.Push(out_count);
 }
 
 void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AOC, "called");
+    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);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
+
     const auto title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
     FileSys::PatchManager pm{title_id};
 
@@ -148,10 +172,17 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {
 }
 
 void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
+    struct Parameters {
+        s32 addon_index;
+        u64 process_id;
+    };
+    static_assert(sizeof(Parameters) == 16);
 
-    const auto aoc_id = rp.PopRaw<u32>();
-    LOG_WARNING(Service_AOC, "(STUBBED) called with aoc_id={:08X}", aoc_id);
+    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);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);

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

@@ -4,42 +4,50 @@
 
 #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, nullptr, "IsUpdated"},
-            {1, nullptr, "IsFullDatabase"},
-            {2, nullptr, "GetCount"},
-            {3, nullptr, "Get"},
-            {4, nullptr, "Get1"},
+            {0, &IDatabaseService::IsUpdated, "IsUpdated"},
+            {1, &IDatabaseService::IsFullDatabase, "IsFullDatabase"},
+            {2, &IDatabaseService::GetCount, "GetCount"},
+            {3, &IDatabaseService::Get, "Get"},
+            {4, &IDatabaseService::Get1, "Get1"},
             {5, nullptr, "UpdateLatest"},
-            {6, nullptr, "BuildRandom"},
-            {7, nullptr, "BuildDefault"},
-            {8, nullptr, "Get2"},
-            {9, nullptr, "Get3"},
+            {6, &IDatabaseService::BuildRandom, "BuildRandom"},
+            {7, &IDatabaseService::BuildDefault, "BuildDefault"},
+            {8, &IDatabaseService::Get2, "Get2"},
+            {9, &IDatabaseService::Get3, "Get3"},
             {10, nullptr, "UpdateLatest1"},
-            {11, nullptr, "FindIndex"},
-            {12, nullptr, "Move"},
-            {13, nullptr, "AddOrReplace"},
-            {14, nullptr, "Delete"},
-            {15, nullptr, "DestroyFile"},
-            {16, nullptr, "DeleteFile"},
-            {17, nullptr, "Format"},
+            {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"},
             {18, nullptr, "Import"},
             {19, nullptr, "Export"},
             {20, nullptr, "IsBrokenDatabaseWithClearFlag"},
-            {21, nullptr, "GetIndex"},
+            {21, &IDatabaseService::GetIndex, "GetIndex"},
             {22, nullptr, "SetInterfaceVersion"},
             {23, nullptr, "Convert"},
         };
@@ -47,6 +55,305 @@ 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

@@ -0,0 +1,416 @@
+// 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

@@ -0,0 +1,273 @@
+// 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/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() == static_cast<int>(header.size), "{} != {}", header.size,
+    ASSERT_MSG(uncompressed_data.size() == header.size, "{} != {}", header.size,
                uncompressed_data.size());
 
     return uncompressed_data;

src/input_common/sdl/sdl_impl.cpp

@@ -143,9 +143,9 @@ std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& g
     std::lock_guard lock{joystick_map_mutex};
     const auto it = joystick_map.find(guid);
     if (it != joystick_map.end()) {
-        while (it->second.size() <= port) {
-            auto joystick = std::make_shared<SDLJoystick>(guid, it->second.size(), nullptr,
-                                                          [](SDL_Joystick*) {});
+        while (it->second.size() <= static_cast<std::size_t>(port)) {
+            auto joystick = std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()),
+                                                          nullptr, [](SDL_Joystick*) {});
             it->second.emplace_back(std::move(joystick));
         }
         return it->second[port];

src/video_core/engines/shader_bytecode.h

@@ -1663,6 +1663,7 @@ 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"),
@@ -1686,7 +1687,6 @@ 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/renderer_opengl/gl_device.cpp

@@ -35,6 +35,7 @@ Device::Device(std::nullptr_t) {
 
 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() {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -170,7 +170,8 @@ 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";
+    std::string source = "#version 430 core\n"
+                         "#extension GL_ARB_separate_shader_objects : enable\n\n";
     source += fmt::format("#define EMULATION_UBO_BINDING {}\n", base_bindings.cbuf++);
 
     for (const auto& cbuf : entries.const_buffers) {

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -31,6 +31,8 @@ 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;
@@ -93,11 +95,9 @@ private:
 };
 
 /// Generates code to use for a swizzle operation.
-std::string GetSwizzle(u32 elem) {
-    ASSERT(elem <= 3);
-    std::string swizzle = ".";
-    swizzle += "xyzw"[elem];
-    return swizzle;
+constexpr const char* GetSwizzle(u32 element) {
+    constexpr std::array<const char*, 4> swizzle = {".x", ".y", ".z", ".w"};
+    return swizzle.at(element);
 }
 
 /// Translate topology
@@ -636,7 +636,7 @@ private:
             if (stage != ShaderStage::Fragment) {
                 return GeometryPass("position") + GetSwizzle(element);
             } else {
-                return element == 3 ? "1.0f" : "gl_FragCoord" + GetSwizzle(element);
+                return element == 3 ? "1.0f" : ("gl_FragCoord"s + GetSwizzle(element));
             }
         case Attribute::Index::PointCoord:
             switch (element) {
@@ -921,7 +921,7 @@ private:
             target = [&]() -> std::string {
                 switch (const auto attribute = abuf->GetIndex(); abuf->GetIndex()) {
                 case Attribute::Index::Position:
-                    return "position" + GetSwizzle(abuf->GetElement());
+                    return "position"s + GetSwizzle(abuf->GetElement());
                 case Attribute::Index::PointSize:
                     return "gl_PointSize";
                 case Attribute::Index::ClipDistances0123:
@@ -1526,6 +1526,16 @@ 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,
 
@@ -1665,6 +1675,12 @@ 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 {

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -19,8 +19,7 @@ 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 = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: VS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: VS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
@@ -82,8 +81,7 @@ void main() {
 ProgramResult GenerateGeometryShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: GS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: GS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(
@@ -113,8 +111,7 @@ void main() {
 ProgramResult GenerateFragmentShader(const Device& device, const ShaderSetup& setup) {
     const std::string id = fmt::format("{:016x}", setup.program.unique_identifier);
 
-    std::string out = "#extension GL_ARB_separate_shader_objects : enable\n\n";
-    out += "// Shader Unique Id: FS" + id + "\n\n";
+    std::string out = "// Shader Unique Id: FS" + id + "\n\n";
     out += GetCommonDeclarations();
 
     out += R"(

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 extra_info) {
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info) {
     if (!GLAD_GL_KHR_debug) {
-        return; // We don't need to throw an error as this is just for debugging
+        // We don't need to throw an error as this is just for debugging
+        return;
     }
-    const std::string nice_addr = fmt::format("0x{:016x}", addr);
-    std::string object_label;
 
+    std::string object_label;
     if (extra_info.empty()) {
         switch (identifier) {
         case GL_TEXTURE:
-            object_label = "Texture@" + nice_addr;
+            object_label = fmt::format("Texture@0x{:016X}", addr);
             break;
         case GL_PROGRAM:
-            object_label = "Shader@" + nice_addr;
+            object_label = fmt::format("Shader@0x{:016X}", addr);
             break;
         default:
-            object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
+            object_label = fmt::format("Object(0x{:X})@0x{:016X}", identifier, addr);
             break;
         }
     } else {
-        object_label = extra_info + '@' + nice_addr;
+        object_label = fmt::format("{}@0x{:016X}", extra_info, 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>
+#include <string_view>
 #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 extra_info = "");
+void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info = {});
 
 } // namespace OpenGL

src/video_core/renderer_vulkan/vk_shader_decompiler.cpp

@@ -1035,6 +1035,18 @@ private:
         return {};
     }
 
+    template <u32 element>
+    Id LocalInvocationId(Operation) {
+        UNIMPLEMENTED();
+        return {};
+    }
+
+    template <u32 element>
+    Id WorkGroupId(Operation) {
+        UNIMPLEMENTED();
+        return {};
+    }
+
     Id DeclareBuiltIn(spv::BuiltIn builtin, spv::StorageClass storage, Id type,
                       const std::string& name) {
         const Id id = OpVariable(type, storage);
@@ -1291,6 +1303,12 @@ private:
         &SPIRVDecompiler::EndPrimitive,
 
         &SPIRVDecompiler::YNegate,
+        &SPIRVDecompiler::LocalInvocationId<0>,
+        &SPIRVDecompiler::LocalInvocationId<1>,
+        &SPIRVDecompiler::LocalInvocationId<2>,
+        &SPIRVDecompiler::WorkGroupId<0>,
+        &SPIRVDecompiler::WorkGroupId<1>,
+        &SPIRVDecompiler::WorkGroupId<2>,
     };
 
     const ShaderIR& ir;

src/video_core/shader/decode/other.cpp

@@ -14,6 +14,7 @@ using Tegra::Shader::ConditionCode;
 using Tegra::Shader::Instruction;
 using Tegra::Shader::OpCode;
 using Tegra::Shader::Register;
+using Tegra::Shader::SystemVariable;
 
 u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
     const Instruction instr = {program_code[pc]};
@@ -59,20 +60,33 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         break;
     }
     case OpCode::Id::MOV_SYS: {
-        switch (instr.sys20) {
-        case Tegra::Shader::SystemVariable::InvocationInfo: {
-            LOG_WARNING(HW_GPU, "MOV_SYS instruction with InvocationInfo is incomplete");
-            SetRegister(bb, instr.gpr0, Immediate(0u));
-            break;
-        }
-        case Tegra::Shader::SystemVariable::Ydirection: {
-            // Config pack's third value is Y_NEGATE's state.
-            SetRegister(bb, instr.gpr0, Operation(OperationCode::YNegate));
-            break;
-        }
-        default:
-            UNIMPLEMENTED_MSG("Unhandled system move: {}", static_cast<u32>(instr.sys20.Value()));
-        }
+        const Node value = [&]() {
+            switch (instr.sys20) {
+            case SystemVariable::Ydirection:
+                return Operation(OperationCode::YNegate);
+            case SystemVariable::InvocationInfo:
+                LOG_WARNING(HW_GPU, "MOV_SYS instruction with InvocationInfo is incomplete");
+                return Immediate(0u);
+            case SystemVariable::TidX:
+                return Operation(OperationCode::LocalInvocationIdX);
+            case SystemVariable::TidY:
+                return Operation(OperationCode::LocalInvocationIdY);
+            case SystemVariable::TidZ:
+                return Operation(OperationCode::LocalInvocationIdZ);
+            case SystemVariable::CtaIdX:
+                return Operation(OperationCode::WorkGroupIdX);
+            case SystemVariable::CtaIdY:
+                return Operation(OperationCode::WorkGroupIdY);
+            case SystemVariable::CtaIdZ:
+                return Operation(OperationCode::WorkGroupIdZ);
+            default:
+                UNIMPLEMENTED_MSG("Unhandled system move: {}",
+                                  static_cast<u32>(instr.sys20.Value()));
+                return Immediate(0u);
+            }
+        }();
+        SetRegister(bb, instr.gpr0, value);
+
         break;
     }
     case OpCode::Id::BRA: {

src/video_core/shader/shader_ir.h

@@ -181,7 +181,13 @@ enum class OperationCode {
     EmitVertex,   /// () -> void
     EndPrimitive, /// () -> void
 
-    YNegate, /// () -> float
+    YNegate,            /// () -> float
+    LocalInvocationIdX, /// () -> uint
+    LocalInvocationIdY, /// () -> uint
+    LocalInvocationIdZ, /// () -> uint
+    WorkGroupIdX,       /// () -> uint
+    WorkGroupIdY,       /// () -> uint
+    WorkGroupIdZ,       /// () -> uint
 
     Amount,
 };

src/yuzu/applets/profile_select.cpp

@@ -27,20 +27,20 @@ constexpr std::array<u8, 107> backup_jpeg{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 };
 
-QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
     return QtProfileSelectionDialog::tr(
                "%1\n%2", "%1 is the profile username, %2 is the formatted UUID (e.g. "
                          "00112233-4455-6677-8899-AABBCCDDEEFF))")
         .arg(username, QString::fromStdString(uuid.FormatSwitch()));
 }
 
-QString GetImagePath(Service::Account::UUID uuid) {
+QString GetImagePath(Common::UUID uuid) {
     const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                       "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
     return QString::fromStdString(path);
 }
 
-QPixmap GetIcon(Service::Account::UUID uuid) {
+QPixmap GetIcon(Common::UUID uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -154,12 +154,12 @@ QtProfileSelector::QtProfileSelector(GMainWindow& parent) {
 QtProfileSelector::~QtProfileSelector() = default;
 
 void QtProfileSelector::SelectProfile(
-    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
+    std::function<void(std::optional<Common::UUID>)> callback) const {
     this->callback = std::move(callback);
     emit MainWindowSelectProfile();
 }
 
-void QtProfileSelector::MainWindowFinishedSelection(std::optional<Service::Account::UUID> uuid) {
+void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::UUID> uuid) {
     // Acquire the HLE mutex
     std::lock_guard lock{HLE::g_hle_lock};
     callback(uuid);

src/yuzu/applets/profile_select.h

@@ -9,6 +9,7 @@
 #include <QList>
 #include <QTreeView>
 #include "core/frontend/applets/profile_select.h"
+#include "core/hle/service/acc/profile_manager.h"
 
 class GMainWindow;
 class QDialogButtonBox;
@@ -60,14 +61,13 @@ public:
     explicit QtProfileSelector(GMainWindow& parent);
     ~QtProfileSelector() override;
 
-    void SelectProfile(
-        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
 
 signals:
     void MainWindowSelectProfile() const;
 
 private:
-    void MainWindowFinishedSelection(std::optional<Service::Account::UUID> uuid);
+    void MainWindowFinishedSelection(std::optional<Common::UUID> uuid);
 
-    mutable std::function<void(std::optional<Service::Account::UUID>)> callback;
+    mutable std::function<void(std::optional<Common::UUID>)> callback;
 };

src/yuzu/bootmanager.cpp

@@ -440,8 +440,7 @@ void GRenderWindow::CaptureScreenshot(u16 res_scale, const QString& screenshot_p
                                layout);
 }
 
-void GRenderWindow::OnMinimalClientAreaChangeRequest(
-    const std::pair<unsigned, unsigned>& minimal_size) {
+void GRenderWindow::OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) {
     setMinimumSize(minimal_size.first, minimal_size.second);
 }
 

src/yuzu/bootmanager.h

@@ -162,8 +162,7 @@ private:
     void TouchUpdateEvent(const QTouchEvent* event);
     void TouchEndEvent();
 
-    void OnMinimalClientAreaChangeRequest(
-        const std::pair<unsigned, unsigned>& minimal_size) override;
+    void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) override;
 
     QWidget* container = nullptr;
     GGLWidgetInternal* child = nullptr;

src/yuzu/configuration/config.cpp

@@ -645,6 +645,8 @@ void Config::ReadUIGamelistValues() {
     UISettings::values.icon_size = ReadSetting(QStringLiteral("icon_size"), 64).toUInt();
     UISettings::values.row_1_text_id = ReadSetting(QStringLiteral("row_1_text_id"), 3).toUInt();
     UISettings::values.row_2_text_id = ReadSetting(QStringLiteral("row_2_text_id"), 2).toUInt();
+    UISettings::values.cache_game_list =
+        ReadSetting(QStringLiteral("cache_game_list"), true).toBool();
 
     qt_config->endGroup();
 }
@@ -1009,6 +1011,7 @@ void Config::SaveUIGamelistValues() {
     WriteSetting(QStringLiteral("icon_size"), UISettings::values.icon_size, 64);
     WriteSetting(QStringLiteral("row_1_text_id"), UISettings::values.row_1_text_id, 3);
     WriteSetting(QStringLiteral("row_2_text_id"), UISettings::values.row_2_text_id, 2);
+    WriteSetting(QStringLiteral("cache_game_list"), UISettings::values.cache_game_list, true);
 
     qt_config->endGroup();
 }

src/yuzu/configuration/configure_per_general.cpp

@@ -13,6 +13,8 @@
 #include <QTimer>
 #include <QTreeView>
 
+#include "common/common_paths.h"
+#include "common/file_util.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/xts_archive.h"
@@ -79,6 +81,14 @@ void ConfigurePerGameGeneral::applyConfiguration() {
             disabled_addons.push_back(item.front()->text().toStdString());
     }
 
+    auto current = Settings::values.disabled_addons[title_id];
+    std::sort(disabled_addons.begin(), disabled_addons.end());
+    std::sort(current.begin(), current.end());
+    if (disabled_addons != current) {
+        FileUtil::Delete(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP +
+                         "game_list" + DIR_SEP + fmt::format("{:016X}.pv.txt", title_id));
+    }
+
     Settings::values.disabled_addons[title_id] = disabled_addons;
 }
 

src/yuzu/configuration/configure_profile_manager.cpp

@@ -33,14 +33,13 @@ constexpr std::array<u8, 107> backup_jpeg{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 };
 
-QString GetImagePath(Service::Account::UUID uuid) {
+QString GetImagePath(Common::UUID uuid) {
     const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                       "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
     return QString::fromStdString(path);
 }
 
-QString GetAccountUsername(const Service::Account::ProfileManager& manager,
-                           Service::Account::UUID uuid) {
+QString GetAccountUsername(const Service::Account::ProfileManager& manager, Common::UUID uuid) {
     Service::Account::ProfileBase profile;
     if (!manager.GetProfileBase(uuid, profile)) {
         return {};
@@ -51,14 +50,14 @@ QString GetAccountUsername(const Service::Account::ProfileManager& manager,
     return QString::fromStdString(text);
 }
 
-QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
     return ConfigureProfileManager::tr("%1\n%2",
                                        "%1 is the profile username, %2 is the formatted UUID (e.g. "
                                        "00112233-4455-6677-8899-AABBCCDDEEFF))")
         .arg(username, QString::fromStdString(uuid.FormatSwitch()));
 }
 
-QPixmap GetIcon(Service::Account::UUID uuid) {
+QPixmap GetIcon(Common::UUID uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -190,7 +189,7 @@ void ConfigureProfileManager::AddUser() {
         return;
     }
 
-    const auto uuid = Service::Account::UUID::Generate();
+    const auto uuid = Common::UUID::Generate();
     profile_manager->CreateNewUser(uuid, username.toStdString());
 
     item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});

src/yuzu/game_list_worker.cpp

@@ -9,6 +9,7 @@
 
 #include <QDir>
 #include <QFileInfo>
+#include <QSettings>
 
 #include "common/common_paths.h"
 #include "common/file_util.h"
@@ -30,13 +31,119 @@
 #include "yuzu/ui_settings.h"
 
 namespace {
+
+template <typename T>
+T GetGameListCachedObject(const std::string& filename, const std::string& ext,
+                          const std::function<T()>& generator);
+
+template <>
+QString GetGameListCachedObject(const std::string& filename, const std::string& ext,
+                                const std::function<QString()>& generator) {
+    if (!UISettings::values.cache_game_list || filename == "0000000000000000") {
+        return generator();
+    }
+
+    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP + "game_list" +
+                      DIR_SEP + filename + '.' + ext;
+
+    FileUtil::CreateFullPath(path);
+
+    if (!FileUtil::Exists(path)) {
+        const auto str = generator();
+
+        std::ofstream stream(path);
+        if (stream) {
+            stream << str.toStdString();
+        }
+
+        return str;
+    }
+
+    std::ifstream stream(path);
+
+    if (stream) {
+        const std::string out(std::istreambuf_iterator<char>{stream},
+                              std::istreambuf_iterator<char>{});
+        return QString::fromStdString(out);
+    }
+
+    return generator();
+}
+
+template <>
+std::pair<std::vector<u8>, std::string> GetGameListCachedObject(
+    const std::string& filename, const std::string& ext,
+    const std::function<std::pair<std::vector<u8>, std::string>()>& generator) {
+    if (!UISettings::values.cache_game_list || filename == "0000000000000000") {
+        return generator();
+    }
+
+    const auto path1 = FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP + "game_list" +
+                       DIR_SEP + filename + ".jpeg";
+    const auto path2 = FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) + DIR_SEP + "game_list" +
+                       DIR_SEP + filename + ".appname.txt";
+
+    FileUtil::CreateFullPath(path1);
+
+    if (!FileUtil::Exists(path1) || !FileUtil::Exists(path2)) {
+        const auto [icon, nacp] = generator();
+
+        FileUtil::IOFile file1(path1, "wb");
+        if (!file1.IsOpen()) {
+            LOG_ERROR(Frontend, "Failed to open cache file.");
+            return generator();
+        }
+
+        if (!file1.Resize(icon.size())) {
+            LOG_ERROR(Frontend, "Failed to resize cache file to necessary size.");
+            return generator();
+        }
+
+        if (file1.WriteBytes(icon.data(), icon.size()) != icon.size()) {
+            LOG_ERROR(Frontend, "Failed to write data to cache file.");
+            return generator();
+        }
+
+        std::ofstream stream2(path2, std::ios::out);
+        if (stream2) {
+            stream2 << nacp;
+        }
+
+        return std::make_pair(icon, nacp);
+    }
+
+    FileUtil::IOFile file1(path1, "rb");
+    std::ifstream stream2(path2);
+
+    if (!file1.IsOpen()) {
+        LOG_ERROR(Frontend, "Failed to open cache file for reading.");
+        return generator();
+    }
+
+    if (!stream2) {
+        LOG_ERROR(Frontend, "Failed to open cache file for reading.");
+        return generator();
+    }
+
+    std::vector<u8> vec(file1.GetSize());
+    file1.ReadBytes(vec.data(), vec.size());
+
+    if (stream2 && !vec.empty()) {
+        const std::string out(std::istreambuf_iterator<char>{stream2},
+                              std::istreambuf_iterator<char>{});
+        return std::make_pair(vec, out);
+    }
+
+    return generator();
+}
+
 void GetMetadataFromControlNCA(const FileSys::PatchManager& patch_manager, const FileSys::NCA& nca,
                                std::vector<u8>& icon, std::string& name) {
-    auto [nacp, icon_file] = patch_manager.ParseControlNCA(nca);
-    if (icon_file != nullptr)
-        icon = icon_file->ReadAllBytes();
-    if (nacp != nullptr)
-        name = nacp->GetApplicationName();
+    std::tie(icon, name) = GetGameListCachedObject<std::pair<std::vector<u8>, std::string>>(
+        fmt::format("{:016X}", patch_manager.GetTitleID()), {}, [&patch_manager, &nca] {
+            const auto [nacp, icon_f] = patch_manager.ParseControlNCA(nca);
+            return std::make_pair(icon_f->ReadAllBytes(), nacp->GetApplicationName());
+        });
 }
 
 bool HasSupportedFileExtension(const std::string& file_name) {
@@ -114,8 +221,11 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
     };
 
     if (UISettings::values.show_add_ons) {
-        list.insert(
-            2, new GameListItem(FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable())));
+        const auto patch_versions = GetGameListCachedObject<QString>(
+            fmt::format("{:016X}", patch.GetTitleID()), "pv.txt", [&patch, &loader] {
+                return FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable());
+            });
+        list.insert(2, new GameListItem(patch_versions));
     }
 
     return list;

src/yuzu/main.cpp

@@ -1396,6 +1396,8 @@ void GMainWindow::OnMenuInstallToNAND() {
                                  tr("The file was successfully installed."));
         game_list->PopulateAsync(UISettings::values.game_directory_path,
                                  UISettings::values.game_directory_deepscan);
+        FileUtil::DeleteDirRecursively(FileUtil::GetUserPath(FileUtil::UserPath::CacheDir) +
+                                       DIR_SEP + "game_list");
     };
 
     const auto failed = [this]() {

src/yuzu/main.h

@@ -104,7 +104,7 @@ signals:
 
     void ErrorDisplayFinished();
 
-    void ProfileSelectorFinishedSelection(std::optional<Service::Account::UUID> uuid);
+    void ProfileSelectorFinishedSelection(std::optional<Common::UUID> uuid);
     void SoftwareKeyboardFinishedText(std::optional<std::u16string> text);
     void SoftwareKeyboardFinishedCheckDialog();
 

src/yuzu/ui_settings.h

@@ -79,6 +79,7 @@ struct Values {
     uint8_t row_1_text_id;
     uint8_t row_2_text_id;
     std::atomic_bool is_game_list_reload_pending{false};
+    bool cache_game_list;
 };
 
 extern Values values;

src/yuzu_cmd/CMakeLists.txt

@@ -4,6 +4,8 @@ add_executable(yuzu-cmd
     config.cpp
     config.h
     default_ini.h
+    emu_window/emu_window_sdl2_gl.cpp
+    emu_window/emu_window_sdl2_gl.h
     emu_window/emu_window_sdl2.cpp
     emu_window/emu_window_sdl2.h
     resource.h

src/yuzu_cmd/config.cpp

@@ -26,12 +26,12 @@ Config::Config() {
 Config::~Config() = default;
 
 bool Config::LoadINI(const std::string& default_contents, bool retry) {
-    const char* location = this->sdl2_config_loc.c_str();
+    const std::string& location = this->sdl2_config_loc;
     if (sdl2_config->ParseError() < 0) {
         if (retry) {
             LOG_WARNING(Config, "Failed to load {}. Creating file from defaults...", location);
             FileUtil::CreateFullPath(location);
-            FileUtil::WriteStringToFile(true, default_contents, location);
+            FileUtil::WriteStringToFile(true, location, default_contents);
             sdl2_config = std::make_unique<INIReader>(location); // Reopen file
 
             return LoadINI(default_contents, false);

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -2,53 +2,27 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <cstdlib>
-#include <string>
-#define SDL_MAIN_HANDLED
 #include <SDL.h>
-#include <fmt/format.h>
-#include <glad/glad.h>
 #include "common/logging/log.h"
-#include "common/scm_rev.h"
-#include "common/string_util.h"
-#include "core/settings.h"
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
 #include "input_common/motion_emu.h"
 #include "input_common/sdl/sdl.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"
 
-class SDLGLContext : public Core::Frontend::GraphicsContext {
-public:
-    explicit SDLGLContext() {
-        // create a hidden window to make the shared context against
-        window = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, // x position
-                                  SDL_WINDOWPOS_UNDEFINED,     // y position
-                                  Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
-                                  SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN);
-        context = SDL_GL_CreateContext(window);
+EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
+        LOG_CRITICAL(Frontend, "Failed to initialize SDL2! Exiting...");
+        exit(1);
     }
+    InputCommon::Init();
+    SDL_SetMainReady();
+}
 
-    ~SDLGLContext() {
-        SDL_GL_DeleteContext(context);
-        SDL_DestroyWindow(window);
-    }
-
-    void MakeCurrent() override {
-        SDL_GL_MakeCurrent(window, context);
-    }
-
-    void DoneCurrent() override {
-        SDL_GL_MakeCurrent(window, nullptr);
-    }
-
-    void SwapBuffers() override {}
-
-private:
-    SDL_Window* window;
-    SDL_GLContext context;
-};
+EmuWindow_SDL2::~EmuWindow_SDL2() {
+    InputCommon::Shutdown();
+    SDL_Quit();
+}
 
 void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
     TouchMoved((unsigned)std::max(x, 0), (unsigned)std::max(y, 0));
@@ -139,112 +113,6 @@ void EmuWindow_SDL2::Fullscreen() {
     SDL_MaximizeWindow(render_window);
 }
 
-bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
-    std::vector<std::string> unsupported_ext;
-
-    if (!GLAD_GL_ARB_direct_state_access)
-        unsupported_ext.push_back("ARB_direct_state_access");
-    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
-        unsupported_ext.push_back("ARB_vertex_type_10f_11f_11f_rev");
-    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
-        unsupported_ext.push_back("ARB_texture_mirror_clamp_to_edge");
-    if (!GLAD_GL_ARB_multi_bind)
-        unsupported_ext.push_back("ARB_multi_bind");
-
-    // Extensions required to support some texture formats.
-    if (!GLAD_GL_EXT_texture_compression_s3tc)
-        unsupported_ext.push_back("EXT_texture_compression_s3tc");
-    if (!GLAD_GL_ARB_texture_compression_rgtc)
-        unsupported_ext.push_back("ARB_texture_compression_rgtc");
-    if (!GLAD_GL_ARB_depth_buffer_float)
-        unsupported_ext.push_back("ARB_depth_buffer_float");
-
-    for (const std::string& ext : unsupported_ext)
-        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);
-
-    return unsupported_ext.empty();
-}
-
-EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
-    // Initialize the window
-    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
-        LOG_CRITICAL(Frontend, "Failed to initialize SDL2! Exiting...");
-        exit(1);
-    }
-
-    InputCommon::Init();
-
-    SDL_SetMainReady();
-
-    const SDL_GLprofile profile = Settings::values.use_compatibility_profile
-                                      ? SDL_GL_CONTEXT_PROFILE_COMPATIBILITY
-                                      : SDL_GL_CONTEXT_PROFILE_CORE;
-
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
-    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
-    SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
-
-    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_fullname,
-                                           Common::g_scm_branch, Common::g_scm_desc);
-    render_window =
-        SDL_CreateWindow(window_title.c_str(),
-                         SDL_WINDOWPOS_UNDEFINED, // x position
-                         SDL_WINDOWPOS_UNDEFINED, // y position
-                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
-                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
-
-    if (render_window == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! {}", SDL_GetError());
-        exit(1);
-    }
-
-    if (fullscreen) {
-        Fullscreen();
-    }
-    gl_context = SDL_GL_CreateContext(render_window);
-
-    if (gl_context == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! {}", SDL_GetError());
-        exit(1);
-    }
-
-    if (!gladLoadGLLoader(static_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
-        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! {}", SDL_GetError());
-        exit(1);
-    }
-
-    if (!SupportsRequiredGLExtensions()) {
-        LOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
-        exit(1);
-    }
-
-    OnResize();
-    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
-    SDL_PumpEvents();
-    SDL_GL_SetSwapInterval(false);
-    LOG_INFO(Frontend, "yuzu Version: {} | {}-{}", Common::g_build_fullname, Common::g_scm_branch,
-             Common::g_scm_desc);
-    Settings::LogSettings();
-
-    DoneCurrent();
-}
-
-EmuWindow_SDL2::~EmuWindow_SDL2() {
-    InputCommon::Shutdown();
-    SDL_GL_DeleteContext(gl_context);
-    SDL_Quit();
-}
-
-void EmuWindow_SDL2::SwapBuffers() {
-    SDL_GL_SwapWindow(render_window);
-}
-
 void EmuWindow_SDL2::PollEvents() {
     SDL_Event event;
 
@@ -257,7 +125,11 @@ void EmuWindow_SDL2::PollEvents() {
             case SDL_WINDOWEVENT_RESIZED:
             case SDL_WINDOWEVENT_MAXIMIZED:
             case SDL_WINDOWEVENT_RESTORED:
+                OnResize();
+                break;
             case SDL_WINDOWEVENT_MINIMIZED:
+            case SDL_WINDOWEVENT_EXPOSED:
+                is_shown = event.window.event == SDL_WINDOWEVENT_EXPOSED;
                 OnResize();
                 break;
             case SDL_WINDOWEVENT_CLOSE:
@@ -300,20 +172,6 @@ void EmuWindow_SDL2::PollEvents() {
     }
 }
 
-void EmuWindow_SDL2::MakeCurrent() {
-    SDL_GL_MakeCurrent(render_window, gl_context);
-}
-
-void EmuWindow_SDL2::DoneCurrent() {
-    SDL_GL_MakeCurrent(render_window, nullptr);
-}
-
-void EmuWindow_SDL2::OnMinimalClientAreaChangeRequest(
-    const std::pair<unsigned, unsigned>& minimal_size) {
-
+void EmuWindow_SDL2::OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) {
     SDL_SetWindowMinimumSize(render_window, minimal_size.first, minimal_size.second);
 }
-
-std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2::CreateSharedContext() const {
-    return std::make_unique<SDLGLContext>();
-}

src/yuzu_cmd/emu_window/emu_window_sdl2.h

@@ -15,24 +15,13 @@ public:
     explicit EmuWindow_SDL2(bool fullscreen);
     ~EmuWindow_SDL2();
 
-    /// Swap buffers to display the next frame
-    void SwapBuffers() override;
-
     /// Polls window events
     void PollEvents() override;
 
-    /// Makes the graphics context current for the caller thread
-    void MakeCurrent() override;
-
-    /// Releases the GL context from the caller thread
-    void DoneCurrent() override;
-
-    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
-
     /// Whether the window is still open, and a close request hasn't yet been sent
     bool IsOpen() const;
 
-private:
+protected:
     /// Called by PollEvents when a key is pressed or released.
     void OnKeyEvent(int key, u8 state);
 
@@ -60,20 +49,15 @@ private:
     /// Called when user passes the fullscreen parameter flag
     void Fullscreen();
 
-    /// Whether the GPU and driver supports the OpenGL extension required
-    bool SupportsRequiredGLExtensions();
-
     /// Called when a configuration change affects the minimal size of the window
-    void OnMinimalClientAreaChangeRequest(
-        const std::pair<unsigned, unsigned>& minimal_size) override;
+    void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned> minimal_size) override;
 
     /// Is the window still open?
     bool is_open = true;
 
+    /// Is the window being shown?
+    bool is_shown = true;
+
     /// Internal SDL2 render window
     SDL_Window* render_window;
-
-    using SDL_GLContext = void*;
-    /// The OpenGL context associated with the window
-    SDL_GLContext gl_context;
 };

src/yuzu_cmd/emu_window/emu_window_sdl2_gl.cpp

@@ -0,0 +1,154 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstdlib>
+#include <string>
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+#include <fmt/format.h>
+#include <glad/glad.h>
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "common/string_util.h"
+#include "core/settings.h"
+#include "input_common/keyboard.h"
+#include "input_common/main.h"
+#include "input_common/motion_emu.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h"
+
+class SDLGLContext : public Core::Frontend::GraphicsContext {
+public:
+    explicit SDLGLContext() {
+        // create a hidden window to make the shared context against
+        window = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED, // x position
+                                  SDL_WINDOWPOS_UNDEFINED,     // y position
+                                  Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
+                                  SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN);
+        context = SDL_GL_CreateContext(window);
+    }
+
+    ~SDLGLContext() {
+        SDL_GL_DeleteContext(context);
+        SDL_DestroyWindow(window);
+    }
+
+    void MakeCurrent() override {
+        SDL_GL_MakeCurrent(window, context);
+    }
+
+    void DoneCurrent() override {
+        SDL_GL_MakeCurrent(window, nullptr);
+    }
+
+    void SwapBuffers() override {}
+
+private:
+    SDL_Window* window;
+    SDL_GLContext context;
+};
+
+bool EmuWindow_SDL2_GL::SupportsRequiredGLExtensions() {
+    std::vector<std::string> unsupported_ext;
+
+    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
+        unsupported_ext.push_back("ARB_vertex_type_10f_11f_11f_rev");
+    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
+        unsupported_ext.push_back("ARB_texture_mirror_clamp_to_edge");
+    if (!GLAD_GL_ARB_multi_bind)
+        unsupported_ext.push_back("ARB_multi_bind");
+
+    // Extensions required to support some texture formats.
+    if (!GLAD_GL_EXT_texture_compression_s3tc)
+        unsupported_ext.push_back("EXT_texture_compression_s3tc");
+    if (!GLAD_GL_ARB_texture_compression_rgtc)
+        unsupported_ext.push_back("ARB_texture_compression_rgtc");
+    if (!GLAD_GL_ARB_depth_buffer_float)
+        unsupported_ext.push_back("ARB_depth_buffer_float");
+
+    for (const std::string& ext : unsupported_ext)
+        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);
+
+    return unsupported_ext.empty();
+}
+
+EmuWindow_SDL2_GL::EmuWindow_SDL2_GL(bool fullscreen) : EmuWindow_SDL2(fullscreen) {
+    const SDL_GLprofile profile = Settings::values.use_compatibility_profile
+                                      ? SDL_GL_CONTEXT_PROFILE_COMPATIBILITY
+                                      : SDL_GL_CONTEXT_PROFILE_CORE;
+
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
+    SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
+
+    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_fullname,
+                                           Common::g_scm_branch, Common::g_scm_desc);
+    render_window =
+        SDL_CreateWindow(window_title.c_str(),
+                         SDL_WINDOWPOS_UNDEFINED, // x position
+                         SDL_WINDOWPOS_UNDEFINED, // y position
+                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
+                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+
+    if (render_window == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! {}", SDL_GetError());
+        exit(1);
+    }
+
+    if (fullscreen) {
+        Fullscreen();
+    }
+    gl_context = SDL_GL_CreateContext(render_window);
+
+    if (gl_context == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! {}", SDL_GetError());
+        exit(1);
+    }
+
+    if (!gladLoadGLLoader(static_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
+        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! {}", SDL_GetError());
+        exit(1);
+    }
+
+    if (!SupportsRequiredGLExtensions()) {
+        LOG_CRITICAL(Frontend, "GPU does not support all required OpenGL extensions! Exiting...");
+        exit(1);
+    }
+
+    OnResize();
+    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
+    SDL_PumpEvents();
+    SDL_GL_SetSwapInterval(false);
+    LOG_INFO(Frontend, "yuzu Version: {} | {}-{}", Common::g_build_fullname, Common::g_scm_branch,
+             Common::g_scm_desc);
+    Settings::LogSettings();
+
+    DoneCurrent();
+}
+
+EmuWindow_SDL2_GL::~EmuWindow_SDL2_GL() {
+    SDL_GL_DeleteContext(gl_context);
+}
+
+void EmuWindow_SDL2_GL::SwapBuffers() {
+    SDL_GL_SwapWindow(render_window);
+}
+
+void EmuWindow_SDL2_GL::MakeCurrent() {
+    SDL_GL_MakeCurrent(render_window, gl_context);
+}
+
+void EmuWindow_SDL2_GL::DoneCurrent() {
+    SDL_GL_MakeCurrent(render_window, nullptr);
+}
+
+std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_GL::CreateSharedContext() const {
+    return std::make_unique<SDLGLContext>();
+}

src/yuzu_cmd/emu_window/emu_window_sdl2_gl.h

@@ -0,0 +1,34 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "core/frontend/emu_window.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+
+class EmuWindow_SDL2_GL final : public EmuWindow_SDL2 {
+public:
+    explicit EmuWindow_SDL2_GL(bool fullscreen);
+    ~EmuWindow_SDL2_GL();
+
+    /// Swap buffers to display the next frame
+    void SwapBuffers() override;
+
+    /// Makes the graphics context current for the caller thread
+    void MakeCurrent() override;
+
+    /// Releases the GL context from the caller thread
+    void DoneCurrent() override;
+
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
+
+private:
+    /// Whether the GPU and driver supports the OpenGL extension required
+    bool SupportsRequiredGLExtensions();
+
+    using SDL_GLContext = void*;
+    /// The OpenGL context associated with the window
+    SDL_GLContext gl_context;
+};

src/yuzu_cmd/yuzu.cpp

@@ -31,6 +31,7 @@
 #include "video_core/renderer_base.h"
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h"
 
 #include "core/file_sys/registered_cache.h"
 
@@ -173,7 +174,7 @@ int main(int argc, char** argv) {
     Settings::values.use_gdbstub = use_gdbstub;
     Settings::Apply();
 
-    std::unique_ptr<EmuWindow_SDL2> emu_window{std::make_unique<EmuWindow_SDL2>(fullscreen)};
+    std::unique_ptr<EmuWindow_SDL2> emu_window{std::make_unique<EmuWindow_SDL2_GL>(fullscreen)};
 
     if (!Settings::values.use_multi_core) {
         // Single core mode must acquire OpenGL context for entire emulation session