svc: Improve SleepThread for yield types.

- Fixes Super Mario Party.

CONTRIBUTING.md

@@ -1 +1,136 @@
-**The Contributor's Guide has moved to [the Citra wiki](https://github.com/citra-emu/citra/wiki/Contributing).**
+# Reporting Issues
+
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+
+If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
+
+# Contributing
+yuzu is a brand new project, so we have a great opportunity to keep things clean and well organized early on. As such, coding style is very important when making commits. We run clang-format on our CI to check the code. Please use it to format your code when contributing. However, it doesn't cover all the rules below. Some of them aren't very strict rules since we want to be flexible and we understand that under certain circumstances some of them can be counterproductive. Just try to follow as many of them as possible.
+
+# Using clang format (version 6.0)
+When generating the native build script for your toolset, cmake will try to find the correct version of clang format (or will download it on windows). Before running cmake, please install clang format version 6.0 for your platform as follows:
+
+* Windows: do nothing; cmake will download a pre built binary for MSVC and MINGW. MSVC users can additionally install a clang format Visual Studio extension to add features like format on save.
+* OSX: run `brew install clang-format`.
+* Linux: use your package manager to get an appropriate binary.
+
+If clang format is found, then cmake will add a custom build target that can be run at any time to run clang format against *all* source files and update the formatting in them. This should be used before making a pull request so that the reviewers can spend more time reviewing the code instead of having to worry about minor style violations. On MSVC, you can run clang format by building the clang-format project in the solution. On OSX, you can either use the Makefile target `make clang-format` or by building the clang-format target in XCode. For Makefile builds, you can use the clang-format target with `make clang-format`
+
+### General Rules
+* A lot of code was taken from other projects (e.g. Citra, Dolphin, PPSSPP, Gekko). In general, when editing other people's code, follow the style of the module you're in (or better yet, fix the style if it drastically differs from our guide).
+* Line width is typically 100 characters. Please do not use 80-characters.
+* Don't ever introduce new external dependencies into Core
+* Don't use any platform specific code in Core
+* Use namespaces often
+* Avoid the use of C-style casts and instead prefer C++-style `static_cast` and `reinterpret_cast`. Try to avoid using `dynamic_cast`. Never use `const_cast`.
+
+### Naming Rules
+* Functions: `PascalCase`
+* Variables: `lower_case_underscored`. Prefix with `g_` if global.
+* Classes: `PascalCase`
+* Files and Directories: `lower_case_underscored`
+* Namespaces: `PascalCase`, `_` may also be used for clarity (e.g. `ARM_InitCore`)
+
+### Indentation/Whitespace Style
+Follow the indentation/whitespace style shown below. Do not use tabs, use 4-spaces instead.
+
+### Comments
+* For regular comments, use C++ style (`//`) comments, even for multi-line ones.
+* For doc-comments (Doxygen comments), use `/// ` if it's a single line, else use the `/**` `*/` style featured in the example. Start the text on the second line, not the first containing `/**`.
+* For items that are both defined and declared in two separate files, put the doc-comment only next to the associated declaration. (In a header file, usually.) Otherwise, put it next to the implementation. Never duplicate doc-comments in both places.
+
+```cpp
+// Includes should be sorted lexicographically
+// STD includes first
+#include <map>
+#include <memory>
+
+// then, library includes
+#include <nihstro/shared_binary.h>
+
+// finally, yuzu includes
+#include "common/math_util.h"
+#include "common/vector_math.h"
+
+// each major module is separated
+#include "video_core/pica.h"
+#include "video_core/video_core.h"
+
+namespace Example {
+
+// Namespace contents are not indented
+
+// Declare globals at the top
+int g_foo{}; // {} can be used to initialize types as 0, false, or nullptr
+char* g_some_pointer{}; // Pointer * and reference & stick to the type name, and make sure to initialize as nullptr!
+
+/// A colorful enum.
+enum SomeEnum {
+    ColorRed,   ///< The color of fire.
+    ColorGreen, ///< The color of grass.
+    ColorBlue,  ///< Not actually the color of water.
+};
+
+/**
+ * Very important struct that does a lot of stuff.
+ * Note that the asterisks are indented by one space to align to the first line.
+ */
+struct Position {
+    int x{}, y{}; // Always intitialize member variables!
+};
+
+// Use "typename" rather than "class" here
+template <typename T>
+void FooBar() {
+    const std::string some_string{ "prefer uniform initialization" };
+
+    int some_array[]{
+        5,
+        25,
+        7,
+        42,
+    };
+
+    if (note == the_space_after_the_if) {
+        CallAfunction();
+    } else {
+        // Use a space after the // when commenting
+    }
+
+    // Place a single space after the for loop semicolons, prefer pre-increment
+    for (int i{}; i != 25; ++i) {
+        // This is how we write loops
+    }
+
+    DoStuff(this, function, call, takes, up, multiple,
+            lines, like, this);
+
+    if (this || condition_takes_up_multiple &&
+        lines && like && this || everything ||
+        alright || then) {
+
+        // Leave a blank space before the if block body if the condition was continued across
+        // several lines.
+    }
+
+    switch (var) {
+    // No indentation for case label
+    case 1: {
+        int case_var{ var + 3 };
+        DoSomething(case_var);
+        break;
+    }
+    case 3:
+        DoSomething(var);
+        return;
+
+    default:
+        // Yes, even break for the last case
+        break;
+    }
+
+    std::vector<T> you_can_declare, a_few, variables, like_this;
+}
+
+}
+```

src/audio_core/cubeb_sink.cpp

@@ -121,8 +121,7 @@ CubebSink::CubebSink(std::string target_device_name) {
             const auto collection_end{collection.device + collection.count};
             const auto device{
                 std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return info.friendly_name != nullptr &&
-                           target_device_name == info.friendly_name;
+                    return target_device_name == info.friendly_name;
                 })};
             if (device != collection_end) {
                 output_device = device->devid;

src/audio_core/time_stretch.cpp

@@ -10,7 +10,8 @@
 
 namespace AudioCore {
 
-TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count) : m_sample_rate{sample_rate} {
+TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count)
+    : m_sample_rate(sample_rate), m_channel_count(channel_count) {
     m_sound_touch.setChannels(channel_count);
     m_sound_touch.setSampleRate(sample_rate);
     m_sound_touch.setPitch(1.0);

src/audio_core/time_stretch.h

@@ -27,6 +27,7 @@ public:
 
 private:
     u32 m_sample_rate;
+    u32 m_channel_count;
     soundtouch::SoundTouch m_sound_touch;
     double m_stretch_ratio = 1.0;
 };

src/common/logging/backend.cpp

@@ -196,7 +196,6 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NIM)                                                                              \
-    SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCIE)                                                                             \
@@ -205,12 +204,10 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, PM)                                                                               \
     SUB(Service, PREPO)                                                                            \
     SUB(Service, PSC)                                                                              \
-    SUB(Service, PSM)                                                                              \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
     SUB(Service, SPL)                                                                              \
     SUB(Service, SSL)                                                                              \
-    SUB(Service, TCAP)                                                                             \
     SUB(Service, Time)                                                                             \
     SUB(Service, USB)                                                                              \
     SUB(Service, VI)                                                                               \

src/common/logging/log.h

@@ -83,7 +83,6 @@ enum class Class : ClassType {
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NIM,       ///< The NIM service
-    Service_NPNS,      ///< The NPNS service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCIE,      ///< The PCIe service
@@ -97,7 +96,6 @@ enum class Class : ClassType {
     Service_SM,        ///< The SM (Service manager) service
     Service_SPL,       ///< The SPL service
     Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
     Service_Time,      ///< The time service
     Service_USB,       ///< The USB (Universal Serial Bus) service
     Service_VI,        ///< The VI (Video interface) service

src/core/crypto/key_manager.cpp

@@ -395,7 +395,7 @@ static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_
     if (base.size() < begin + length)
         return false;
     return std::all_of(base.begin() + begin, base.begin() + begin + length,
-                       [](u8 c) { return std::isxdigit(c); });
+                       [](u8 c) { return std::isdigit(c); });
 }
 
 void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {
@@ -713,6 +713,7 @@ void KeyManager::DeriveBase() {
 
     const auto sbk = GetKey(S128KeyType::SecureBoot);
     const auto tsec = GetKey(S128KeyType::TSEC);
+    const auto master_source = GetKey(S128KeyType::Source, static_cast<u64>(SourceKeyType::Master));
 
     for (size_t i = 0; i < revisions.size(); ++i) {
         if (!revisions[i])

src/core/file_sys/card_image.cpp

@@ -168,6 +168,10 @@ VirtualDir XCI::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
     if (partitions[static_cast<std::size_t>(part)] == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;

src/core/file_sys/card_image.h

@@ -94,6 +94,9 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     Loader::ResultStatus AddNCAFromPartition(XCIPartition part);
 

src/core/file_sys/content_archive.cpp

@@ -546,4 +546,7 @@ u64 NCA::GetBaseIVFCOffset() const {
     return ivfc_offset;
 }
 
+bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/content_archive.h

@@ -100,6 +100,9 @@ public:
     // Returns the base ivfc offset used in BKTR patching.
     u64 GetBaseIVFCOffset() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     bool CheckSupportedNCA(const NCAHeader& header);
     bool HandlePotentialHeaderDecryption();

src/core/file_sys/ips_layer.cpp

@@ -99,7 +99,7 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
             u16 rle_size{};
             if (ips->ReadObject(&rle_size, offset) != sizeof(u16))
                 return nullptr;
-            rle_size = Common::swap16(rle_size);
+            rle_size = Common::swap16(data_size);
             offset += sizeof(u16);
 
             const auto data = ips->ReadByte(offset++);

src/core/file_sys/partition_filesystem.cpp

@@ -83,7 +83,7 @@ std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return {};
+    return pfs_dirs;
 }
 
 std::string PartitionFilesystem::GetName() const {
@@ -103,4 +103,18 @@ void PartitionFilesystem::PrintDebugInfo() const {
                   pfs_files[i]->GetName(), pfs_files[i]->GetSize());
     }
 }
+
+bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    if (iter == pfs_files.end())
+        return false;
+
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = std::move(pfs_files.back());
+    pfs_files.pop_back();
+
+    pfs_dirs.emplace_back(std::move(dir));
+
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/partition_filesystem.h

@@ -35,6 +35,9 @@ public:
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
     void PrintDebugInfo() const;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     struct Header {
         u32_le magic;
@@ -81,6 +84,7 @@ private:
     std::size_t content_offset = 0;
 
     std::vector<VirtualFile> pfs_files;
+    std::vector<VirtualDir> pfs_dirs;
 };
 
 } // namespace FileSys

src/core/file_sys/patch_manager.cpp

@@ -61,12 +61,13 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
     const auto update = installed->GetEntry(update_tid, ContentRecordType::Program);
-
-    if (update != nullptr && update->GetExeFS() != nullptr &&
-        update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-        LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
-        exefs = update->GetExeFS();
+    if (update != nullptr) {
+        if (update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
+            update->GetExeFS() != nullptr) {
+            LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
+                     FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
+            exefs = update->GetExeFS();
+        }
     }
 
     return exefs;
@@ -167,8 +168,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 
 static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
-    if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
-        load_dir == nullptr || load_dir->GetSize() <= 0) {
+    if (type != ContentRecordType::Program || load_dir == nullptr || load_dir->GetSize() <= 0) {
         return;
     }
 
@@ -218,7 +218,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
                                         title_id, static_cast<u8>(type))
                                 .c_str();
 
-    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
+    if (type == ContentRecordType::Program)
         LOG_INFO(Loader, log_string);
     else
         LOG_DEBUG(Loader, log_string);

src/core/file_sys/registered_cache.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <regex>
 #include <mbedtls/sha256.h>
 #include "common/assert.h"
@@ -31,14 +30,6 @@ bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs)
     return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
 }
 
-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
-    return std::tie(lhs.title_id, lhs.type) == std::tie(rhs.title_id, rhs.type);
-}
-
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
-    return !operator==(lhs, rhs);
-}
-
 static bool FollowsTwoDigitDirFormat(std::string_view name) {
     static const std::regex two_digit_regex("000000[0-9A-F]{2}", std::regex_constants::ECMAScript |
                                                                      std::regex_constants::icase);
@@ -602,9 +593,6 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
             },
             [](const CNMT& c, const ContentRecord& r) { return true; });
     }
-
-    std::sort(out.begin(), out.end());
-    out.erase(std::unique(out.begin(), out.end()), out.end());
     return out;
 }
 
@@ -628,9 +616,6 @@ std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
                 return true;
             });
     }
-
-    std::sort(out.begin(), out.end());
-    out.erase(std::unique(out.begin(), out.end()), out.end());
     return out;
 }
 } // namespace FileSys

src/core/file_sys/registered_cache.h

@@ -50,10 +50,6 @@ constexpr u64 GetUpdateTitleID(u64 base_title_id) {
 // boost flat_map requires operator< for O(log(n)) lookups.
 bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
 
-// std unique requires operator== to identify duplicates.
-bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
-
 /*
  * A class that catalogues NCAs in the registered directory structure.
  * Nintendo's registered format follows this structure:
@@ -64,8 +60,8 @@ bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs
  *         | 00
  *         | 01 <- Actual content split along 4GB boundaries. (optional)
  *
- * (This impl also supports substituting the nca dir for an nca file, as that's more convenient
- * when 4GB splitting can be ignored.)
+ * (This impl also supports substituting the nca dir for an nca file, as that's more convenient when
+ * 4GB splitting can be ignored.)
  */
 class RegisteredCache {
     friend class RegisteredCacheUnion;

src/core/file_sys/submission_package.cpp

@@ -205,6 +205,10 @@ VirtualDir NSP::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool NSP::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
+
 void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {
     exefs = pfs;
 

src/core/file_sys/submission_package.h

@@ -55,6 +55,9 @@ public:
 
     VirtualDir GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     void InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files);
     void ReadNCAs(const std::vector<VirtualFile>& files);

src/core/file_sys/vfs.cpp

@@ -472,14 +472,10 @@ bool VfsRawCopy(const VirtualFile& src, const VirtualFile& dest, std::size_t blo
     std::vector<u8> temp(std::min(block_size, src->GetSize()));
     for (std::size_t i = 0; i < src->GetSize(); i += block_size) {
         const auto read = std::min(block_size, src->GetSize() - i);
+        const auto block = src->Read(temp.data(), read, i);
 
-        if (src->Read(temp.data(), read, i) != read) {
+        if (dest->Write(temp.data(), read, i) != read)
             return false;
-        }
-
-        if (dest->Write(temp.data(), read, i) != read) {
-            return false;
-        }
     }
 
     return true;

src/core/file_sys/vfs.h

@@ -262,8 +262,36 @@ public:
     // item name -> type.
     virtual std::map<std::string, VfsEntryType, std::less<>> GetEntries() const;
 
+    // Interprets the file with name file instead as a directory of type directory.
+    // The directory must have a constructor that takes a single argument of type
+    // std::shared_ptr<VfsFile>. Allows to reinterpret container files (i.e NCA, zip, XCI, etc) as a
+    // subdirectory in one call.
+    template <typename Directory>
+    bool InterpretAsDirectory(std::string_view file) {
+        auto file_p = GetFile(file);
+
+        if (file_p == nullptr) {
+            return false;
+        }
+
+        return ReplaceFileWithSubdirectory(file_p, std::make_shared<Directory>(file_p));
+    }
+
+    bool InterpretAsDirectory(const std::function<VirtualDir(VirtualFile)>& function,
+                              const std::string& file) {
+        auto file_p = GetFile(file);
+        if (file_p == nullptr)
+            return false;
+        return ReplaceFileWithSubdirectory(file_p, function(file_p));
+    }
+
     // Returns the full path of this directory as a string, recursively
     virtual std::string GetFullPath() const;
+
+protected:
+    // Backend for InterpretAsDirectory.
+    // Removes all references to file and adds a reference to dir in the directory's implementation.
+    virtual bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) = 0;
 };
 
 // A convenience partial-implementation of VfsDirectory that stubs out methods that should only work

src/core/file_sys/vfs_layered.cpp

@@ -126,4 +126,7 @@ bool LayeredVfsDirectory::Rename(std::string_view name_) {
     return true;
 }
 
+bool LayeredVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/vfs_layered.h

@@ -39,6 +39,9 @@ public:
     bool DeleteFile(std::string_view name) override;
     bool Rename(std::string_view name) override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     std::vector<VirtualDir> dirs;
     std::string name;

src/core/file_sys/vfs_real.cpp

@@ -430,4 +430,7 @@ std::map<std::string, VfsEntryType, std::less<>> RealVfsDirectory::GetEntries()
     return out;
 }
 
+bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/vfs_real.h

@@ -100,6 +100,9 @@ public:
     std::string GetFullPath() const override;
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     RealVfsDirectory(RealVfsFilesystem& base, const std::string& path, Mode perms = Mode::Read);
 

src/core/file_sys/vfs_vector.cpp

@@ -132,4 +132,11 @@ void VectorVfsDirectory::AddFile(VirtualFile file) {
 void VectorVfsDirectory::AddDirectory(VirtualDir dir) {
     dirs.push_back(std::move(dir));
 }
+
+bool VectorVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    if (!DeleteFile(file->GetName()))
+        return false;
+    dirs.emplace_back(std::move(dir));
+    return true;
+}
 } // namespace FileSys

src/core/file_sys/vfs_vector.h

@@ -57,6 +57,9 @@ public:
     virtual void AddFile(VirtualFile file);
     virtual void AddDirectory(VirtualDir dir);
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     std::vector<VirtualFile> files;
     std::vector<VirtualDir> dirs;

src/core/file_sys/xts_archive.cpp

@@ -163,4 +163,7 @@ std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
+bool NAX::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+    return false;
+}
 } // namespace FileSys

src/core/file_sys/xts_archive.h

@@ -51,6 +51,9 @@ public:
 
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
 
+protected:
+    bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
 private:
     Loader::ResultStatus Parse(std::string_view path);
 

src/core/hle/ipc.h

@@ -14,6 +14,11 @@ namespace IPC {
 /// Size of the command buffer area, in 32-bit words.
 constexpr std::size_t COMMAND_BUFFER_LENGTH = 0x100 / sizeof(u32);
 
+// These errors are commonly returned by invalid IPC translations, so alias them here for
+// convenience.
+// TODO(yuriks): These will probably go away once translation is implemented inside the kernel.
+constexpr auto ERR_INVALID_HANDLE = Kernel::ERR_INVALID_HANDLE_OS;
+
 enum class ControlCommand : u32 {
     ConvertSessionToDomain = 0,
     ConvertDomainToSession = 1,

src/core/hle/kernel/errors.h

@@ -10,6 +10,11 @@ namespace Kernel {
 
 namespace ErrCodes {
 enum {
+    // TODO(Subv): Remove these 3DS OS error codes.
+    SessionClosedByRemote = 26,
+    NoPendingSessions = 35,
+    InvalidBufferDescriptor = 48,
+
     // Confirmed Switch OS error codes
     MaxConnectionsReached = 7,
     InvalidSize = 101,
@@ -21,7 +26,6 @@ enum {
     InvalidThreadPriority = 112,
     InvalidProcessorId = 113,
     InvalidHandle = 114,
-    InvalidPointer = 115,
     InvalidCombination = 116,
     Timeout = 117,
     SynchronizationCanceled = 118,
@@ -29,7 +33,6 @@ enum {
     InvalidEnumValue = 120,
     NoSuchEntry = 121,
     AlreadyRegistered = 122,
-    SessionClosed = 123,
     InvalidState = 125,
     ResourceLimitExceeded = 132,
 };
@@ -38,14 +41,18 @@ enum {
 // WARNING: The kernel is quite inconsistent in it's usage of errors code. Make sure to always
 // double check that the code matches before re-using the constant.
 
+// TODO(bunnei): Replace -1 with correct errors for Switch OS
 constexpr ResultCode ERR_HANDLE_TABLE_FULL(ErrorModule::Kernel, ErrCodes::HandleTableFull);
-constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(ErrorModule::Kernel, ErrCodes::SessionClosed);
+constexpr ResultCode ERR_SESSION_CLOSED_BY_REMOTE(-1);
 constexpr ResultCode ERR_PORT_NAME_TOO_LONG(ErrorModule::Kernel, ErrCodes::TooLarge);
 constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED(ErrorModule::Kernel,
                                                  ErrCodes::MaxConnectionsReached);
 constexpr ResultCode ERR_INVALID_ENUM_VALUE(ErrorModule::Kernel, ErrCodes::InvalidEnumValue);
+constexpr ResultCode ERR_INVALID_ENUM_VALUE_FND(-1);
+constexpr ResultCode ERR_INVALID_COMBINATION(-1);
 constexpr ResultCode ERR_INVALID_COMBINATION_KERNEL(ErrorModule::Kernel,
                                                     ErrCodes::InvalidCombination);
+constexpr ResultCode ERR_OUT_OF_MEMORY(-1);
 constexpr ResultCode ERR_INVALID_ADDRESS(ErrorModule::Kernel, ErrCodes::InvalidAddress);
 constexpr ResultCode ERR_INVALID_ADDRESS_STATE(ErrorModule::Kernel, ErrCodes::InvalidMemoryState);
 constexpr ResultCode ERR_INVALID_MEMORY_PERMISSIONS(ErrorModule::Kernel,
@@ -58,8 +65,14 @@ constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::Kernel, ErrCodes::Alrea
 constexpr ResultCode ERR_INVALID_STATE(ErrorModule::Kernel, ErrCodes::InvalidState);
 constexpr ResultCode ERR_INVALID_THREAD_PRIORITY(ErrorModule::Kernel,
                                                  ErrCodes::InvalidThreadPriority);
-constexpr ResultCode ERR_INVALID_POINTER(ErrorModule::Kernel, ErrCodes::InvalidPointer);
+constexpr ResultCode ERR_INVALID_POINTER(-1);
+constexpr ResultCode ERR_INVALID_OBJECT_ADDR(-1);
+constexpr ResultCode ERR_NOT_AUTHORIZED(-1);
+/// Alternate code returned instead of ERR_INVALID_HANDLE in some code paths.
+constexpr ResultCode ERR_INVALID_HANDLE_OS(-1);
 constexpr ResultCode ERR_NOT_FOUND(ErrorModule::Kernel, ErrCodes::NoSuchEntry);
 constexpr ResultCode RESULT_TIMEOUT(ErrorModule::Kernel, ErrCodes::Timeout);
+/// Returned when Accept() is called on a port with no sessions to be accepted.
+constexpr ResultCode ERR_NO_PENDING_SESSIONS(-1);
 
 } // namespace Kernel

src/core/hle/kernel/process.cpp

@@ -232,12 +232,6 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
     MapSegment(module_.CodeSegment(), VMAPermission::ReadExecute, MemoryState::CodeStatic);
     MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeMutable);
     MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeMutable);
-
-    // Clear instruction cache in CPU JIT
-    Core::System::GetInstance().ArmInterface(0).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(1).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(2).ClearInstructionCache();
-    Core::System::GetInstance().ArmInterface(3).ClearInstructionCache();
 }
 
 ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {

src/core/hle/kernel/process.h

@@ -202,16 +202,6 @@ public:
         return is_64bit_process;
     }
 
-    /// Gets the total running time of the process instance in ticks.
-    u64 GetCPUTimeTicks() const {
-        return total_process_running_time_ticks;
-    }
-
-    /// Updates the total running time, adding the given ticks to it.
-    void UpdateCPUTimeTicks(u64 ticks) {
-        total_process_running_time_ticks += ticks;
-    }
-
     /**
      * Loads process-specifics configuration info with metadata provided
      * by an executable.
@@ -315,9 +305,6 @@ private:
     /// specified by metadata provided to the process during loading.
     bool is_64bit_process = true;
 
-    /// Total running time for the process in ticks.
-    u64 total_process_running_time_ticks = 0;
-
     /// Per-process handle table for storing created object handles in.
     HandleTable handle_table;
 

src/core/hle/kernel/scheduler.cpp

@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -35,10 +34,6 @@ Thread* Scheduler::GetCurrentThread() const {
     return current_thread.get();
 }
 
-u64 Scheduler::GetLastContextSwitchTicks() const {
-    return last_context_switch_time;
-}
-
 Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
@@ -59,10 +54,7 @@ Thread* Scheduler::PopNextReadyThread() {
 }
 
 void Scheduler::SwitchContext(Thread* new_thread) {
-    Thread* const previous_thread = GetCurrentThread();
-    Process* const previous_process = Core::CurrentProcess();
-
-    UpdateLastContextSwitchTime(previous_thread, previous_process);
+    Thread* previous_thread = GetCurrentThread();
 
     // Save context for previous thread
     if (previous_thread) {
@@ -86,6 +78,8 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
 
+        auto* const previous_process = Core::CurrentProcess();
+
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->GetPriority(), new_thread);
@@ -108,22 +102,6 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     }
 }
 
-void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
-    const u64 prev_switch_ticks = last_context_switch_time;
-    const u64 most_recent_switch_ticks = CoreTiming::GetTicks();
-    const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;
-
-    if (thread != nullptr) {
-        thread->UpdateCPUTimeTicks(update_ticks);
-    }
-
-    if (process != nullptr) {
-        process->UpdateCPUTimeTicks(update_ticks);
-    }
-
-    last_context_switch_time = most_recent_switch_ticks;
-}
-
 void Scheduler::Reschedule() {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 

src/core/hle/kernel/scheduler.h

@@ -17,8 +17,6 @@ class ARM_Interface;
 
 namespace Kernel {
 
-class Process;
-
 class Scheduler final {
 public:
     explicit Scheduler(Core::ARM_Interface& cpu_core);
@@ -33,9 +31,6 @@ public:
     /// Gets the current running thread
     Thread* GetCurrentThread() const;
 
-    /// Gets the timestamp for the last context switch in ticks.
-    u64 GetLastContextSwitchTicks() const;
-
     /// Adds a new thread to the scheduler
     void AddThread(SharedPtr<Thread> thread, u32 priority);
 
@@ -69,19 +64,6 @@ private:
      */
     void SwitchContext(Thread* new_thread);
 
-    /**
-     * Called on every context switch to update the internal timestamp
-     * This also updates the running time ticks for the given thread and
-     * process using the following difference:
-     *
-     * ticks += most_recent_ticks - last_context_switch_ticks
-     *
-     * The internal tick timestamp for the scheduler is simply the
-     * most recent tick count retrieved. No special arithmetic is
-     * applied to it.
-     */
-    void UpdateLastContextSwitchTime(Thread* thread, Process* process);
-
     /// Lists all thread ids that aren't deleted/etc.
     std::vector<SharedPtr<Thread>> thread_list;
 
@@ -91,7 +73,6 @@ private:
     SharedPtr<Thread> current_thread = nullptr;
 
     Core::ARM_Interface& cpu_core;
-    u64 last_context_switch_time = 0;
 
     static std::mutex scheduler_mutex;
 };

src/core/hle/kernel/server_port.cpp

@@ -18,7 +18,7 @@ ServerPort::~ServerPort() = default;
 
 ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
     if (pending_sessions.empty()) {
-        return ERR_NOT_FOUND;
+        return ERR_NO_PENDING_SESSIONS;
     }
 
     auto session = std::move(pending_sessions.back());
@@ -28,7 +28,7 @@ ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
 
 bool ServerPort::ShouldWait(Thread* thread) const {
     // If there are no pending sessions, we wait until a new one is added.
-    return pending_sessions.empty();
+    return pending_sessions.size() == 0;
 }
 
 void ServerPort::Acquire(Thread* thread) {

src/core/hle/kernel/shared_memory.cpp

@@ -80,19 +80,20 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
 
 ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermission permissions,
                              MemoryPermission other_permissions) {
-    const MemoryPermission own_other_permissions =
+
+    MemoryPermission own_other_permissions =
         target_process == owner_process ? this->permissions : this->other_permissions;
 
     // Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
     if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        return ERR_INVALID_COMBINATION;
     }
 
     // Error out if the requested permissions don't match what the creator process allows.
     if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
         LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
                   GetObjectId(), address, name);
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        return ERR_INVALID_COMBINATION;
     }
 
     // Error out if the provided permissions are not compatible with what the creator process needs.

src/core/hle/kernel/svc.cpp

@@ -375,19 +375,9 @@ static ResultCode ArbitrateUnlock(VAddr mutex_addr) {
     return Mutex::Release(mutex_addr);
 }
 
-enum class BreakType : u32 {
-    Panic = 0,
-    AssertionFailed = 1,
-    PreNROLoad = 3,
-    PostNROLoad = 4,
-    PreNROUnload = 5,
-    PostNROUnload = 6,
-};
-
 struct BreakReason {
     union {
         u32 raw;
-        BitField<0, 30, BreakType> break_type;
         BitField<31, 1, u32> signal_debugger;
     };
 };
@@ -395,48 +385,12 @@ struct BreakReason {
 /// Break program execution
 static void Break(u32 reason, u64 info1, u64 info2) {
     BreakReason break_reason{reason};
-
-    switch (break_reason.break_type) {
-    case BreakType::Panic:
-        LOG_CRITICAL(Debug_Emulated, "Signalling debugger, PANIC! info1=0x{:016X}, info2=0x{:016X}",
-                     info1, info2);
-        break;
-    case BreakType::AssertionFailed:
-        LOG_CRITICAL(Debug_Emulated,
-                     "Signalling debugger, Assertion failed! info1=0x{:016X}, info2=0x{:016X}",
-                     info1, info2);
-        break;
-    case BreakType::PreNROLoad:
-        LOG_WARNING(
+    if (break_reason.signal_debugger) {
+        LOG_ERROR(
             Debug_Emulated,
-            "Signalling debugger, Attempting to load an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
-        break;
-    case BreakType::PostNROLoad:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Loaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
-        break;
-    case BreakType::PreNROUnload:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Attempting to unload an NRO at 0x{:016X} with size 0x{:016X}",
-            info1, info2);
-        break;
-    case BreakType::PostNROUnload:
-        LOG_WARNING(Debug_Emulated,
-                    "Signalling debugger, Unloaded an NRO at 0x{:016X} with size 0x{:016X}", info1,
-                    info2);
-        break;
-    default:
-        LOG_WARNING(
-            Debug_Emulated,
-            "Signalling debugger, Unknown break reason {}, info1=0x{:016X}, info2=0x{:016X}",
-            static_cast<u32>(break_reason.break_type.Value()), info1, info2);
-        break;
-    }
-
-    if (!break_reason.signal_debugger) {
+            "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
+            reason, info1, info2);
+    } else {
         LOG_CRITICAL(
             Debug_Emulated,
             "Emulated program broke execution! reason=0x{:016X}, info1=0x{:016X}, info2=0x{:016X}",
@@ -467,37 +421,6 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
-    enum class GetInfoType : u64 {
-        // 1.0.0+
-        AllowedCpuIdBitmask = 0,
-        AllowedThreadPrioBitmask = 1,
-        MapRegionBaseAddr = 2,
-        MapRegionSize = 3,
-        HeapRegionBaseAddr = 4,
-        HeapRegionSize = 5,
-        TotalMemoryUsage = 6,
-        TotalHeapUsage = 7,
-        IsCurrentProcessBeingDebugged = 8,
-        ResourceHandleLimit = 9,
-        IdleTickCount = 10,
-        RandomEntropy = 11,
-        PerformanceCounter = 0xF0000002,
-        // 2.0.0+
-        ASLRRegionBaseAddr = 12,
-        ASLRRegionSize = 13,
-        NewMapRegionBaseAddr = 14,
-        NewMapRegionSize = 15,
-        // 3.0.0+
-        IsVirtualAddressMemoryEnabled = 16,
-        PersonalMmHeapUsage = 17,
-        TitleId = 18,
-        // 4.0.0+
-        PrivilegedProcessId = 19,
-        // 5.0.0+
-        UserExceptionContextAddr = 20,
-        ThreadTickCount = 0xF0000002,
-    };
-
     const auto* current_process = Core::CurrentProcess();
     const auto& vm_manager = current_process->VMManager();
 
@@ -560,36 +483,6 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
                     "(STUBBED) Attempted to query user exception context address, returned 0");
         *result = 0;
         break;
-    case GetInfoType::ThreadTickCount: {
-        constexpr u64 num_cpus = 4;
-        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
-            return ERR_INVALID_COMBINATION_KERNEL;
-        }
-
-        const auto thread =
-            current_process->GetHandleTable().Get<Thread>(static_cast<Handle>(handle));
-        if (!thread) {
-            return ERR_INVALID_HANDLE;
-        }
-
-        auto& system = Core::System::GetInstance();
-        const auto& scheduler = system.CurrentScheduler();
-        const auto* const current_thread = scheduler.GetCurrentThread();
-        const bool same_thread = current_thread == thread;
-
-        const u64 prev_ctx_ticks = scheduler.GetLastContextSwitchTicks();
-        u64 out_ticks = 0;
-        if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
-            const u64 thread_ticks = current_thread->GetTotalCPUTimeTicks();
-
-            out_ticks = thread_ticks + (CoreTiming::GetTicks() - prev_ctx_ticks);
-        } else if (same_thread && info_sub_id == system.CurrentCoreIndex()) {
-            out_ticks = CoreTiming::GetTicks() - prev_ctx_ticks;
-        }
-
-        *result = out_ticks;
-        break;
-    }
     default:
         UNIMPLEMENTED();
     }
@@ -655,17 +548,16 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
     }
 
     const auto* const current_process = Core::CurrentProcess();
+    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
+    if (!thread) {
+        return ERR_INVALID_HANDLE;
+    }
 
     // Note: The kernel uses the current process's resource limit instead of
     // the one from the thread owner's resource limit.
     const ResourceLimit& resource_limit = current_process->GetResourceLimit();
     if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_INVALID_THREAD_PRIORITY;
-    }
-
-    SharedPtr<Thread> thread = current_process->GetHandleTable().Get<Thread>(handle);
-    if (!thread) {
-        return ERR_INVALID_HANDLE;
+        return ERR_NOT_AUTHORIZED;
     }
 
     thread->SetPriority(priority);
@@ -807,7 +699,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     auto* const current_process = Core::CurrentProcess();
     const ResourceLimit& resource_limit = current_process->GetResourceLimit();
     if (resource_limit.GetMaxResourceValue(ResourceType::Priority) > priority) {
-        return ERR_INVALID_THREAD_PRIORITY;
+        return ERR_NOT_AUTHORIZED;
     }
 
     if (processor_id == THREADPROCESSORID_DEFAULT) {
@@ -878,12 +770,24 @@ static void ExitThread() {
 
 /// Sleep the current thread
 static void SleepThread(s64 nanoseconds) {
-    LOG_TRACE(Kernel_SVC, "called nanoseconds={}", nanoseconds);
+    LOG_DEBUG(Kernel_SVC, "called nanoseconds={}", nanoseconds);
 
-    // Don't attempt to yield execution if there are no available threads to run,
-    // this way we avoid a useless reschedule to the idle thread.
-    if (nanoseconds == 0 && !Core::System::GetInstance().CurrentScheduler().HaveReadyThreads())
+    if (nanoseconds == 0) {
+        // Yield type 0 is just a yield without load balancing
+        Core::System::GetInstance().CpuCore(0).PrepareReschedule();
+        Core::System::GetInstance().CpuCore(1).PrepareReschedule();
+        Core::System::GetInstance().CpuCore(2).PrepareReschedule();
+        Core::System::GetInstance().CpuCore(3).PrepareReschedule();
         return;
+    }
+
+    if (nanoseconds < 0) {
+        UNIMPLEMENTED_MSG("unimplemented yield type");
+
+        // TODO(bunnei): Implement the various load balancing yield types here. This will force a
+        // reschedule, but is incorrect.
+        nanoseconds = 0;
+    }
 
     // Sleep current thread and check for next thread to schedule
     WaitCurrentThread_Sleep();
@@ -891,7 +795,10 @@ static void SleepThread(s64 nanoseconds) {
     // Create an event to wake the thread up after the specified nanosecond delay has passed
     GetCurrentThread()->WakeAfterDelay(nanoseconds);
 
-    Core::System::GetInstance().PrepareReschedule();
+    Core::System::GetInstance().CpuCore(0).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(1).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(2).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(3).PrepareReschedule();
 }
 
 /// Wait process wide key atomic

src/core/hle/kernel/svc.h

@@ -24,6 +24,37 @@ struct PageInfo {
     u64 flags;
 };
 
+/// Values accepted by svcGetInfo
+enum class GetInfoType : u64 {
+    // 1.0.0+
+    AllowedCpuIdBitmask = 0,
+    AllowedThreadPrioBitmask = 1,
+    MapRegionBaseAddr = 2,
+    MapRegionSize = 3,
+    HeapRegionBaseAddr = 4,
+    HeapRegionSize = 5,
+    TotalMemoryUsage = 6,
+    TotalHeapUsage = 7,
+    IsCurrentProcessBeingDebugged = 8,
+    ResourceHandleLimit = 9,
+    IdleTickCount = 10,
+    RandomEntropy = 11,
+    PerformanceCounter = 0xF0000002,
+    // 2.0.0+
+    ASLRRegionBaseAddr = 12,
+    ASLRRegionSize = 13,
+    NewMapRegionBaseAddr = 14,
+    NewMapRegionSize = 15,
+    // 3.0.0+
+    IsVirtualAddressMemoryEnabled = 16,
+    PersonalMmHeapUsage = 17,
+    TitleId = 18,
+    // 4.0.0+
+    PrivilegedProcessId = 19,
+    // 5.0.0+
+    UserExceptionContextAddr = 20,
+};
+
 void CallSVC(u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -258,14 +258,6 @@ public:
         return last_running_ticks;
     }
 
-    u64 GetTotalCPUTimeTicks() const {
-        return total_cpu_time_ticks;
-    }
-
-    void UpdateCPUTimeTicks(u64 ticks) {
-        total_cpu_time_ticks += ticks;
-    }
-
     s32 GetProcessorID() const {
         return processor_id;
     }
@@ -386,8 +378,7 @@ private:
     u32 nominal_priority = 0; ///< Nominal thread priority, as set by the emulated application
     u32 current_priority = 0; ///< Current thread priority, can be temporarily changed
 
-    u64 total_cpu_time_ticks = 0; ///< Total CPU running ticks.
-    u64 last_running_ticks = 0;   ///< CPU tick when thread was last running
+    u64 last_running_ticks = 0; ///< CPU tick when thread was last running
 
     s32 processor_id = 0;
 

src/core/hle/kernel/vm_manager.cpp

@@ -143,26 +143,6 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }
 
-ResultVal<VAddr> VMManager::FindFreeRegion(u64 size) const {
-    // Find the first Free VMA.
-    const VAddr base = GetASLRRegionBaseAddress();
-    const VMAHandle vma_handle = std::find_if(vma_map.begin(), vma_map.end(), [&](const auto& vma) {
-        if (vma.second.type != VMAType::Free)
-            return false;
-
-        const VAddr vma_end = vma.second.base + vma.second.size;
-        return vma_end > base && vma_end >= base + size;
-    });
-
-    if (vma_handle == vma_map.end()) {
-        // TODO(Subv): Find the correct error code here.
-        return ResultCode(-1);
-    }
-
-    const VAddr target = std::max(base, vma_handle->second.base);
-    return MakeResult<VAddr>(target);
-}
-
 ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u64 size,
                                                    MemoryState state,
                                                    Memory::MemoryHookPointer mmio_handler) {

src/core/hle/kernel/vm_manager.h

@@ -157,14 +157,6 @@ public:
      */
     ResultVal<VMAHandle> MapBackingMemory(VAddr target, u8* memory, u64 size, MemoryState state);
 
-    /**
-     * Finds the first free address that can hold a region of the desired size.
-     *
-     * @param size Size of the desired region.
-     * @return The found free address.
-     */
-    ResultVal<VAddr> FindFreeRegion(u64 size) const;
-
     /**
      * Maps a memory-mapped IO region at a given address.
      *

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

@@ -2,13 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <array>
-#include "common/common_paths.h"
 #include "common/common_types.h"
-#include "common/file_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
@@ -20,7 +16,6 @@
 #include "core/hle/service/acc/profile_manager.h"
 
 namespace Service::Account {
-
 // TODO: RE this structure
 struct UserData {
     INSERT_PADDING_WORDS(1);
@@ -32,29 +27,6 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
-// Smallest JPEG https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
-// used as a backup should the one on disk not exist
-constexpr u32 backup_jpeg_size = 107;
-constexpr std::array<u8, backup_jpeg_size> backup_jpeg{{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-}};
-
-static std::string GetImagePath(UUID uuid) {
-    return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-           "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
-}
-
-static constexpr u32 SanitizeJPEGSize(std::size_t size) {
-    constexpr std::size_t max_jpeg_image_size = 0x20000;
-    return static_cast<u32>(std::min(size, max_jpeg_image_size));
-}
-
 class IProfile final : public ServiceFramework<IProfile> {
 public:
     explicit IProfile(UUID user_id, ProfileManager& profile_manager)
@@ -101,42 +73,32 @@ private:
     }
 
     void LoadImage(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called");
-
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
+        // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
+        constexpr u32 jpeg_size = 107;
+        static constexpr std::array<u8, jpeg_size> jpeg{
+            0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
+            0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
+            0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
+            0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e, 0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f,
+            0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13, 0x12, 0x10, 0x13, 0x0f, 0x10, 0x10,
+            0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
+            0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
+            0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
+        };
+        ctx.WriteBuffer(jpeg);
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-
-        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
-        if (!image.IsOpen()) {
-            LOG_WARNING(Service_ACC,
-                        "Failed to load user provided image! Falling back to built-in backup...");
-            ctx.WriteBuffer(backup_jpeg);
-            rb.Push<u32>(backup_jpeg_size);
-            return;
-        }
-
-        const u32 size = SanitizeJPEGSize(image.GetSize());
-        std::vector<u8> buffer(size);
-        image.ReadBytes(buffer.data(), buffer.size());
-
-        ctx.WriteBuffer(buffer.data(), buffer.size());
-        rb.Push<u32>(size);
+        rb.Push<u32>(jpeg_size);
     }
 
     void GetImageSize(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called");
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        constexpr u32 jpeg_size = 107;
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-
-        const FileUtil::IOFile image(GetImagePath(user_id), "rb");
-
-        if (!image.IsOpen()) {
-            LOG_WARNING(Service_ACC,
-                        "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push<u32>(backup_jpeg_size);
-        } else {
-            rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
-        }
+        rb.Push<u32>(jpeg_size);
     }
 
     const ProfileManager& profile_manager;

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

@@ -3,66 +3,41 @@
 // Refer to the license.txt file included.
 
 #include <random>
-
-#include "common/file_util.h"
+#include <boost/optional.hpp>
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 
 namespace Service::Account {
-
-struct UserRaw {
-    UUID uuid;
-    UUID uuid2;
-    u64 timestamp;
-    ProfileUsername username;
-    INSERT_PADDING_BYTES(0x80);
-};
-static_assert(sizeof(UserRaw) == 0xC8, "UserRaw has incorrect size.");
-
-struct ProfileDataRaw {
-    INSERT_PADDING_BYTES(0x10);
-    std::array<UserRaw, MAX_USERS> users;
-};
-static_assert(sizeof(ProfileDataRaw) == 0x650, "ProfileDataRaw has incorrect size.");
-
 // TODO(ogniK): Get actual error codes
 constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
-constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "/system/save/8000000000000010/su/avators/";
-
-UUID UUID::Generate() {
+const 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)};
+    uuid[0] = distribution(gen);
+    uuid[1] = distribution(gen);
+    return *this;
 }
 
 ProfileManager::ProfileManager() {
-    ParseUserSaveFile();
-
-    if (user_count == 0)
-        CreateNewUser(UUID::Generate(), "yuzu");
-
-    auto current = std::clamp<int>(Settings::values.current_user, 0, MAX_USERS - 1);
-    if (UserExistsIndex(current))
-        current = 0;
-
-    OpenUser(*GetUser(current));
+    // TODO(ogniK): Create the default user we have for now until loading/saving users is added
+    auto user_uuid = UUID{1, 0};
+    ASSERT(CreateNewUser(user_uuid, Settings::values.username).IsSuccess());
+    OpenUser(user_uuid);
 }
 
-ProfileManager::~ProfileManager() {
-    WriteUserSaveFile();
-}
+ProfileManager::~ProfileManager() = default;
 
 /// After a users creation it needs to be "registered" to the system. AddToProfiles handles the
 /// internal management of the users profiles
-std::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& profile) {
+boost::optional<std::size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
     if (user_count >= MAX_USERS) {
-        return {};
+        return boost::none;
     }
-    profiles[user_count] = profile;
+    profiles[user_count] = user;
     return user_count++;
 }
 
@@ -81,7 +56,7 @@ bool ProfileManager::RemoveProfileAtIndex(std::size_t index) {
 
 /// Helper function to register a user to the system
 ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
-    if (!AddToProfiles(user)) {
+    if (AddToProfiles(user) == boost::none) {
         return ERROR_TOO_MANY_USERS;
     }
     return RESULT_SUCCESS;
@@ -126,40 +101,31 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
     return CreateNewUser(uuid, username_output);
 }
 
-std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
-    if (index >= MAX_USERS) {
-        return {};
-    }
-
-    return profiles[index].user_uuid;
-}
-
 /// Returns a users profile index based on their user id.
-std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
+boost::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
     if (!uuid) {
-        return {};
+        return boost::none;
     }
-
-    const auto iter = std::find_if(profiles.begin(), profiles.end(),
-                                   [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
+    auto iter = std::find_if(profiles.begin(), profiles.end(),
+                             [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
     if (iter == profiles.end()) {
-        return {};
+        return boost::none;
     }
-
     return static_cast<std::size_t>(std::distance(profiles.begin(), iter));
 }
 
 /// Returns a users profile index based on their profile
-std::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
+boost::optional<std::size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
     return GetUserIndex(user.user_uuid);
 }
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const {
-    if (!index || index >= MAX_USERS) {
+bool ProfileManager::GetProfileBase(boost::optional<std::size_t> index,
+                                    ProfileBase& profile) const {
+    if (index == boost::none || index >= MAX_USERS) {
         return false;
     }
-    const auto& prof_info = profiles[*index];
+    const auto& prof_info = profiles[index.get()];
     profile.user_uuid = prof_info.user_uuid;
     profile.username = prof_info.username;
     profile.timestamp = prof_info.creation_time;
@@ -168,7 +134,7 @@ bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBas
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
 bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
-    const auto idx = GetUserIndex(uuid);
+    auto idx = GetUserIndex(uuid);
     return GetProfileBase(idx, profile);
 }
 
@@ -195,34 +161,26 @@ std::size_t ProfileManager::GetOpenUserCount() const {
 
 /// Checks if a user id exists in our profile manager
 bool ProfileManager::UserExists(UUID uuid) const {
-    return GetUserIndex(uuid) != std::nullopt;
-}
-
-bool ProfileManager::UserExistsIndex(std::size_t index) const {
-    if (index >= MAX_USERS)
-        return false;
-    return profiles[index].user_uuid.uuid != INVALID_UUID;
+    return (GetUserIndex(uuid) != boost::none);
 }
 
 /// Opens a specific user
 void ProfileManager::OpenUser(UUID uuid) {
-    const auto idx = GetUserIndex(uuid);
-    if (!idx) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
         return;
     }
-
-    profiles[*idx].is_open = true;
+    profiles[idx.get()].is_open = true;
     last_opened_user = uuid;
 }
 
 /// Closes a specific user
 void ProfileManager::CloseUser(UUID uuid) {
-    const auto idx = GetUserIndex(uuid);
-    if (!idx) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
         return;
     }
-
-    profiles[*idx].is_open = false;
+    profiles[idx.get()].is_open = false;
 }
 
 /// Gets all valid user ids on the system
@@ -252,10 +210,10 @@ UUID ProfileManager::GetLastOpenedUser() const {
 }
 
 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
+bool ProfileManager::GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
                                            ProfileData& data) const {
     if (GetProfileBase(index, profile)) {
-        data = profiles[*index].data;
+        data = profiles[index.get()].data;
         return true;
     }
     return false;
@@ -264,7 +222,7 @@ bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, Pro
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
                                            ProfileData& data) const {
-    const auto idx = GetUserIndex(uuid);
+    auto idx = GetUserIndex(uuid);
     return GetProfileBaseAndData(idx, profile, data);
 }
 
@@ -281,96 +239,4 @@ bool ProfileManager::CanSystemRegisterUser() const {
     // emulate qlaunch. Update this to dynamically change.
 }
 
-bool ProfileManager::RemoveUser(UUID uuid) {
-    const auto index = GetUserIndex(uuid);
-    if (!index) {
-        return false;
-    }
-
-    profiles[*index] = ProfileInfo{};
-    std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
-    return true;
-}
-
-bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
-    const auto index = GetUserIndex(uuid);
-    if (!index || profile_new.user_uuid == UUID(INVALID_UUID)) {
-        return false;
-    }
-
-    auto& profile = profiles[*index];
-    profile.user_uuid = profile_new.user_uuid;
-    profile.username = profile_new.username;
-    profile.creation_time = profile_new.timestamp;
-
-    return true;
-}
-
-void ProfileManager::ParseUserSaveFile() {
-    FileUtil::IOFile save(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                              ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat",
-                          "rb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "user 'yuzu' with random UUID.");
-        return;
-    }
-
-    ProfileDataRaw data;
-    if (save.ReadBytes(&data, sizeof(ProfileDataRaw)) != sizeof(ProfileDataRaw)) {
-        LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
-                                 "'yuzu' with random UUID.");
-        return;
-    }
-
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        const auto& user = data.users[i];
-
-        if (user.uuid != UUID(INVALID_UUID))
-            AddUser({user.uuid, user.username, user.timestamp, {}, false});
-    }
-
-    std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
-}
-
-void ProfileManager::WriteUserSaveFile() {
-    ProfileDataRaw raw{};
-
-    for (std::size_t i = 0; i < MAX_USERS; ++i) {
-        raw.users[i].username = profiles[i].username;
-        raw.users[i].uuid2 = profiles[i].user_uuid;
-        raw.users[i].uuid = profiles[i].user_uuid;
-        raw.users[i].timestamp = profiles[i].creation_time;
-    }
-
-    const auto raw_path =
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010";
-    if (FileUtil::Exists(raw_path) && !FileUtil::IsDirectory(raw_path))
-        FileUtil::Delete(raw_path);
-
-    const auto path = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
-                      ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat";
-
-    if (!FileUtil::CreateFullPath(path)) {
-        LOG_WARNING(Service_ACC, "Failed to create full path of profiles.dat. Create the directory "
-                                 "nand/system/save/8000000000000010/su/avators to mitigate this "
-                                 "issue.");
-        return;
-    }
-
-    FileUtil::IOFile save(path, "wb");
-
-    if (!save.IsOpen()) {
-        LOG_WARNING(Service_ACC, "Failed to write save data to file... No changes to user data "
-                                 "made in current session will be saved.");
-        return;
-    }
-
-    save.Resize(sizeof(ProfileDataRaw));
-    save.WriteBytes(&raw, sizeof(ProfileDataRaw));
-}
-
 }; // namespace Service::Account

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

@@ -5,8 +5,8 @@
 #pragma once
 
 #include <array>
-#include <optional>
 
+#include "boost/optional.hpp"
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/result.h"
@@ -36,7 +36,7 @@ struct UUID {
     }
 
     // TODO(ogniK): Properly generate uuids based on RFC-4122
-    static UUID Generate();
+    const UUID& Generate();
 
     // Set the UUID to {0,0} to be considered an invalid user
     void Invalidate() {
@@ -45,15 +45,6 @@ struct UUID {
     std::string Format() const {
         return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
     }
-
-    std::string 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]);
-    }
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
@@ -90,19 +81,18 @@ static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
 /// objects
 class ProfileManager {
 public:
-    ProfileManager();
+    ProfileManager(); // TODO(ogniK): Load from system save
     ~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;
-    std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
-    bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
+    boost::optional<std::size_t> GetUserIndex(const UUID& uuid) const;
+    boost::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
+    bool GetProfileBase(boost::optional<std::size_t> index, ProfileBase& profile) const;
     bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
     bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
-    bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
+    bool GetProfileBaseAndData(boost::optional<std::size_t> index, ProfileBase& profile,
                                ProfileData& data) const;
     bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
     bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
@@ -110,7 +100,6 @@ public:
     std::size_t GetUserCount() const;
     std::size_t GetOpenUserCount() const;
     bool UserExists(UUID uuid) const;
-    bool UserExistsIndex(std::size_t index) const;
     void OpenUser(UUID uuid);
     void CloseUser(UUID uuid);
     UserIDArray GetOpenUsers() const;
@@ -119,17 +108,11 @@ public:
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(UUID uuid);
-    bool SetProfileBase(UUID uuid, const ProfileBase& profile_new);
-
 private:
-    void ParseUserSaveFile();
-    void WriteUserSaveFile();
-    std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
-    bool RemoveProfileAtIndex(std::size_t index);
-
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count = 0;
+    boost::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
+    bool RemoveProfileAtIndex(std::size_t index);
     UUID last_opened_user{INVALID_UUID};
 };
 

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

@@ -4,13 +4,11 @@
 
 #include <array>
 #include <cinttypes>
-#include <cstring>
 #include <stack>
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
@@ -28,16 +26,6 @@
 
 namespace Service::AM {
 
-constexpr u32 POP_LAUNCH_PARAMETER_MAGIC = 0xC79497CA;
-
-struct LaunchParameters {
-    u32_le magic;
-    u32_le is_account_selected;
-    u128 current_user;
-    INSERT_PADDING_BYTES(0x70);
-};
-static_assert(sizeof(LaunchParameters) == 0x88);
-
 IWindowController::IWindowController() : ServiceFramework("IWindowController") {
     // clang-format off
     static const FunctionInfo functions[] = {
@@ -736,23 +724,20 @@ void IApplicationFunctions::EndBlockingHomeButton(Kernel::HLERequestContext& ctx
 }
 
 void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
-    LaunchParameters params{};
+    constexpr std::array<u8, 0x88> data{{
+        0xca, 0x97, 0x94, 0xc7, // Magic
+        1,    0,    0,    0,    // IsAccountSelected (bool)
+        1,    0,    0,    0,    // User Id (word 0)
+        0,    0,    0,    0,    // User Id (word 1)
+        0,    0,    0,    0,    // User Id (word 2)
+        0,    0,    0,    0     // User Id (word 3)
+    }};
 
-    params.magic = POP_LAUNCH_PARAMETER_MAGIC;
-    params.is_account_selected = 1;
-
-    Account::ProfileManager profile_manager{};
-    const auto uuid = profile_manager.GetUser(Settings::values.current_user);
-    ASSERT(uuid != std::nullopt);
-    params.current_user = uuid->uuid;
+    std::vector<u8> buffer(data.begin(), data.end());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
     rb.Push(RESULT_SUCCESS);
-
-    std::vector<u8> buffer(sizeof(LaunchParameters));
-    std::memcpy(buffer.data(), &params, buffer.size());
-
     rb.PushIpcInterface<AM::IStorage>(buffer);
 
     LOG_DEBUG(Service_AM, "called");

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

@@ -24,8 +24,8 @@ namespace Service::AOC {
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 constexpr u64 DLC_BASE_TO_AOC_ID = 0x1000;
 
-static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
-    return (title_id & DLC_BASE_TITLE_ID_MASK) == base;
+static bool CheckAOCTitleIDMatchesBase(u64 base, u64 aoc) {
+    return (aoc & DLC_BASE_TITLE_ID_MASK) == base;
 }
 
 static std::vector<u64> AccumulateAOCTitleIDs() {
@@ -74,7 +74,7 @@ void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
     const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
     rb.Push<u32>(static_cast<u32>(
         std::count_if(add_on_content.begin(), add_on_content.end(),
-                      [current](u64 tid) { return CheckAOCTitleIDMatchesBase(tid, current); })));
+                      [&current](u64 tid) { return (tid & DLC_BASE_TITLE_ID_MASK) == current; })));
 }
 
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {

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

@@ -17,7 +17,6 @@
 #include "core/file_sys/errors.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
@@ -273,8 +272,8 @@ public:
             {0, &IFileSystem::CreateFile, "CreateFile"},
             {1, &IFileSystem::DeleteFile, "DeleteFile"},
             {2, &IFileSystem::CreateDirectory, "CreateDirectory"},
-            {3, &IFileSystem::DeleteDirectory, "DeleteDirectory"},
-            {4, &IFileSystem::DeleteDirectoryRecursively, "DeleteDirectoryRecursively"},
+            {3, nullptr, "DeleteDirectory"},
+            {4, nullptr, "DeleteDirectoryRecursively"},
             {5, &IFileSystem::RenameFile, "RenameFile"},
             {6, nullptr, "RenameDirectory"},
             {7, &IFileSystem::GetEntryType, "GetEntryType"},
@@ -329,30 +328,6 @@ public:
         rb.Push(backend.CreateDirectory(name));
     }
 
-    void DeleteDirectory(Kernel::HLERequestContext& ctx) {
-        const IPC::RequestParser rp{ctx};
-
-        const auto file_buffer = ctx.ReadBuffer();
-        std::string name = Common::StringFromBuffer(file_buffer);
-
-        LOG_DEBUG(Service_FS, "called directory {}", name);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(backend.DeleteDirectory(name));
-    }
-
-    void DeleteDirectoryRecursively(Kernel::HLERequestContext& ctx) {
-        const IPC::RequestParser rp{ctx};
-
-        const auto file_buffer = ctx.ReadBuffer();
-        std::string name = Common::StringFromBuffer(file_buffer);
-
-        LOG_DEBUG(Service_FS, "called directory {}", name);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(backend.DeleteDirectoryRecursively(name));
-    }
-
     void RenameFile(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -655,7 +630,6 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
               static_cast<u8>(storage_id), unknown, title_id);
 
     auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
-
     if (data.Failed()) {
         // TODO(DarkLordZach): Find the right error code to use here
         LOG_ERROR(Service_FS,
@@ -666,9 +640,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    FileSys::PatchManager pm{title_id};
-
-    IStorage storage(pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data));
+    IStorage storage(std::move(data.Unwrap()));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);

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

@@ -108,10 +108,9 @@ void Controller_NPad::OnInit() {
     styleset_changed_event =
         Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
 
-    if (!IsControllerActivated()) {
+    if (!IsControllerActivated())
         return;
-    }
-
+    std::size_t controller{};
     if (style.raw == 0) {
         // We want to support all controllers
         style.handheld.Assign(1);

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

@@ -3,13 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <memory>
-#include <fmt/format.h>
 
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/service/ldr/ldr.h"
 #include "core/hle/service/service.h"
-#include "core/loader/nro.h"
 
 namespace Service::LDR {
 
@@ -63,58 +59,16 @@ public:
     explicit RelocatableObject() : ServiceFramework{"ldr:ro"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &RelocatableObject::LoadNro, "LoadNro"},
+            {0, nullptr, "LoadNro"},
             {1, nullptr, "UnloadNro"},
-            {2, &RelocatableObject::LoadNrr, "LoadNrr"},
+            {2, nullptr, "LoadNrr"},
             {3, nullptr, "UnloadNrr"},
-            {4, &RelocatableObject::Initialize, "Initialize"},
+            {4, nullptr, "Initialize"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
-
-    void LoadNrr(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
-    }
-
-    void LoadNro(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        rp.Skip(2, false);
-        const VAddr nro_addr{rp.Pop<VAddr>()};
-        const u64 nro_size{rp.Pop<u64>()};
-        const VAddr bss_addr{rp.Pop<VAddr>()};
-        const u64 bss_size{rp.Pop<u64>()};
-
-        // Read NRO data from memory
-        std::vector<u8> nro_data(nro_size);
-        Memory::ReadBlock(nro_addr, nro_data.data(), nro_size);
-
-        // Load NRO as new executable module
-        const VAddr addr{*Core::CurrentProcess()->VMManager().FindFreeRegion(nro_size + bss_size)};
-        Loader::AppLoader_NRO::LoadNro(nro_data, fmt::format("nro-{:08x}", addr), addr);
-
-        // TODO(bunnei): This is an incomplete implementation. It was tested with Super Mario Party.
-        // It is currently missing:
-        // - Signature checks with LoadNRR
-        // - Checking if a module has already been loaded
-        // - Using/validating BSS, etc. params (these are used from NRO header instead)
-        // - Error checking
-        // - ...Probably other things
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(addr);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
-    }
-
-    void Initialize(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_LDR, "(STUBBED) called");
-    }
 };
 
 void InstallInterfaces(SM::ServiceManager& sm) {

src/core/hle/service/nfc/nfc.cpp

@@ -10,13 +10,12 @@
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/settings.h"
 
 namespace Service::NFC {
 
 class IAm final : public ServiceFramework<IAm> {
 public:
-    explicit IAm() : ServiceFramework{"NFC::IAm"} {
+    explicit IAm() : ServiceFramework{"IAm"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "Initialize"},
@@ -53,7 +52,7 @@ private:
 
 class MFIUser final : public ServiceFramework<MFIUser> {
 public:
-    explicit MFIUser() : ServiceFramework{"NFC::MFIUser"} {
+    explicit MFIUser() : ServiceFramework{"IUser"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "Initialize"},
@@ -101,13 +100,13 @@ private:
 
 class IUser final : public ServiceFramework<IUser> {
 public:
-    explicit IUser() : ServiceFramework{"NFC::IUser"} {
+    explicit IUser() : ServiceFramework{"IUser"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &IUser::InitializeOld, "InitializeOld"},
-            {1, &IUser::FinalizeOld, "FinalizeOld"},
-            {2, &IUser::GetStateOld, "GetStateOld"},
-            {3, &IUser::IsNfcEnabledOld, "IsNfcEnabledOld"},
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "GetState"},
+            {3, nullptr, "IsNfcEnabled"},
             {400, nullptr, "Initialize"},
             {401, nullptr, "Finalize"},
             {402, nullptr, "GetState"},
@@ -131,47 +130,11 @@ public:
 
         RegisterHandlers(functions);
     }
-
-private:
-    enum class NfcStates : u32 {
-        Finalized = 6,
-    };
-
-    void InitializeOld(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0};
-        rb.Push(RESULT_SUCCESS);
-
-        // We don't deal with hardware initialization so we can just stub this.
-        LOG_DEBUG(Service_NFC, "called");
-    }
-
-    void IsNfcEnabledOld(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u8>(Settings::values.enable_nfc);
-
-        LOG_DEBUG(Service_NFC, "IsNfcEnabledOld");
-    }
-
-    void GetStateOld(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFC, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushEnum(NfcStates::Finalized); // TODO(ogniK): Figure out if this matches nfp
-    }
-
-    void FinalizeOld(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFC, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
 };
 
 class NFC_U final : public ServiceFramework<NFC_U> {
 public:
-    explicit NFC_U() : ServiceFramework{"nfc:user"} {
+    explicit NFC_U() : ServiceFramework{"nfc:u"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &NFC_U::CreateUserInterface, "CreateUserInterface"},

src/core/hle/service/nfp/nfp.cpp

@@ -2,67 +2,56 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <atomic>
-
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
-#include "core/hle/lock.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
 
 namespace Service::NFP {
 
-namespace ErrCodes {
-constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
-                                    -1); // TODO(ogniK): Find the actual error code
-}
-
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    nfc_tag_load =
-        Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected");
-}
+    : ServiceFramework(name), module(std::move(module)) {}
 
 Module::Interface::~Interface() = default;
 
 class IUser final : public ServiceFramework<IUser> {
 public:
-    IUser(Module::Interface& nfp_interface)
-        : ServiceFramework("NFP::IUser"), nfp_interface(nfp_interface) {
+    IUser() : ServiceFramework("IUser") {
         static const FunctionInfo functions[] = {
             {0, &IUser::Initialize, "Initialize"},
-            {1, &IUser::Finalize, "Finalize"},
+            {1, nullptr, "Finalize"},
             {2, &IUser::ListDevices, "ListDevices"},
-            {3, &IUser::StartDetection, "StartDetection"},
-            {4, &IUser::StopDetection, "StopDetection"},
-            {5, &IUser::Mount, "Mount"},
-            {6, &IUser::Unmount, "Unmount"},
-            {7, &IUser::OpenApplicationArea, "OpenApplicationArea"},
-            {8, &IUser::GetApplicationArea, "GetApplicationArea"},
+            {3, nullptr, "StartDetection"},
+            {4, nullptr, "StopDetection"},
+            {5, nullptr, "Mount"},
+            {6, nullptr, "Unmount"},
+            {7, nullptr, "OpenApplicationArea"},
+            {8, nullptr, "GetApplicationArea"},
             {9, nullptr, "SetApplicationArea"},
             {10, nullptr, "Flush"},
             {11, nullptr, "Restore"},
             {12, nullptr, "CreateApplicationArea"},
-            {13, &IUser::GetTagInfo, "GetTagInfo"},
-            {14, &IUser::GetRegisterInfo, "GetRegisterInfo"},
-            {15, &IUser::GetCommonInfo, "GetCommonInfo"},
-            {16, &IUser::GetModelInfo, "GetModelInfo"},
+            {13, nullptr, "GetTagInfo"},
+            {14, nullptr, "GetRegisterInfo"},
+            {15, nullptr, "GetCommonInfo"},
+            {16, nullptr, "GetModelInfo"},
             {17, &IUser::AttachActivateEvent, "AttachActivateEvent"},
             {18, &IUser::AttachDeactivateEvent, "AttachDeactivateEvent"},
             {19, &IUser::GetState, "GetState"},
             {20, &IUser::GetDeviceState, "GetDeviceState"},
             {21, &IUser::GetNpadId, "GetNpadId"},
-            {22, &IUser::GetApplicationAreaSize, "GetApplicationAreaSize"},
+            {22, nullptr, "GetApplicationArea2"},
             {23, &IUser::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},
             {24, nullptr, "RecreateApplicationArea"},
         };
         RegisterHandlers(functions);
 
         auto& kernel = Core::System::GetInstance().Kernel();
+        activate_event =
+            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:ActivateEvent");
         deactivate_event =
             Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
         availability_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
@@ -70,17 +59,6 @@ public:
     }
 
 private:
-    struct TagInfo {
-        std::array<u8, 10> uuid;
-        u8 uuid_length; // TODO(ogniK): Figure out if this is actual the uuid length or does it
-                        // mean something else
-        INSERT_PADDING_BYTES(0x15);
-        u32_le protocol;
-        u32_le tag_type;
-        INSERT_PADDING_BYTES(0x2c);
-    };
-    static_assert(sizeof(TagInfo) == 0x54, "TagInfo is an invalid size");
-
     enum class State : u32 {
         NonInitialized = 0,
         Initialized = 1,
@@ -88,40 +66,15 @@ private:
 
     enum class DeviceState : u32 {
         Initialized = 0,
-        SearchingForTag = 1,
-        TagFound = 2,
-        TagRemoved = 3,
-        TagNearby = 4,
-        Unknown5 = 5,
-        Finalized = 6
     };
 
-    struct CommonInfo {
-        u16_be last_write_year;
-        u8 last_write_month;
-        u8 last_write_day;
-        u16_be write_counter;
-        u16_be version;
-        u32_be application_area_size;
-        INSERT_PADDING_BYTES(0x34);
-    };
-    static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");
-
     void Initialize(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0};
-        rb.Push(RESULT_SUCCESS);
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
 
         state = State::Initialized;
 
-        LOG_DEBUG(Service_NFC, "called");
-    }
-
-    void GetState(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3, 0};
+        IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u32>(static_cast<u32>(state));
-
-        LOG_DEBUG(Service_NFC, "called");
     }
 
     void ListDevices(Kernel::HLERequestContext& ctx) {
@@ -130,219 +83,80 @@ private:
 
         ctx.WriteBuffer(&device_handle, sizeof(device_handle));
 
-        LOG_DEBUG(Service_NFP, "called, array_size={}", array_size);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, array_size={}", array_size);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(1);
-    }
-
-    void GetNpadId(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 dev_handle = rp.Pop<u64>();
-        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(npad_id);
+        rb.Push<u32>(0);
     }
 
     void AttachActivateEvent(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const u64 dev_handle = rp.Pop<u64>();
-        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(nfp_interface.GetNFCEvent());
-        has_attached_handle = true;
+        rb.PushCopyObjects(activate_event);
     }
 
     void AttachDeactivateEvent(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const u64 dev_handle = rp.Pop<u64>();
-        LOG_DEBUG(Service_NFP, "called, dev_handle=0x{:X}", dev_handle);
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(deactivate_event);
     }
 
-    void StopDetection(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-        switch (device_state) {
-        case DeviceState::TagFound:
-        case DeviceState::TagNearby:
-            deactivate_event->Signal();
-            device_state = DeviceState::Initialized;
-            break;
-        case DeviceState::SearchingForTag:
-        case DeviceState::TagRemoved:
-            device_state = DeviceState::Initialized;
-            break;
-        }
-        IPC::ResponseBuilder rb{ctx, 2};
+    void GetState(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(static_cast<u32>(state));
     }
 
     void GetDeviceState(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-        auto nfc_event = nfp_interface.GetNFCEvent();
-        if (!nfc_event->ShouldWait(Kernel::GetCurrentThread()) && !has_attached_handle) {
-            device_state = DeviceState::TagFound;
-            nfc_event->Clear();
-        }
-
+        LOG_WARNING(Service_NFP, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(static_cast<u32>(device_state));
     }
 
-    void StartDetection(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        if (device_state == DeviceState::Initialized || device_state == DeviceState::TagRemoved) {
-            device_state = DeviceState::SearchingForTag;
-        }
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetTagInfo(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        auto amiibo = nfp_interface.GetAmiiboBuffer();
-        TagInfo tag_info{};
-        std::memcpy(tag_info.uuid.data(), amiibo.uuid.data(), sizeof(tag_info.uuid.size()));
-        tag_info.uuid_length = static_cast<u8>(tag_info.uuid.size());
-
-        tag_info.protocol = 1; // TODO(ogniK): Figure out actual values
-        tag_info.tag_type = 2;
-        ctx.WriteBuffer(&tag_info, sizeof(TagInfo));
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Mount(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        device_state = DeviceState::TagNearby;
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetModelInfo(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        auto amiibo = nfp_interface.GetAmiiboBuffer();
-        ctx.WriteBuffer(&amiibo.model_info, sizeof(amiibo.model_info));
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Unmount(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        device_state = DeviceState::TagFound;
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Finalize(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-
-        device_state = DeviceState::Finalized;
-
-        IPC::ResponseBuilder rb{ctx, 2};
+    void GetNpadId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u64 dev_handle = rp.Pop<u64>();
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
+        IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(npad_id);
     }
 
     void AttachAvailabilityChangeEvent(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
+        const u64 dev_handle = rp.Pop<u64>();
+        LOG_WARNING(Service_NFP, "(STUBBED) called, dev_handle=0x{:X}", dev_handle);
 
         IPC::ResponseBuilder rb{ctx, 2, 1};
         rb.Push(RESULT_SUCCESS);
         rb.PushCopyObjects(availability_change_event);
     }
 
-    void GetRegisterInfo(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
-
-        // TODO(ogniK): Pull Mii and owner data from amiibo
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetCommonInfo(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
-
-        // TODO(ogniK): Pull common information from amiibo
-
-        CommonInfo common_info{};
-        common_info.application_area_size = 0;
-        ctx.WriteBuffer(&common_info, sizeof(CommonInfo));
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void OpenApplicationArea(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_NFP, "called");
-        // We don't need to worry about this since we can just open the file
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetApplicationAreaSize(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
-        // We don't need to worry about this since we can just open the file
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u32>(0); // This is from the GetCommonInfo stub
-    }
-
-    void GetApplicationArea(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NFP, "(STUBBED) called");
-
-        // TODO(ogniK): Pull application area from amiibo
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u32>(0); // This is from the GetCommonInfo stub
-    }
-
-    bool has_attached_handle{};
-    const u64 device_handle{Common::MakeMagic('Y', 'U', 'Z', 'U')};
-    const u32 npad_id{0}; // Player 1 controller
+    const u64 device_handle{0xDEAD};
+    const u32 npad_id{0}; // This is the first player controller id
     State state{State::NonInitialized};
     DeviceState device_state{DeviceState::Initialized};
+    Kernel::SharedPtr<Kernel::Event> activate_event;
     Kernel::SharedPtr<Kernel::Event> deactivate_event;
     Kernel::SharedPtr<Kernel::Event> availability_change_event;
-    const Module::Interface& nfp_interface;
 };
 
 void Module::Interface::CreateUserInterface(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_NFP, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IUser>(*this);
-}
-
-bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-    if (buffer.size() < sizeof(AmiiboFile)) {
-        return false;
-    }
-
-    std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
-    nfc_tag_load->Signal();
-    return true;
-}
-const Kernel::SharedPtr<Kernel::Event>& Module::Interface::GetNFCEvent() const {
-    return nfc_tag_load;
-}
-const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const {
-    return amiibo;
+    rb.PushIpcInterface<IUser>();
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {

src/core/hle/service/nfp/nfp.h

@@ -4,9 +4,6 @@
 
 #pragma once
 
-#include <array>
-#include <vector>
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/service.h"
 
 namespace Service::NFP {
@@ -18,27 +15,7 @@ public:
         explicit Interface(std::shared_ptr<Module> module, const char* name);
         ~Interface() override;
 
-        struct ModelInfo {
-            std::array<u8, 0x8> amiibo_identification_block;
-            INSERT_PADDING_BYTES(0x38);
-        };
-        static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
-
-        struct AmiiboFile {
-            std::array<u8, 10> uuid;
-            INSERT_PADDING_BYTES(0x4a);
-            ModelInfo model_info;
-        };
-        static_assert(sizeof(AmiiboFile) == 0x94, "AmiiboFile is an invalid size");
-
         void CreateUserInterface(Kernel::HLERequestContext& ctx);
-        bool LoadAmiibo(const std::vector<u8>& buffer);
-        const Kernel::SharedPtr<Kernel::Event>& GetNFCEvent() const;
-        const AmiiboFile& GetAmiiboBuffer() const;
-
-    private:
-        Kernel::SharedPtr<Kernel::Event> nfc_tag_load{};
-        AmiiboFile amiibo{};
 
     protected:
         std::shared_ptr<Module> module;

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

@@ -67,15 +67,15 @@ public:
     explicit IClientEpSession() : ServiceFramework{"IClientEpSession"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Open"},
-            {1, nullptr, "Close"},
-            {2, nullptr, "Unknown1"},
-            {3, nullptr, "Populate"},
+            {0, nullptr, "Unknown1"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
             {4, nullptr, "PostBufferAsync"},
-            {5, nullptr, "GetXferReport"},
-            {6, nullptr, "Unknown2"},
-            {7, nullptr, "Unknown3"},
-            {8, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
+            {6, nullptr, "Unknown6"},
+            {7, nullptr, "Unknown7"},
+            {8, nullptr, "Unknown8"},
         };
         // clang-format on
 
@@ -89,15 +89,15 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "Unknown1"},
-            {1, nullptr, "SetInterface"},
-            {2, nullptr, "GetInterface"},
-            {3, nullptr, "GetAlternateInterface"},
-            {4, nullptr, "GetCurrentFrame"},
+            {1, nullptr, "Unknown2"},
+            {2, nullptr, "Unknown3"},
+            {3, nullptr, "Unknown4"},
+            {4, nullptr, "Unknown5"},
             {5, nullptr, "CtrlXferAsync"},
-            {6, nullptr, "Unknown2"},
+            {6, nullptr, "Unknown6"},
             {7, nullptr, "GetCtrlXferReport"},
-            {8, nullptr, "ResetDevice"},
-            {9, nullptr, "OpenUsbEp"},
+            {8, nullptr, "Unknown7"},
+            {9, nullptr, "GetClientEpSession"},
         };
         // clang-format on
 
@@ -111,14 +111,13 @@ public:
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "BindClientProcess"},
-            {1, nullptr, "QueryAllInterfaces"},
-            {2, nullptr, "QueryAvailableInterfaces"},
-            {3, nullptr, "QueryAcquiredInterfaces"},
-            {4, nullptr, "CreateInterfaceAvailableEvent"},
-            {5, nullptr, "DestroyInterfaceAvailableEvent"},
+            {1, nullptr, "Unknown1"},
+            {2, nullptr, "Unknown2"},
+            {3, nullptr, "Unknown3"},
+            {4, nullptr, "Unknown4"},
+            {5, nullptr, "Unknown5"},
             {6, nullptr, "GetInterfaceStateChangeEvent"},
-            {7, nullptr, "AcquireUsbIf"},
-            {8, nullptr, "Unknown1"},
+            {7, nullptr, "GetClientIfSession"},
         };
         // clang-format on
 

src/core/loader/nro.cpp

@@ -127,23 +127,18 @@ static constexpr u32 PageAlignSize(u32 size) {
     return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
 }
 
-/*static*/ bool AppLoader_NRO::LoadNro(const std::vector<u8>& data, const std::string& name,
-                                       VAddr load_base) {
-
-    if (data.size() < sizeof(NroHeader)) {
-        return {};
-    }
-
+bool AppLoader_NRO::LoadNro(const FileSys::VfsFile& file, VAddr load_base) {
     // Read NSO header
     NroHeader nro_header{};
-    std::memcpy(&nro_header, data.data(), sizeof(NroHeader));
+    if (sizeof(NroHeader) != file.ReadObject(&nro_header)) {
+        return {};
+    }
     if (nro_header.magic != Common::MakeMagic('N', 'R', 'O', '0')) {
         return {};
     }
 
     // Build program image
-    std::vector<u8> program_image(PageAlignSize(nro_header.file_size));
-    std::memcpy(program_image.data(), data.data(), program_image.size());
+    std::vector<u8> program_image = file.ReadBytes(PageAlignSize(nro_header.file_size));
     if (program_image.size() != PageAlignSize(nro_header.file_size)) {
         return {};
     }
@@ -187,15 +182,11 @@ static constexpr u32 PageAlignSize(u32 size) {
     Core::CurrentProcess()->LoadModule(std::move(codeset), load_base);
 
     // Register module with GDBStub
-    GDBStub::RegisterModule(name, load_base, load_base);
+    GDBStub::RegisterModule(file.GetName(), load_base, load_base);
 
     return true;
 }
 
-bool AppLoader_NRO::LoadNro(const FileSys::VfsFile& file, VAddr load_base) {
-    return AppLoader_NRO::LoadNro(file.ReadAllBytes(), file.GetName(), load_base);
-}
-
 ResultStatus AppLoader_NRO::Load(Kernel::Process& process) {
     if (is_loaded) {
         return ResultStatus::ErrorAlreadyLoaded;

src/core/loader/nro.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-#include <vector>
 #include "common/common_types.h"
 #include "core/loader/linker.h"
 #include "core/loader/loader.h"
@@ -41,8 +40,6 @@ public:
     ResultStatus ReadTitle(std::string& title) override;
     bool IsRomFSUpdatable() const override;
 
-    static bool LoadNro(const std::vector<u8>& data, const std::string& name, VAddr load_base);
-
 private:
     bool LoadNro(const FileSys::VfsFile& file, VAddr load_base);
 

src/core/loader/nsp.cpp

@@ -36,16 +36,6 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file)
 
     std::tie(nacp_file, icon_file) =
         FileSys::PatchManager(nsp->GetProgramTitleID()).ParseControlNCA(*control_nca);
-
-    if (nsp->IsExtractedType()) {
-        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
-    } else {
-        if (title_id == 0)
-            return;
-
-        secondary_loader = std::make_unique<AppLoader_NCA>(
-            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
-    }
 }
 
 AppLoader_NSP::~AppLoader_NSP() = default;
@@ -77,19 +67,26 @@ ResultStatus AppLoader_NSP::Load(Kernel::Process& process) {
         return ResultStatus::ErrorAlreadyLoaded;
     }
 
-    if (title_id == 0)
-        return ResultStatus::ErrorNSPMissingProgramNCA;
+    if (nsp->IsExtractedType()) {
+        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
+    } else {
+        if (title_id == 0)
+            return ResultStatus::ErrorNSPMissingProgramNCA;
 
-    if (nsp->GetStatus() != ResultStatus::Success)
-        return nsp->GetStatus();
+        secondary_loader = std::make_unique<AppLoader_NCA>(
+            nsp->GetNCAFile(title_id, FileSys::ContentRecordType::Program));
 
-    if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
-        return nsp->GetProgramStatus(title_id);
+        if (nsp->GetStatus() != ResultStatus::Success)
+            return nsp->GetStatus();
 
-    if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
-        if (!Core::Crypto::KeyManager::KeyFileExists(false))
-            return ResultStatus::ErrorMissingProductionKeyFile;
-        return ResultStatus::ErrorNSPMissingProgramNCA;
+        if (nsp->GetProgramStatus(title_id) != ResultStatus::Success)
+            return nsp->GetProgramStatus(title_id);
+
+        if (nsp->GetNCA(title_id, FileSys::ContentRecordType::Program) == nullptr) {
+            if (!Core::Crypto::KeyManager::KeyFileExists(false))
+                return ResultStatus::ErrorMissingProductionKeyFile;
+            return ResultStatus::ErrorNSPMissingProgramNCA;
+        }
     }
 
     const auto result = secondary_loader->Load(process);

src/core/perf_stats.cpp

@@ -74,6 +74,10 @@ double PerfStats::GetLastFrameTimeScale() {
 }
 
 void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
+    // Max lag caused by slow frames. Can be adjusted to compensate for too many slow frames. Higher
+    // values increase the time needed to recover and limit framerate again after spikes.
+    constexpr microseconds MAX_LAG_TIME_US = 25000us;
+
     if (!Settings::values.use_frame_limit) {
         return;
     }

src/core/settings.h

@@ -113,8 +113,7 @@ static const std::array<const char*, NumAnalogs> mapping = {{
 struct Values {
     // System
     bool use_docked_mode;
-    bool enable_nfc;
-    int current_user;
+    std::string username;
     int language_index;
 
     // Controls

src/video_core/engines/maxwell_3d.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <cinttypes>
-#include <cstring>
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/core_timing.h"
@@ -20,24 +19,7 @@ namespace Tegra::Engines {
 constexpr u32 MacroRegistersStart = 0xE00;
 
 Maxwell3D::Maxwell3D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
-    : memory_manager(memory_manager), rasterizer{rasterizer}, macro_interpreter(*this) {
-    InitializeRegisterDefaults();
-}
-
-void Maxwell3D::InitializeRegisterDefaults() {
-    // Initializes registers to their default values - what games expect them to be at boot. This is
-    // for certain registers that may not be explicitly set by games.
-
-    // Reset all registers to zero
-    std::memset(&regs, 0, sizeof(regs));
-
-    // Depth range near/far is not always set, but is expected to be the default 0.0f, 1.0f. This is
-    // needed for ARMS.
-    for (std::size_t viewport{}; viewport < Regs::NumViewports; ++viewport) {
-        regs.viewport[viewport].depth_range_near = 0.0f;
-        regs.viewport[viewport].depth_range_far = 1.0f;
-    }
-}
+    : memory_manager(memory_manager), rasterizer{rasterizer}, macro_interpreter(*this) {}
 
 void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
     // Reset the current macro.
@@ -173,6 +155,7 @@ void Maxwell3D::ProcessQueryGet() {
     ASSERT_MSG(regs.query.query_get.unit == Regs::QueryUnit::Crop,
                "Units other than CROP are unimplemented");
 
+    u32 value = Memory::Read32(*address);
     u64 result = 0;
 
     // TODO(Subv): Support the other query variables

src/video_core/engines/maxwell_3d.h

@@ -723,11 +723,7 @@ public:
                 StencilOp stencil_back_op_zpass;
                 ComparisonOp stencil_back_func_func;
 
-                INSERT_PADDING_WORDS(0x4);
-
-                u32 framebuffer_srgb;
-
-                INSERT_PADDING_WORDS(0x12);
+                INSERT_PADDING_WORDS(0x17);
 
                 union {
                     BitField<2, 1, u32> coord_origin;
@@ -755,14 +751,7 @@ public:
                     };
                 } draw;
 
-                INSERT_PADDING_WORDS(0xA);
-
-                struct {
-                    u32 enabled;
-                    u32 index;
-                } primitive_restart;
-
-                INSERT_PADDING_WORDS(0x5F);
+                INSERT_PADDING_WORDS(0x6B);
 
                 struct {
                     u32 start_addr_high;
@@ -995,8 +984,6 @@ public:
     Texture::FullTextureInfo GetStageTexture(Regs::ShaderStage stage, std::size_t offset) const;
 
 private:
-    void InitializeRegisterDefaults();
-
     VideoCore::RasterizerInterface& rasterizer;
 
     std::unordered_map<u32, std::vector<u32>> uploaded_macros;
@@ -1090,11 +1077,9 @@ ASSERT_REG_POSITION(stencil_back_op_fail, 0x566);
 ASSERT_REG_POSITION(stencil_back_op_zfail, 0x567);
 ASSERT_REG_POSITION(stencil_back_op_zpass, 0x568);
 ASSERT_REG_POSITION(stencil_back_func_func, 0x569);
-ASSERT_REG_POSITION(framebuffer_srgb, 0x56E);
 ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
-ASSERT_REG_POSITION(primitive_restart, 0x591);
 ASSERT_REG_POSITION(index_array, 0x5F2);
 ASSERT_REG_POSITION(instanced_arrays, 0x620);
 ASSERT_REG_POSITION(cull, 0x646);

src/video_core/engines/shader_bytecode.h

@@ -79,7 +79,6 @@ union Attribute {
     constexpr explicit Attribute(u64 value) : value(value) {}
 
     enum class Index : u64 {
-        PointSize = 6,
         Position = 7,
         Attribute_0 = 8,
         Attribute_31 = 39,
@@ -208,16 +207,6 @@ enum class UniformType : u64 {
     Double = 5,
 };
 
-enum class StoreType : u64 {
-    Unsigned8 = 0,
-    Signed8 = 1,
-    Unsigned16 = 2,
-    Signed16 = 3,
-    Bytes32 = 4,
-    Bytes64 = 5,
-    Bytes128 = 6,
-};
-
 enum class IMinMaxExchange : u64 {
     None = 0,
     XLo = 1,
@@ -757,18 +746,6 @@ union Instruction {
         BitField<44, 2, u64> unknown;
     } ld_c;
 
-    union {
-        BitField<48, 3, StoreType> type;
-    } ldst_sl;
-
-    union {
-        BitField<44, 2, u64> unknown;
-    } ld_l;
-
-    union {
-        BitField<44, 2, u64> unknown;
-    } st_l;
-
     union {
         BitField<0, 3, u64> pred0;
         BitField<3, 3, u64> pred3;
@@ -1231,7 +1208,6 @@ union Instruction {
     BitField<61, 1, u64> is_b_imm;
     BitField<60, 1, u64> is_b_gpr;
     BitField<59, 1, u64> is_c_gpr;
-    BitField<20, 24, s64> smem_imm;
 
     Attribute attribute;
     Sampler sampler;
@@ -1255,12 +1231,8 @@ public:
         BRA,
         PBK,
         LD_A,
-        LD_L,
-        LD_S,
         LD_C,
         ST_A,
-        ST_L,
-        ST_S,
         LDG, // Load from global memory
         STG, // Store in global memory
         TEX,
@@ -1517,12 +1489,8 @@ private:
             INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
             INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
             INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
-            INST("1110111101001---", Id::LD_S, Type::Memory, "LD_S"),
-            INST("1110111101000---", Id::LD_L, Type::Memory, "LD_L"),
             INST("1110111110010---", Id::LD_C, Type::Memory, "LD_C"),
             INST("1110111111110---", Id::ST_A, Type::Memory, "ST_A"),
-            INST("1110111101011---", Id::ST_S, Type::Memory, "ST_S"),
-            INST("1110111101010---", Id::ST_L, Type::Memory, "ST_L"),
             INST("1110111011010---", Id::LDG, Type::Memory, "LDG"),
             INST("1110111011011---", Id::STG, Type::Memory, "STG"),
             INST("110000----111---", Id::TEX, Type::Memory, "TEX"),

src/video_core/engines/shader_header.h

@@ -96,11 +96,6 @@ struct Header {
             }
         } ps;
     };
-
-    u64 GetLocalMemorySize() {
-        return (common1.shader_local_memory_low_size |
-                (common2.shader_local_memory_high_size << 24));
-    }
 };
 
 static_assert(sizeof(Header) == 0x50, "Incorrect structure size");

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -418,7 +418,6 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
     // Bind the framebuffer surfaces
     state.draw.draw_framebuffer = framebuffer.handle;
     state.Apply();
-    state.framebuffer_srgb.enabled = regs.framebuffer_srgb != 0;
 
     if (using_color_fb) {
         if (single_color_target) {
@@ -430,9 +429,6 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
                 // Assume that a surface will be written to if it is used as a framebuffer, even if
                 // the shader doesn't actually write to it.
                 color_surface->MarkAsModified(true, res_cache);
-                // Workaround for and issue in nvidia drivers
-                // https://devtalk.nvidia.com/default/topic/776591/opengl/gl_framebuffer_srgb-functions-incorrectly/
-                state.framebuffer_srgb.enabled |= color_surface->GetSurfaceParams().srgb_conversion;
             }
 
             glFramebufferTexture2D(
@@ -450,11 +446,6 @@ void RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb, bool using_dep
                     // Assume that a surface will be written to if it is used as a framebuffer, even
                     // if the shader doesn't actually write to it.
                     color_surface->MarkAsModified(true, res_cache);
-                    // Enable sRGB only for supported formats
-                    // Workaround for and issue in nvidia drivers
-                    // https://devtalk.nvidia.com/default/topic/776591/opengl/gl_framebuffer_srgb-functions-incorrectly/
-                    state.framebuffer_srgb.enabled |=
-                        color_surface->GetSurfaceParams().srgb_conversion;
                 }
 
                 buffers[index] = GL_COLOR_ATTACHMENT0 + regs.rt_control.GetMap(index);
@@ -546,9 +537,7 @@ void RasterizerOpenGL::Clear() {
 
     ConfigureFramebuffers(use_color, use_depth || use_stencil, false,
                           regs.clear_buffers.RT.Value());
-    // Copy the sRGB setting to the clear state to avoid problem with
-    // specific driver implementations
-    clear_state.framebuffer_srgb.enabled = state.framebuffer_srgb.enabled;
+
     clear_state.Apply();
 
     if (use_color) {
@@ -581,8 +570,6 @@ void RasterizerOpenGL::DrawArrays() {
     SyncBlendState();
     SyncLogicOpState();
     SyncCullMode();
-    SyncPrimitiveRestart();
-    SyncDepthRange();
     SyncScissorTest();
     // Alpha Testing is synced on shaders.
     SyncTransformFeedback();
@@ -936,18 +923,12 @@ void RasterizerOpenGL::SyncCullMode() {
     }
 }
 
-void RasterizerOpenGL::SyncPrimitiveRestart() {
-    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-
-    state.primitive_restart.enabled = regs.primitive_restart.enabled;
-    state.primitive_restart.index = regs.primitive_restart.index;
+void RasterizerOpenGL::SyncDepthScale() {
+    UNREACHABLE();
 }
 
-void RasterizerOpenGL::SyncDepthRange() {
-    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
-
-    state.depth.depth_range_near = regs.viewport->depth_range_near;
-    state.depth.depth_range_far = regs.viewport->depth_range_far;
+void RasterizerOpenGL::SyncDepthOffset() {
+    UNREACHABLE();
 }
 
 void RasterizerOpenGL::SyncDepthTestState() {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -144,11 +144,11 @@ private:
     /// Syncs the cull mode to match the guest state
     void SyncCullMode();
 
-    /// Syncs the primitve restart to match the guest state
-    void SyncPrimitiveRestart();
+    /// Syncs the depth scale to match the guest state
+    void SyncDepthScale();
 
-    /// Syncs the depth range to match the guest state
-    void SyncDepthRange();
+    /// Syncs the depth offset to match the guest state
+    void SyncDepthOffset();
 
     /// Syncs the depth test state to match the guest state
     void SyncDepthTestState();

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -40,10 +40,6 @@ static bool IsPixelFormatASTC(PixelFormat format) {
     case PixelFormat::ASTC_2D_5X4:
     case PixelFormat::ASTC_2D_8X8:
     case PixelFormat::ASTC_2D_8X5:
-    case PixelFormat::ASTC_2D_4X4_SRGB:
-    case PixelFormat::ASTC_2D_5X4_SRGB:
-    case PixelFormat::ASTC_2D_8X8_SRGB:
-    case PixelFormat::ASTC_2D_8X5_SRGB:
         return true;
     default:
         return false;
@@ -60,14 +56,6 @@ static std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
         return {8, 8};
     case PixelFormat::ASTC_2D_8X5:
         return {8, 5};
-    case PixelFormat::ASTC_2D_4X4_SRGB:
-        return {4, 4};
-    case PixelFormat::ASTC_2D_5X4_SRGB:
-        return {5, 4};
-    case PixelFormat::ASTC_2D_8X8_SRGB:
-        return {8, 8};
-    case PixelFormat::ASTC_2D_8X5_SRGB:
-        return {8, 5};
     default:
         LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format));
         UNREACHABLE();
@@ -90,29 +78,6 @@ void SurfaceParams::InitCacheParameters(Tegra::GPUVAddr gpu_addr_) {
     }
 }
 
-std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
-    const u32 compression_factor{GetCompressionFactor(pixel_format)};
-    const u32 bytes_per_pixel{GetBytesPerPixel(pixel_format)};
-    u32 m_depth = (layer_only ? 1U : depth);
-    u32 m_width = std::max(1U, width / compression_factor);
-    u32 m_height = std::max(1U, height / compression_factor);
-    std::size_t size = Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height,
-                                                     m_depth, block_height, block_depth);
-    u32 m_block_height = block_height;
-    u32 m_block_depth = block_depth;
-    std::size_t block_size_bytes = 512 * block_height * block_depth; // 512 is GOB size
-    for (u32 i = 1; i < max_mip_level; i++) {
-        m_width = std::max(1U, m_width / 2);
-        m_height = std::max(1U, m_height / 2);
-        m_depth = std::max(1U, m_depth / 2);
-        m_block_height = std::max(1U, m_block_height / 2);
-        m_block_depth = std::max(1U, m_block_depth / 2);
-        size += Tegra::Texture::CalculateSize(is_tiled, bytes_per_pixel, m_width, m_height, m_depth,
-                                              m_block_height, m_block_depth);
-    }
-    return is_tiled ? Common::AlignUp(size, block_size_bytes) : size;
-}
-
 /*static*/ SurfaceParams SurfaceParams::CreateForTexture(
     const Tegra::Texture::FullTextureInfo& config, const GLShader::SamplerEntry& entry) {
     SurfaceParams params{};
@@ -120,9 +85,8 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_width = params.is_tiled ? config.tic.BlockWidth() : 0,
     params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
     params.block_depth = params.is_tiled ? config.tic.BlockDepth() : 0,
-    params.srgb_conversion = config.tic.IsSrgbConversionEnabled();
-    params.pixel_format = PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value(),
-                                                       params.srgb_conversion);
+    params.pixel_format =
+        PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value());
     params.component_type = ComponentTypeFromTexture(config.tic.r_type.Value());
     params.type = GetFormatType(params.pixel_format);
     params.width = Common::AlignUp(config.tic.Width(), GetCompressionFactor(params.pixel_format));
@@ -160,7 +124,6 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
         break;
     }
 
-    params.is_layered = SurfaceTargetIsLayered(params.target);
     params.max_mip_level = config.tic.max_mip_level + 1;
     params.rt = {};
 
@@ -179,8 +142,6 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_height = 1 << config.memory_layout.block_height;
     params.block_depth = 1 << config.memory_layout.block_depth;
     params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
-    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
-                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
     params.component_type = ComponentTypeFromRenderTarget(config.format);
     params.type = GetFormatType(params.pixel_format);
     params.width = config.width;
@@ -189,7 +150,6 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
     params.max_mip_level = 0;
-    params.is_layered = false;
 
     // Render target specific parameters, not used for caching
     params.rt.index = static_cast<u32>(index);
@@ -216,14 +176,12 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.pixel_format = PixelFormatFromDepthFormat(format);
     params.component_type = ComponentTypeFromDepthFormat(format);
     params.type = GetFormatType(params.pixel_format);
-    params.srgb_conversion = false;
     params.width = zeta_width;
     params.height = zeta_height;
     params.unaligned_height = zeta_height;
     params.target = SurfaceTarget::Texture2D;
     params.depth = 1;
     params.max_mip_level = 0;
-    params.is_layered = false;
     params.rt = {};
 
     params.InitCacheParameters(zeta_address);
@@ -240,8 +198,6 @@ std::size_t SurfaceParams::InnerMemorySize(bool layer_only) const {
     params.block_height = params.is_tiled ? std::min(config.BlockHeight(), 32U) : 0,
     params.block_depth = params.is_tiled ? std::min(config.BlockDepth(), 32U) : 0,
     params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
-    params.srgb_conversion = config.format == Tegra::RenderTargetFormat::BGRA8_SRGB ||
-                             config.format == Tegra::RenderTargetFormat::RGBA8_SRGB;
     params.component_type = ComponentTypeFromRenderTarget(config.format);
     params.type = GetFormatType(params.pixel_format);
     params.width = config.width;
@@ -273,7 +229,7 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
      false},                                                                     // R11FG11FB10F
     {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RGBA32UI
-    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+    {GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT1
     {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // DXT23
@@ -307,29 +263,14 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_RG16I, GL_RG_INTEGER, GL_SHORT, ComponentType::SInt, false},           // RG16I
     {GL_RG16_SNORM, GL_RG, GL_SHORT, ComponentType::SNorm, false},             // RG16S
     {GL_RGB32F, GL_RGB, GL_FLOAT, ComponentType::Float, false},                // RGB32F
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm,
-     false},                                                                   // RGBA8_SRGB
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // RG8U
-    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                     // RG8S
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},   // RG32UI
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},   // R32UI
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_8X8
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_8X5
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_5X4
-    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
-    // Compressed sRGB formats
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true}, // DXT1_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true}, // DXT23_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true}, // DXT45_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8,
-     ComponentType::UNorm, true},                                              // BC7U_SRGB
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4_SRGB
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4_SRGB
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // SRGBA8
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},                       // RG8U
+    {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                                // RG8S
+    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // RG32UI
+    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false},              // R32UI
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4
 
     // Depth formats
     {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
@@ -394,10 +335,6 @@ static bool IsFormatBCn(PixelFormat format) {
     case PixelFormat::BC7U:
     case PixelFormat::BC6H_UF16:
     case PixelFormat::BC6H_SF16:
-    case PixelFormat::DXT1_SRGB:
-    case PixelFormat::DXT23_SRGB:
-    case PixelFormat::DXT45_SRGB:
-    case PixelFormat::BC7U_SRGB:
         return true;
     }
     return false;
@@ -424,11 +361,10 @@ void MortonCopy(u32 stride, u32 block_height, u32 height, u32 block_depth, u32 d
     }
 }
 
-using GLConversionArray = std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
-                                     SurfaceParams::MaxPixelFormat>;
-
-static constexpr GLConversionArray morton_to_gl_fns = {
-    // clang-format off
+static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
+                            SurfaceParams::MaxPixelFormat>
+    morton_to_gl_fns = {
+        // clang-format off
         MortonCopy<true, PixelFormat::ABGR8U>,
         MortonCopy<true, PixelFormat::ABGR8S>,
         MortonCopy<true, PixelFormat::ABGR8UI>,
@@ -469,7 +405,7 @@ static constexpr GLConversionArray morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::RG16I>,
         MortonCopy<true, PixelFormat::RG16S>,
         MortonCopy<true, PixelFormat::RGB32F>,
-        MortonCopy<true, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<true, PixelFormat::SRGBA8>,
         MortonCopy<true, PixelFormat::RG8U>,
         MortonCopy<true, PixelFormat::RG8S>,
         MortonCopy<true, PixelFormat::RG32UI>,
@@ -477,25 +413,18 @@ static constexpr GLConversionArray morton_to_gl_fns = {
         MortonCopy<true, PixelFormat::ASTC_2D_8X8>,
         MortonCopy<true, PixelFormat::ASTC_2D_8X5>,
         MortonCopy<true, PixelFormat::ASTC_2D_5X4>,
-        MortonCopy<true, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<true, PixelFormat::DXT1_SRGB>,
-        MortonCopy<true, PixelFormat::DXT23_SRGB>,
-        MortonCopy<true, PixelFormat::DXT45_SRGB>,
-        MortonCopy<true, PixelFormat::BC7U_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_4X4_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X8_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_8X5_SRGB>,
-        MortonCopy<true, PixelFormat::ASTC_2D_5X4_SRGB>,
         MortonCopy<true, PixelFormat::Z32F>,
         MortonCopy<true, PixelFormat::Z16>,
         MortonCopy<true, PixelFormat::Z24S8>,
         MortonCopy<true, PixelFormat::S8Z24>,
         MortonCopy<true, PixelFormat::Z32FS8>,
-    // clang-format on
+        // clang-format on
 };
 
-static constexpr GLConversionArray gl_to_morton_fns = {
-    // clang-format off
+static constexpr std::array<void (*)(u32, u32, u32, u32, u32, u8*, std::size_t, VAddr),
+                            SurfaceParams::MaxPixelFormat>
+    gl_to_morton_fns = {
+        // clang-format off
         MortonCopy<false, PixelFormat::ABGR8U>,
         MortonCopy<false, PixelFormat::ABGR8S>,
         MortonCopy<false, PixelFormat::ABGR8UI>,
@@ -537,7 +466,7 @@ static constexpr GLConversionArray gl_to_morton_fns = {
         MortonCopy<false, PixelFormat::RG16I>,
         MortonCopy<false, PixelFormat::RG16S>,
         MortonCopy<false, PixelFormat::RGB32F>,
-        MortonCopy<false, PixelFormat::RGBA8_SRGB>,
+        MortonCopy<false, PixelFormat::SRGBA8>,
         MortonCopy<false, PixelFormat::RG8U>,
         MortonCopy<false, PixelFormat::RG8S>,
         MortonCopy<false, PixelFormat::RG32UI>,
@@ -545,49 +474,14 @@ static constexpr GLConversionArray gl_to_morton_fns = {
         nullptr,
         nullptr,
         nullptr,
-        MortonCopy<false, PixelFormat::BGRA8_SRGB>,
-        MortonCopy<false, PixelFormat::DXT1_SRGB>,
-        MortonCopy<false, PixelFormat::DXT23_SRGB>,
-        MortonCopy<false, PixelFormat::DXT45_SRGB>,
-        MortonCopy<false, PixelFormat::BC7U_SRGB>,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
         MortonCopy<false, PixelFormat::Z32F>,
         MortonCopy<false, PixelFormat::Z16>,
         MortonCopy<false, PixelFormat::Z24S8>,
         MortonCopy<false, PixelFormat::S8Z24>,
         MortonCopy<false, PixelFormat::Z32FS8>,
-    // clang-format on
+        // clang-format on
 };
 
-void SwizzleFunc(const GLConversionArray& functions, const SurfaceParams& params,
-                 std::vector<u8>& gl_buffer) {
-    u32 depth = params.depth;
-    if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
-        // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
-        depth = 1U;
-    }
-    if (params.is_layered) {
-        u64 offset = 0;
-        u64 offset_gl = 0;
-        u64 layer_size = params.LayerMemorySize();
-        u64 gl_size = params.LayerSizeGL();
-        for (u32 i = 0; i < depth; i++) {
-            functions[static_cast<std::size_t>(params.pixel_format)](
-                params.width, params.block_height, params.height, params.block_depth, 1,
-                gl_buffer.data() + offset_gl, gl_size, params.addr + offset);
-            offset += layer_size;
-            offset_gl += gl_size;
-        }
-    } else {
-        functions[static_cast<std::size_t>(params.pixel_format)](
-            params.width, params.block_height, params.height, params.block_depth, depth,
-            gl_buffer.data(), gl_buffer.size(), params.addr);
-    }
-}
-
 static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
                         GLuint read_fb_handle, GLuint draw_fb_handle, GLenum src_attachment = 0,
                         GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
@@ -601,8 +495,6 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
     OpenGLState state;
     state.draw.read_framebuffer = read_fb_handle;
     state.draw.draw_framebuffer = draw_fb_handle;
-    // Set sRGB enabled if the destination surfaces need it
-    state.framebuffer_srgb.enabled = dst_params.srgb_conversion;
     state.Apply();
 
     u32 buffers{};
@@ -938,11 +830,7 @@ static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelForma
     case PixelFormat::ASTC_2D_4X4:
     case PixelFormat::ASTC_2D_8X8:
     case PixelFormat::ASTC_2D_8X5:
-    case PixelFormat::ASTC_2D_5X4:
-    case PixelFormat::ASTC_2D_4X4_SRGB:
-    case PixelFormat::ASTC_2D_8X8_SRGB:
-    case PixelFormat::ASTC_2D_8X5_SRGB:
-    case PixelFormat::ASTC_2D_5X4_SRGB: {
+    case PixelFormat::ASTC_2D_5X4: {
         // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
         u32 block_width{};
         u32 block_height{};
@@ -974,9 +862,7 @@ static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelForm
     case PixelFormat::G8R8U:
     case PixelFormat::G8R8S:
     case PixelFormat::ASTC_2D_4X4:
-    case PixelFormat::ASTC_2D_8X8:
-    case PixelFormat::ASTC_2D_4X4_SRGB:
-    case PixelFormat::ASTC_2D_8X8_SRGB: {
+    case PixelFormat::ASTC_2D_8X8: {
         LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
                      static_cast<u32>(pixel_format));
         UNREACHABLE();
@@ -995,10 +881,21 @@ void CachedSurface::LoadGLBuffer() {
 
     gl_buffer.resize(params.size_in_bytes_gl);
     if (params.is_tiled) {
+        u32 depth = params.depth;
+        u32 block_depth = params.block_depth;
+
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
 
-        SwizzleFunc(morton_to_gl_fns, params, gl_buffer);
+        if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
+            // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
+            depth = 1U;
+            block_depth = 1U;
+        }
+
+        morton_to_gl_fns[static_cast<std::size_t>(params.pixel_format)](
+            params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
+            gl_buffer.size(), params.addr);
     } else {
         const auto texture_src_data{Memory::GetPointer(params.addr)};
         const auto texture_src_data_end{texture_src_data + params.size_in_bytes_gl};
@@ -1023,8 +920,8 @@ void CachedSurface::FlushGLBuffer() {
     glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.width));
     ASSERT(!tuple.compressed);
     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type,
-                      static_cast<GLsizei>(gl_buffer.size()), gl_buffer.data());
+    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type, gl_buffer.size(),
+                      gl_buffer.data());
     glPixelStorei(GL_PACK_ROW_LENGTH, 0);
     ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
                                         params.height);
@@ -1032,10 +929,19 @@ void CachedSurface::FlushGLBuffer() {
     const u8* const texture_src_data = Memory::GetPointer(params.addr);
     ASSERT(texture_src_data);
     if (params.is_tiled) {
+        u32 depth = params.depth;
+        u32 block_depth = params.block_depth;
+
         ASSERT_MSG(params.block_width == 1, "Block width is defined as {} on texture type {}",
                    params.block_width, static_cast<u32>(params.target));
 
-        SwizzleFunc(gl_to_morton_fns, params, gl_buffer);
+        if (params.target == SurfaceParams::SurfaceTarget::Texture2D) {
+            // TODO(Blinkhawk): Eliminate this condition once all texture types are implemented.
+            depth = 1U;
+        }
+        gl_to_morton_fns[static_cast<size_t>(params.pixel_format)](
+            params.width, params.block_height, params.height, block_depth, depth, gl_buffer.data(),
+            gl_buffer.size(), GetAddr());
     } else {
         std::memcpy(Memory::GetPointer(GetAddr()), gl_buffer.data(), GetSizeInBytes());
     }
@@ -1273,7 +1179,7 @@ void RasterizerCacheOpenGL::AccurateCopySurface(const Surface& src_surface,
                                                 const Surface& dst_surface) {
     const auto& src_params{src_surface->GetSurfaceParams()};
     const auto& dst_params{dst_surface->GetSurfaceParams()};
-    FlushRegion(src_params.addr, dst_params.MemorySize());
+    FlushRegion(src_params.addr, dst_params.size_in_bytes);
     LoadSurface(dst_surface);
 }
 
@@ -1315,10 +1221,44 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
             CopySurface(old_surface, new_surface, copy_pbo.handle);
         }
         break;
-    case SurfaceParams::SurfaceTarget::TextureCubemap:
     case SurfaceParams::SurfaceTarget::Texture3D:
         AccurateCopySurface(old_surface, new_surface);
         break;
+    case SurfaceParams::SurfaceTarget::TextureCubemap: {
+        if (old_params.rt.array_mode != 1) {
+            // TODO(bunnei): This is used by Breath of the Wild, I'm not sure how to implement this
+            // yet (array rendering used as a cubemap texture).
+            LOG_CRITICAL(HW_GPU, "Unhandled rendertarget array_mode {}", old_params.rt.array_mode);
+            UNREACHABLE();
+            return new_surface;
+        }
+
+        // This seems to be used for render-to-cubemap texture
+        ASSERT_MSG(old_params.target == SurfaceParams::SurfaceTarget::Texture2D, "Unexpected");
+        ASSERT_MSG(old_params.pixel_format == new_params.pixel_format, "Unexpected");
+        ASSERT_MSG(old_params.rt.base_layer == 0, "Unimplemented");
+
+        // TODO(bunnei): Verify the below - this stride seems to be in 32-bit words, not pixels.
+        // Tested with Splatoon 2, Super Mario Odyssey, and Breath of the Wild.
+        const std::size_t byte_stride{old_params.rt.layer_stride * sizeof(u32)};
+
+        for (std::size_t index = 0; index < new_params.depth; ++index) {
+            Surface face_surface{TryGetReservedSurface(old_params)};
+            ASSERT_MSG(face_surface, "Unexpected");
+
+            if (is_blit) {
+                BlitSurface(face_surface, new_surface, read_framebuffer.handle,
+                            draw_framebuffer.handle, face_surface->GetSurfaceParams().rt.index,
+                            new_params.rt.index, index);
+            } else {
+                CopySurface(face_surface, new_surface, copy_pbo.handle,
+                            face_surface->GetSurfaceParams().rt.index, new_params.rt.index, index);
+            }
+
+            old_params.addr += byte_stride;
+        }
+        break;
+    }
     default:
         LOG_CRITICAL(Render_OpenGL, "Unimplemented surface target={}",
                      static_cast<u32>(new_params.target));
@@ -1326,7 +1266,7 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     }
 
     return new_surface;
-} // namespace OpenGL
+}
 
 Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr addr) const {
     return TryGet(addr);

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -69,7 +69,7 @@ struct SurfaceParams {
         RG16I = 37,
         RG16S = 38,
         RGB32F = 39,
-        RGBA8_SRGB = 40,
+        SRGBA8 = 40,
         RG8U = 41,
         RG8S = 42,
         RG32UI = 43,
@@ -77,28 +77,19 @@ struct SurfaceParams {
         ASTC_2D_8X8 = 45,
         ASTC_2D_8X5 = 46,
         ASTC_2D_5X4 = 47,
-        BGRA8_SRGB = 48,
-        DXT1_SRGB = 49,
-        DXT23_SRGB = 50,
-        DXT45_SRGB = 51,
-        BC7U_SRGB = 52,
-        ASTC_2D_4X4_SRGB = 53,
-        ASTC_2D_8X8_SRGB = 54,
-        ASTC_2D_8X5_SRGB = 55,
-        ASTC_2D_5X4_SRGB = 56,
 
         MaxColorFormat,
 
         // Depth formats
-        Z32F = 57,
-        Z16 = 58,
+        Z32F = 48,
+        Z16 = 49,
 
         MaxDepthFormat,
 
         // DepthStencil formats
-        Z24S8 = 59,
-        S8Z24 = 60,
-        Z32FS8 = 61,
+        Z24S8 = 50,
+        S8Z24 = 51,
+        Z32FS8 = 52,
 
         MaxDepthStencilFormat,
 
@@ -177,23 +168,6 @@ struct SurfaceParams {
         }
     }
 
-    static bool SurfaceTargetIsLayered(SurfaceTarget target) {
-        switch (target) {
-        case SurfaceTarget::Texture1D:
-        case SurfaceTarget::Texture2D:
-        case SurfaceTarget::Texture3D:
-            return false;
-        case SurfaceTarget::Texture1DArray:
-        case SurfaceTarget::Texture2DArray:
-        case SurfaceTarget::TextureCubemap:
-            return true;
-        default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
-            UNREACHABLE();
-            return false;
-        }
-    }
-
     /**
      * Gets the compression factor for the specified PixelFormat. This applies to just the
      * "compressed width" and "compressed height", not the overall compression factor of a
@@ -245,7 +219,7 @@ struct SurfaceParams {
             1, // RG16I
             1, // RG16S
             1, // RGB32F
-            1, // RGBA8_SRGB
+            1, // SRGBA8
             1, // RG8U
             1, // RG8S
             1, // RG32UI
@@ -253,15 +227,6 @@ struct SurfaceParams {
             4, // ASTC_2D_8X8
             4, // ASTC_2D_8X5
             4, // ASTC_2D_5X4
-            1, // BGRA8_SRGB
-            4, // DXT1_SRGB
-            4, // DXT23_SRGB
-            4, // DXT45_SRGB
-            4, // BC7U_SRGB
-            4, // ASTC_2D_4X4_SRGB
-            4, // ASTC_2D_8X8_SRGB
-            4, // ASTC_2D_8X5_SRGB
-            4, // ASTC_2D_5X4_SRGB
             1, // Z32F
             1, // Z16
             1, // Z24S8
@@ -273,77 +238,6 @@ struct SurfaceParams {
         return compression_factor_table[static_cast<std::size_t>(format)];
     }
 
-    static constexpr u32 GetDefaultBlockHeight(PixelFormat format) {
-        if (format == PixelFormat::Invalid)
-            return 0;
-        constexpr std::array<u32, MaxPixelFormat> block_height_table = {{
-            1, // ABGR8U
-            1, // ABGR8S
-            1, // ABGR8UI
-            1, // B5G6R5U
-            1, // A2B10G10R10U
-            1, // A1B5G5R5U
-            1, // R8U
-            1, // R8UI
-            1, // RGBA16F
-            1, // RGBA16U
-            1, // RGBA16UI
-            1, // R11FG11FB10F
-            1, // RGBA32UI
-            4, // DXT1
-            4, // DXT23
-            4, // DXT45
-            4, // DXN1
-            4, // DXN2UNORM
-            4, // DXN2SNORM
-            4, // BC7U
-            4, // BC6H_UF16
-            4, // BC6H_SF16
-            4, // ASTC_2D_4X4
-            1, // G8R8U
-            1, // G8R8S
-            1, // BGRA8
-            1, // RGBA32F
-            1, // RG32F
-            1, // R32F
-            1, // R16F
-            1, // R16U
-            1, // R16S
-            1, // R16UI
-            1, // R16I
-            1, // RG16
-            1, // RG16F
-            1, // RG16UI
-            1, // RG16I
-            1, // RG16S
-            1, // RGB32F
-            1, // RGBA8_SRGB
-            1, // RG8U
-            1, // RG8S
-            1, // RG32UI
-            1, // R32UI
-            8, // ASTC_2D_8X8
-            5, // ASTC_2D_8X5
-            4, // ASTC_2D_5X4
-            1, // BGRA8_SRGB
-            4, // DXT1_SRGB
-            4, // DXT23_SRGB
-            4, // DXT45_SRGB
-            4, // BC7U_SRGB
-            4, // ASTC_2D_4X4_SRGB
-            8, // ASTC_2D_8X8_SRGB
-            5, // ASTC_2D_8X5_SRGB
-            4, // ASTC_2D_5X4_SRGB
-            1, // Z32F
-            1, // Z16
-            1, // Z24S8
-            1, // S8Z24
-            1, // Z32FS8
-        }};
-        ASSERT(static_cast<std::size_t>(format) < block_height_table.size());
-        return block_height_table[static_cast<std::size_t>(format)];
-    }
-
     static constexpr u32 GetFormatBpp(PixelFormat format) {
         if (format == PixelFormat::Invalid)
             return 0;
@@ -389,23 +283,14 @@ struct SurfaceParams {
             32,  // RG16I
             32,  // RG16S
             96,  // RGB32F
-            32,  // RGBA8_SRGB
+            32,  // SRGBA8
             16,  // RG8U
             16,  // RG8S
             64,  // RG32UI
             32,  // R32UI
             16,  // ASTC_2D_8X8
-            16,  // ASTC_2D_8X5
+            32,  // ASTC_2D_8X5
             32,  // ASTC_2D_5X4
-            32,  // BGRA8_SRGB
-            64,  // DXT1_SRGB
-            128, // DXT23_SRGB
-            128, // DXT45_SRGB
-            128, // BC7U
-            32,  // ASTC_2D_4X4_SRGB
-            16,  // ASTC_2D_8X8_SRGB
-            16,  // ASTC_2D_8X5_SRGB
-            32,  // ASTC_2D_5X4_SRGB
             32,  // Z32F
             16,  // Z16
             32,  // Z24S8
@@ -444,7 +329,6 @@ struct SurfaceParams {
         // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
         // gamma.
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
-            return PixelFormat::RGBA8_SRGB;
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
             return PixelFormat::ABGR8U;
         case Tegra::RenderTargetFormat::RGBA8_SNORM:
@@ -452,7 +336,6 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGBA8_UINT:
             return PixelFormat::ABGR8UI;
         case Tegra::RenderTargetFormat::BGRA8_SRGB:
-            return PixelFormat::BGRA8_SRGB;
         case Tegra::RenderTargetFormat::BGRA8_UNORM:
             return PixelFormat::BGRA8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
@@ -516,14 +399,10 @@ struct SurfaceParams {
     }
 
     static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
-                                                    Tegra::Texture::ComponentType component_type,
-                                                    bool is_srgb) {
+                                                    Tegra::Texture::ComponentType component_type) {
         // TODO(Subv): Properly implement this
         switch (format) {
         case Tegra::Texture::TextureFormat::A8R8G8B8:
-            if (is_srgb) {
-                return PixelFormat::RGBA8_SRGB;
-            }
             switch (component_type) {
             case Tegra::Texture::ComponentType::UNORM:
                 return PixelFormat::ABGR8U;
@@ -658,11 +537,11 @@ struct SurfaceParams {
         case Tegra::Texture::TextureFormat::Z24S8:
             return PixelFormat::Z24S8;
         case Tegra::Texture::TextureFormat::DXT1:
-            return is_srgb ? PixelFormat::DXT1_SRGB : PixelFormat::DXT1;
+            return PixelFormat::DXT1;
         case Tegra::Texture::TextureFormat::DXT23:
-            return is_srgb ? PixelFormat::DXT23_SRGB : PixelFormat::DXT23;
+            return PixelFormat::DXT23;
         case Tegra::Texture::TextureFormat::DXT45:
-            return is_srgb ? PixelFormat::DXT45_SRGB : PixelFormat::DXT45;
+            return PixelFormat::DXT45;
         case Tegra::Texture::TextureFormat::DXN1:
             return PixelFormat::DXN1;
         case Tegra::Texture::TextureFormat::DXN2:
@@ -676,19 +555,19 @@ struct SurfaceParams {
                          static_cast<u32>(component_type));
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::BC7U:
-            return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U;
+            return PixelFormat::BC7U;
         case Tegra::Texture::TextureFormat::BC6H_UF16:
             return PixelFormat::BC6H_UF16;
         case Tegra::Texture::TextureFormat::BC6H_SF16:
             return PixelFormat::BC6H_SF16;
         case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
-            return is_srgb ? PixelFormat::ASTC_2D_4X4_SRGB : PixelFormat::ASTC_2D_4X4;
+            return PixelFormat::ASTC_2D_4X4;
         case Tegra::Texture::TextureFormat::ASTC_2D_5X4:
-            return is_srgb ? PixelFormat::ASTC_2D_5X4_SRGB : PixelFormat::ASTC_2D_5X4;
+            return PixelFormat::ASTC_2D_5X4;
         case Tegra::Texture::TextureFormat::ASTC_2D_8X8:
-            return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8;
+            return PixelFormat::ASTC_2D_8X8;
         case Tegra::Texture::TextureFormat::ASTC_2D_8X5:
-            return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5;
+            return PixelFormat::ASTC_2D_8X5;
         case Tegra::Texture::TextureFormat::R16_G16:
             switch (component_type) {
             case Tegra::Texture::ComponentType::FLOAT:
@@ -863,25 +742,6 @@ struct SurfaceParams {
         return size_in_bytes_gl / 6;
     }
 
-    /// Returns the exact size of memory occupied by the texture in VRAM, including mipmaps.
-    std::size_t MemorySize() const {
-        std::size_t size = InnerMemorySize(is_layered);
-        if (is_layered)
-            return size * depth;
-        return size;
-    }
-
-    /// Returns the exact size of the memory occupied by a layer in a texture in VRAM, including
-    /// mipmaps.
-    std::size_t LayerMemorySize() const {
-        return InnerMemorySize(true);
-    }
-
-    /// Returns the size of a layer of this surface in OpenGL.
-    std::size_t LayerSizeGL() const {
-        return SizeInBytesRaw(true) / depth;
-    }
-
     /// Creates SurfaceParams from a texture configuration
     static SurfaceParams CreateForTexture(const Tegra::Texture::FullTextureInfo& config,
                                           const GLShader::SamplerEntry& entry);
@@ -922,8 +782,7 @@ struct SurfaceParams {
     u32 unaligned_height;
     SurfaceTarget target;
     u32 max_mip_level;
-    bool is_layered;
-    bool srgb_conversion;
+
     // Parameters used for caching
     VAddr addr;
     Tegra::GPUVAddr gpu_addr;
@@ -938,9 +797,6 @@ struct SurfaceParams {
         u32 layer_stride;
         u32 base_layer;
     } rt;
-
-private:
-    std::size_t InnerMemorySize(bool layer_only = false) const;
 };
 
 }; // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -6,7 +6,6 @@
 #include <set>
 #include <string>
 #include <string_view>
-#include <unordered_set>
 
 #include <boost/optional.hpp>
 #include <fmt/format.h>
@@ -277,8 +276,7 @@ public:
     GLSLRegisterManager(ShaderWriter& shader, ShaderWriter& declarations,
                         const Maxwell3D::Regs::ShaderStage& stage, const std::string& suffix,
                         const Tegra::Shader::Header& header)
-        : shader{shader}, declarations{declarations}, stage{stage}, suffix{suffix}, header{header},
-          fixed_pipeline_output_attributes_used{}, local_memory_size{0} {
+        : shader{shader}, declarations{declarations}, stage{stage}, suffix{suffix}, header{header} {
         BuildRegisterList();
         BuildInputList();
     }
@@ -341,10 +339,10 @@ public:
      */
     void SetRegisterToFloat(const Register& reg, u64 elem, const std::string& value,
                             u64 dest_num_components, u64 value_num_components,
-                            bool is_saturated = false, u64 dest_elem = 0, bool precise = false) {
+                            bool is_saturated = false, u64 dest_elem = 0) {
 
         SetRegister(reg, elem, is_saturated ? "clamp(" + value + ", 0.0, 1.0)" : value,
-                    dest_num_components, value_num_components, dest_elem, precise);
+                    dest_num_components, value_num_components, dest_elem);
     }
 
     /**
@@ -368,7 +366,7 @@ public:
         const std::string func{is_signed ? "intBitsToFloat" : "uintBitsToFloat"};
 
         SetRegister(reg, elem, func + '(' + ConvertIntegerSize(value, size) + ')',
-                    dest_num_components, value_num_components, dest_elem, false);
+                    dest_num_components, value_num_components, dest_elem);
 
         if (sets_cc) {
             const std::string zero_condition = "( " + ConvertIntegerSize(value, size) + " == 0 )";
@@ -416,7 +414,7 @@ public:
             }
         }();
 
-        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem, false);
+        SetRegister(reg, elem, result, dest_num_components, value_num_components, dest_elem);
     }
 
     /**
@@ -436,25 +434,6 @@ public:
         shader.AddLine(dest + " = " + src + ';');
     }
 
-    std::string GetLocalMemoryAsFloat(const std::string& index) {
-        return "lmem[" + index + ']';
-    }
-
-    std::string GetLocalMemoryAsInteger(const std::string& index, bool is_signed = false) {
-        const std::string func{is_signed ? "floatToIntBits" : "floatBitsToUint"};
-        return func + "(lmem[" + index + "])";
-    }
-
-    void SetLocalMemoryAsFloat(const std::string& index, const std::string& value) {
-        shader.AddLine("lmem[" + index + "] = " + value + ';');
-    }
-
-    void SetLocalMemoryAsInteger(const std::string& index, const std::string& value,
-                                 bool is_signed = false) {
-        const std::string func{is_signed ? "intBitsToFloat" : "uintBitsToFloat"};
-        shader.AddLine("lmem[" + index + "] = " + func + '(' + value + ");");
-    }
-
     std::string GetControlCode(const Tegra::Shader::ControlCode cc) const {
         switch (cc) {
         case Tegra::Shader::ControlCode::NEU:
@@ -501,12 +480,7 @@ public:
                                std::to_string(static_cast<u32>(attribute)) + ']' +
                                GetSwizzle(elem) + " = " + src + ';');
             } else {
-                if (attribute == Attribute::Index::PointSize) {
-                    fixed_pipeline_output_attributes_used.insert(attribute);
-                    shader.AddLine(dest + " = " + src + ';');
-                } else {
-                    shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
-                }
+                shader.AddLine(dest + GetSwizzle(elem) + " = " + src + ';');
             }
         }
     }
@@ -550,9 +524,7 @@ public:
 
     /// Add declarations.
     void GenerateDeclarations(const std::string& suffix) {
-        GenerateVertex();
         GenerateRegisters(suffix);
-        GenerateLocalMemory();
         GenerateInternalFlags();
         GenerateInputAttrs();
         GenerateOutputAttrs();
@@ -598,10 +570,6 @@ public:
         return entry.GetName();
     }
 
-    void SetLocalMemory(u64 lmem) {
-        local_memory_size = lmem;
-    }
-
 private:
     /// Generates declarations for registers.
     void GenerateRegisters(const std::string& suffix) {
@@ -612,15 +580,6 @@ private:
         declarations.AddNewLine();
     }
 
-    /// Generates declarations for local memory.
-    void GenerateLocalMemory() {
-        if (local_memory_size > 0) {
-            declarations.AddLine("float lmem[" + std::to_string((local_memory_size - 1 + 4) / 4) +
-                                 "];");
-            declarations.AddNewLine();
-        }
-    }
-
     /// Generates declarations for internal flags.
     void GenerateInternalFlags() {
         for (u32 ii = 0; ii < static_cast<u64>(InternalFlag::Amount); ii++) {
@@ -724,20 +683,6 @@ private:
         declarations.AddNewLine();
     }
 
-    void GenerateVertex() {
-        if (stage != Maxwell3D::Regs::ShaderStage::Vertex)
-            return;
-        declarations.AddLine("out gl_PerVertex {");
-        ++declarations.scope;
-        declarations.AddLine("vec4 gl_Position;");
-        for (auto& o : fixed_pipeline_output_attributes_used) {
-            if (o == Attribute::Index::PointSize)
-                declarations.AddLine("float gl_PointSize;");
-        }
-        --declarations.scope;
-        declarations.AddLine("};");
-    }
-
     /// Generates code representing a temporary (GPR) register.
     std::string GetRegister(const Register& reg, unsigned elem) {
         if (reg == Register::ZeroIndex) {
@@ -757,8 +702,7 @@ private:
      * @param dest_elem Optional, the destination element to use for the operation.
      */
     void SetRegister(const Register& reg, u64 elem, const std::string& value,
-                     u64 dest_num_components, u64 value_num_components, u64 dest_elem,
-                     bool precise) {
+                     u64 dest_num_components, u64 value_num_components, u64 dest_elem) {
         if (reg == Register::ZeroIndex) {
             LOG_CRITICAL(HW_GPU, "Cannot set Register::ZeroIndex");
             UNREACHABLE();
@@ -775,18 +719,7 @@ private:
             src += GetSwizzle(elem);
         }
 
-        if (precise && stage != Maxwell3D::Regs::ShaderStage::Fragment) {
-            shader.AddLine('{');
-            ++shader.scope;
-            // This avoids optimizations of constant propagation and keeps the code as the original
-            // Sadly using the precise keyword causes "linking" errors on fragment shaders.
-            shader.AddLine("precise float tmp = " + src + ';');
-            shader.AddLine(dest + " = tmp;");
-            --shader.scope;
-            shader.AddLine('}');
-        } else {
-            shader.AddLine(dest + " = " + src + ';');
-        }
+        shader.AddLine(dest + " = " + src + ';');
     }
 
     /// Build the GLSL register list.
@@ -903,8 +836,6 @@ private:
     /// Generates code representing the declaration name of an output attribute register.
     std::string GetOutputAttribute(Attribute::Index attribute) {
         switch (attribute) {
-        case Attribute::Index::PointSize:
-            return "gl_PointSize";
         case Attribute::Index::Position:
             return "position";
         default:
@@ -939,8 +870,6 @@ private:
     const Maxwell3D::Regs::ShaderStage& stage;
     const std::string& suffix;
     const Tegra::Shader::Header& header;
-    std::unordered_set<Attribute::Index> fixed_pipeline_output_attributes_used;
-    u64 local_memory_size;
 };
 
 class GLSLGenerator {
@@ -950,8 +879,6 @@ public:
         : subroutines(subroutines), program_code(program_code), main_offset(main_offset),
           stage(stage), suffix(suffix) {
         std::memcpy(&header, program_code.data(), sizeof(Tegra::Shader::Header));
-        local_memory_size = header.GetLocalMemorySize();
-        regs.SetLocalMemory(local_memory_size);
         Generate(suffix);
     }
 
@@ -1522,9 +1449,8 @@ private:
                 ASSERT_MSG(instr.fmul.cc == 0, "FMUL cc is not implemented");
 
                 op_b = GetOperandAbsNeg(op_b, false, instr.fmul.negate_b);
-
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b, 1, 1,
-                                        instr.alu.saturate_d, 0, true);
+                                        instr.alu.saturate_d);
                 break;
             }
             case OpCode::Id::FADD_C:
@@ -1532,9 +1458,8 @@ private:
             case OpCode::Id::FADD_IMM: {
                 op_a = GetOperandAbsNeg(op_a, instr.alu.abs_a, instr.alu.negate_a);
                 op_b = GetOperandAbsNeg(op_b, instr.alu.abs_b, instr.alu.negate_b);
-
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1,
-                                        instr.alu.saturate_d, 0, true);
+                                        instr.alu.saturate_d);
                 break;
             }
             case OpCode::Id::MUFU: {
@@ -1542,31 +1467,31 @@ private:
                 switch (instr.sub_op) {
                 case SubOp::Cos:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "cos(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Sin:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "sin(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Ex2:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "exp2(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Lg2:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "log2(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Rcp:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "1.0 / " + op_a, 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Rsq:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "inversesqrt(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 case SubOp::Sqrt:
                     regs.SetRegisterToFloat(instr.gpr0, 0, "sqrt(" + op_a + ')', 1, 1,
-                                            instr.alu.saturate_d, 0, true);
+                                            instr.alu.saturate_d);
                     break;
                 default:
                     LOG_CRITICAL(HW_GPU, "Unhandled MUFU sub op: {0:x}",
@@ -1587,7 +1512,7 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         '(' + condition + ") ? min(" + parameters + ") : max(" +
                                             parameters + ')',
-                                        1, 1, false, 0, true);
+                                        1, 1);
                 break;
             }
             case OpCode::Id::RRO_C:
@@ -1616,7 +1541,7 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         regs.GetRegisterAsFloat(instr.gpr8) + " * " +
                                             GetImmediate32(instr),
-                                        1, 1, instr.fmul32.saturate, 0, true);
+                                        1, 1, instr.fmul32.saturate);
                 break;
             }
             case OpCode::Id::FADD32I: {
@@ -1639,7 +1564,7 @@ private:
                     op_b = "-(" + op_b + ')';
                 }
 
-                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1, false, 0, true);
+                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1);
                 break;
             }
             }
@@ -2101,9 +2026,8 @@ private:
             }
             }
 
-            regs.SetRegisterToFloat(instr.gpr0, 0, "fma(" + op_a + ", " + op_b + ", " + op_c + ')',
-                                    1, 1, instr.alu.saturate_d, 0, true);
-
+            regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b + " + " + op_c, 1, 1,
+                                    instr.alu.saturate_d);
             break;
         }
         case OpCode::Type::Hfma2: {
@@ -2375,39 +2299,6 @@ private:
                 shader.AddLine("}");
                 break;
             }
-            case OpCode::Id::LD_L: {
-                // Add an extra scope and declare the index register inside to prevent
-                // overwriting it in case it is used as an output of the LD instruction.
-                shader.AddLine('{');
-                ++shader.scope;
-
-                std::string op = '(' + regs.GetRegisterAsInteger(instr.gpr8, 0, false) + " + " +
-                                 std::to_string(instr.smem_imm.Value()) + ')';
-
-                shader.AddLine("uint index = (" + op + " / 4);");
-
-                const std::string op_a = regs.GetLocalMemoryAsFloat("index");
-
-                if (instr.ld_l.unknown != 1) {
-                    LOG_CRITICAL(HW_GPU, "LD_L Unhandled mode: {}",
-                                 static_cast<unsigned>(instr.ld_l.unknown.Value()));
-                    UNREACHABLE();
-                }
-
-                switch (instr.ldst_sl.type.Value()) {
-                case Tegra::Shader::StoreType::Bytes32:
-                    regs.SetRegisterToFloat(instr.gpr0, 0, op_a, 1, 1);
-                    break;
-                default:
-                    LOG_CRITICAL(HW_GPU, "LD_L Unhandled type: {}",
-                                 static_cast<unsigned>(instr.ldst_sl.type.Value()));
-                    UNREACHABLE();
-                }
-
-                --shader.scope;
-                shader.AddLine('}');
-                break;
-            }
             case OpCode::Id::ST_A: {
                 ASSERT_MSG(instr.gpr8.Value() == Register::ZeroIndex,
                            "Indirect attribute loads are not supported");
@@ -2436,37 +2327,6 @@ private:
 
                 break;
             }
-            case OpCode::Id::ST_L: {
-                // Add an extra scope and declare the index register inside to prevent
-                // overwriting it in case it is used as an output of the LD instruction.
-                shader.AddLine('{');
-                ++shader.scope;
-
-                std::string op = '(' + regs.GetRegisterAsInteger(instr.gpr8, 0, false) + " + " +
-                                 std::to_string(instr.smem_imm.Value()) + ')';
-
-                shader.AddLine("uint index = (" + op + " / 4);");
-
-                if (instr.st_l.unknown != 0) {
-                    LOG_CRITICAL(HW_GPU, "ST_L Unhandled mode: {}",
-                                 static_cast<unsigned>(instr.st_l.unknown.Value()));
-                    UNREACHABLE();
-                }
-
-                switch (instr.ldst_sl.type.Value()) {
-                case Tegra::Shader::StoreType::Bytes32:
-                    regs.SetLocalMemoryAsFloat("index", regs.GetRegisterAsFloat(instr.gpr0));
-                    break;
-                default:
-                    LOG_CRITICAL(HW_GPU, "ST_L Unhandled type: {}",
-                                 static_cast<unsigned>(instr.ldst_sl.type.Value()));
-                    UNREACHABLE();
-                }
-
-                --shader.scope;
-                shader.AddLine('}');
-                break;
-            }
             case OpCode::Id::TEX: {
                 Tegra::Shader::TextureType texture_type{instr.tex.texture_type};
                 std::string coord;
@@ -3690,7 +3550,6 @@ private:
     const u32 main_offset;
     Maxwell3D::Regs::ShaderStage stage;
     const std::string& suffix;
-    u64 local_memory_size;
 
     ShaderWriter shader;
     ShaderWriter declarations;

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -19,6 +19,9 @@ ProgramResult GenerateVertexShader(const ShaderSetup& setup) {
     out += Decompiler::GetCommonDeclarations();
 
     out += R"(
+out gl_PerVertex {
+    vec4 gl_Position;
+};
 
 layout (location = 0) out vec4 position;
 

src/video_core/renderer_opengl/gl_state.cpp

@@ -11,10 +11,9 @@
 namespace OpenGL {
 
 OpenGLState OpenGLState::cur_state;
-bool OpenGLState::s_rgb_used;
+
 OpenGLState::OpenGLState() {
     // These all match default OpenGL values
-    framebuffer_srgb.enabled = false;
     cull.enabled = false;
     cull.mode = GL_BACK;
     cull.front_face = GL_CCW;
@@ -22,11 +21,6 @@ OpenGLState::OpenGLState() {
     depth.test_enabled = false;
     depth.test_func = GL_LESS;
     depth.write_mask = GL_TRUE;
-    depth.depth_range_near = 0.0f;
-    depth.depth_range_far = 1.0f;
-
-    primitive_restart.enabled = false;
-    primitive_restart.index = 0;
 
     color_mask.red_enabled = GL_TRUE;
     color_mask.green_enabled = GL_TRUE;
@@ -90,16 +84,6 @@ OpenGLState::OpenGLState() {
 }
 
 void OpenGLState::Apply() const {
-    // sRGB
-    if (framebuffer_srgb.enabled != cur_state.framebuffer_srgb.enabled) {
-        if (framebuffer_srgb.enabled) {
-            // Track if sRGB is used
-            s_rgb_used = true;
-            glEnable(GL_FRAMEBUFFER_SRGB);
-        } else {
-            glDisable(GL_FRAMEBUFFER_SRGB);
-        }
-    }
     // Culling
     if (cull.enabled != cur_state.cull.enabled) {
         if (cull.enabled) {
@@ -135,24 +119,6 @@ void OpenGLState::Apply() const {
         glDepthMask(depth.write_mask);
     }
 
-    // Depth range
-    if (depth.depth_range_near != cur_state.depth.depth_range_near ||
-        depth.depth_range_far != cur_state.depth.depth_range_far) {
-        glDepthRange(depth.depth_range_near, depth.depth_range_far);
-    }
-
-    // Primitive restart
-    if (primitive_restart.enabled != cur_state.primitive_restart.enabled) {
-        if (primitive_restart.enabled) {
-            glEnable(GL_PRIMITIVE_RESTART);
-        } else {
-            glDisable(GL_PRIMITIVE_RESTART);
-        }
-    }
-    if (primitive_restart.index != cur_state.primitive_restart.index) {
-        glPrimitiveRestartIndex(primitive_restart.index);
-    }
-
     // Color mask
     if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
         color_mask.green_enabled != cur_state.color_mask.green_enabled ||

src/video_core/renderer_opengl/gl_state.h

@@ -35,10 +35,6 @@ constexpr TextureUnit ProcTexDiffLUT{9};
 
 class OpenGLState {
 public:
-    struct {
-        bool enabled; // GL_FRAMEBUFFER_SRGB
-    } framebuffer_srgb;
-
     struct {
         bool enabled;      // GL_CULL_FACE
         GLenum mode;       // GL_CULL_FACE_MODE
@@ -46,18 +42,11 @@ public:
     } cull;
 
     struct {
-        bool test_enabled;        // GL_DEPTH_TEST
-        GLenum test_func;         // GL_DEPTH_FUNC
-        GLboolean write_mask;     // GL_DEPTH_WRITEMASK
-        GLfloat depth_range_near; // GL_DEPTH_RANGE
-        GLfloat depth_range_far;  // GL_DEPTH_RANGE
+        bool test_enabled;    // GL_DEPTH_TEST
+        GLenum test_func;     // GL_DEPTH_FUNC
+        GLboolean write_mask; // GL_DEPTH_WRITEMASK
     } depth;
 
-    struct {
-        bool enabled;
-        GLuint index;
-    } primitive_restart; // GL_PRIMITIVE_RESTART
-
     struct {
         GLboolean red_enabled;
         GLboolean green_enabled;
@@ -165,12 +154,7 @@ public:
     static OpenGLState GetCurState() {
         return cur_state;
     }
-    static bool GetsRGBUsed() {
-        return s_rgb_used;
-    }
-    static void ClearsRGBUsed() {
-        s_rgb_used = false;
-    }
+
     /// Apply this state as the current OpenGL state
     void Apply() const;
 
@@ -185,9 +169,6 @@ public:
 
 private:
     static OpenGLState cur_state;
-    // Workaround for sRGB problems caused by
-    // QT not supporting srgb output
-    static bool s_rgb_used;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -283,8 +283,7 @@ void RendererOpenGL::CreateRasterizer() {
     if (rasterizer) {
         return;
     }
-    // Initialize sRGB Usage
-    OpenGLState::ClearsRGBUsed();
+
     rasterizer = std::make_unique<RasterizerOpenGL>(render_window, screen_info);
 }
 
@@ -357,20 +356,13 @@ void RendererOpenGL::DrawScreenTriangles(const ScreenInfo& screen_info, float x,
 
     state.texture_units[0].texture = screen_info.display_texture;
     state.texture_units[0].swizzle = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA};
-    // Workaround brigthness problems in SMO by enabling sRGB in the final output
-    // if it has been used in the frame
-    // Needed because of this bug in QT
-    // QTBUG-50987
-    state.framebuffer_srgb.enabled = OpenGLState::GetsRGBUsed();
     state.Apply();
+
     glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices.data());
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    // restore default state
-    state.framebuffer_srgb.enabled = false;
+
     state.texture_units[0].texture = 0;
     state.Apply();
-    // Clear sRGB state for the next frame
-    OpenGLState::ClearsRGBUsed();
 }
 
 /**

src/video_core/textures/decoders.cpp

@@ -142,6 +142,7 @@ void SwizzledData(u8* swizzled_data, u8* unswizzled_data, const bool unswizzle,
     const u32 blocks_on_x = div_ceil(width, block_x_elements);
     const u32 blocks_on_y = div_ceil(height, block_y_elements);
     const u32 blocks_on_z = div_ceil(depth, block_z_elements);
+    const u32 blocks = blocks_on_x * blocks_on_y * blocks_on_z;
     const u32 gob_size = gob_x_bytes * gob_elements_y * gob_elements_z;
     const u32 xy_block_size = gob_size * block_height;
     const u32 block_size = xy_block_size * block_depth;
@@ -319,13 +320,13 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                           u32 block_height, u32 block_depth) {
     if (tiled) {
-        const u32 gobs_in_x = 64;
+        const u32 gobs_in_x = 64 / bytes_per_pixel;
         const u32 gobs_in_y = 8;
         const u32 gobs_in_z = 1;
-        const u32 aligned_width = Common::AlignUp(width * bytes_per_pixel, gobs_in_x);
+        const u32 aligned_width = Common::AlignUp(width, gobs_in_x);
         const u32 aligned_height = Common::AlignUp(height, gobs_in_y * block_height);
         const u32 aligned_depth = Common::AlignUp(depth, gobs_in_z * block_depth);
-        return aligned_width * aligned_height * aligned_depth;
+        return aligned_width * aligned_height * aligned_depth * bytes_per_pixel;
     } else {
         return width * height * depth * bytes_per_pixel;
     }

src/video_core/textures/texture.h

@@ -173,7 +173,6 @@ struct TICEntry {
     };
     union {
         BitField<0, 16, u32> width_minus_1;
-        BitField<22, 1, u32> srgb_conversion;
         BitField<23, 4, TextureType> texture_type;
     };
     union {
@@ -228,10 +227,6 @@ struct TICEntry {
         return header_version == TICHeaderVersion::BlockLinear ||
                header_version == TICHeaderVersion::BlockLinearColorKey;
     }
-
-    bool IsSrgbConversionEnabled() const {
-        return srgb_conversion != 0;
-    }
 };
 static_assert(sizeof(TICEntry) == 0x20, "TICEntry has wrong size");
 

src/yuzu/bootmanager.cpp

@@ -8,6 +8,7 @@
 
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
+#include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/framebuffer_layout.h"
 #include "core/settings.h"
@@ -106,8 +107,9 @@ private:
 GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
     : QWidget(parent), child(nullptr), emu_thread(emu_thread) {
 
-    setWindowTitle(QStringLiteral("yuzu %1 | %2-%3")
-                       .arg(Common::g_build_name, Common::g_scm_branch, Common::g_scm_desc));
+    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_name,
+                                           Common::g_scm_branch, Common::g_scm_desc);
+    setWindowTitle(QString::fromStdString(window_title));
     setAttribute(Qt::WA_AcceptTouchEvents);
 
     InputCommon::Init();

src/yuzu/configuration/config.cpp

@@ -4,7 +4,6 @@
 
 #include <QSettings>
 #include "common/file_util.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "input_common/main.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/ui_settings.h"
@@ -13,16 +12,11 @@ Config::Config() {
     // TODO: Don't hardcode the path; let the frontend decide where to put the config files.
     qt_config_loc = FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) + "qt-config.ini";
     FileUtil::CreateFullPath(qt_config_loc);
-    qt_config =
-        std::make_unique<QSettings>(QString::fromStdString(qt_config_loc), QSettings::IniFormat);
+    qt_config = new QSettings(QString::fromStdString(qt_config_loc), QSettings::IniFormat);
 
     Reload();
 }
 
-Config::~Config() {
-    Save();
-}
-
 const std::array<int, Settings::NativeButton::NumButtons> Config::default_buttons = {
     Qt::Key_A, Qt::Key_S, Qt::Key_Z,    Qt::Key_X,  Qt::Key_3,     Qt::Key_4,    Qt::Key_Q,
     Qt::Key_W, Qt::Key_1, Qt::Key_2,    Qt::Key_N,  Qt::Key_M,     Qt::Key_F,    Qt::Key_T,
@@ -128,11 +122,7 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("System");
     Settings::values.use_docked_mode = qt_config->value("use_docked_mode", false).toBool();
-    Settings::values.enable_nfc = qt_config->value("enable_nfc", true).toBool();
-
-    Settings::values.current_user = std::clamp<int>(qt_config->value("current_user", 0).toInt(), 0,
-                                                    Service::Account::MAX_USERS - 1);
-
+    Settings::values.username = qt_config->value("username", "yuzu").toString().toStdString();
     Settings::values.language_index = qt_config->value("language_index", 1).toInt();
     qt_config->endGroup();
 
@@ -268,9 +258,7 @@ void Config::SaveValues() {
 
     qt_config->beginGroup("System");
     qt_config->setValue("use_docked_mode", Settings::values.use_docked_mode);
-    qt_config->setValue("enable_nfc", Settings::values.enable_nfc);
-    qt_config->setValue("current_user", Settings::values.current_user);
-
+    qt_config->setValue("username", QString::fromStdString(Settings::values.username));
     qt_config->setValue("language_index", Settings::values.language_index);
     qt_config->endGroup();
 
@@ -347,3 +335,9 @@ void Config::Reload() {
 void Config::Save() {
     SaveValues();
 }
+
+Config::~Config() {
+    Save();
+
+    delete qt_config;
+}

src/yuzu/configuration/config.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <memory>
 #include <string>
 #include <QVariant>
 #include "core/settings.h"
@@ -13,6 +12,12 @@
 class QSettings;
 
 class Config {
+    QSettings* qt_config;
+    std::string qt_config_loc;
+
+    void ReadValues();
+    void SaveValues();
+
 public:
     Config();
     ~Config();
@@ -22,11 +27,4 @@ public:
 
     static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
     static const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> default_analogs;
-
-private:
-    void ReadValues();
-    void SaveValues();
-
-    std::unique_ptr<QSettings> qt_config;
-    std::string qt_config_loc;
 };

src/yuzu/configuration/configure_general.cpp

@@ -31,7 +31,6 @@ void ConfigureGeneral::setConfiguration() {
     ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
     ui->use_cpu_jit->setChecked(Settings::values.use_cpu_jit);
     ui->use_docked_mode->setChecked(Settings::values.use_docked_mode);
-    ui->enable_nfc->setChecked(Settings::values.enable_nfc);
 }
 
 void ConfigureGeneral::PopulateHotkeyList(const HotkeyRegistry& registry) {
@@ -46,5 +45,4 @@ void ConfigureGeneral::applyConfiguration() {
 
     Settings::values.use_cpu_jit = ui->use_cpu_jit->isChecked();
     Settings::values.use_docked_mode = ui->use_docked_mode->isChecked();
-    Settings::values.enable_nfc = ui->enable_nfc->isChecked();
 }

src/yuzu/configuration/configure_general.ui

@@ -68,26 +68,19 @@
        <property name="title">
         <string>Emulation</string>
        </property>
-       <layout class="QHBoxLayout" name="EmulationHorizontalLayout">
-        <item>
-         <layout class="QVBoxLayout" name="EmulationVerticalLayout">
+        <layout class="QHBoxLayout" name="EmulationHorizontalLayout">
           <item>
-           <widget class="QCheckBox" name="use_docked_mode">
-            <property name="text">
-             <string>Enable docked mode</string>
-            </property>
-           </widget>
+            <layout class="QVBoxLayout" name="EmulationVerticalLayout">
+              <item>
+                <widget class="QCheckBox" name="use_docked_mode">
+                  <property name="text">
+                    <string>Enable docked mode</string>
+                  </property>
+                </widget>
+              </item>
+            </layout>
           </item>
-          <item>
-           <widget class="QCheckBox" name="enable_nfc">
-            <property name="text">
-             <string>Enable NFC</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-       </layout>
+        </layout>
       </widget>
      </item>
      <item>

src/yuzu/configuration/configure_system.cpp

@@ -2,27 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-#include <QFileDialog>
-#include <QGraphicsItem>
-#include <QGraphicsScene>
-#include <QInputDialog>
 #include <QMessageBox>
-#include <QStandardItemModel>
-#include <QTreeView>
-#include <QVBoxLayout>
-#include "common/common_paths.h"
-#include "common/logging/backend.h"
-#include "common/string_util.h"
 #include "core/core.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "ui_configure_system.h"
 #include "yuzu/configuration/configure_system.h"
 #include "yuzu/main.h"
 
-namespace {
-constexpr std::array<int, 12> days_in_month = {{
+static const std::array<int, 12> days_in_month = {{
     31,
     29,
     31,
@@ -37,102 +24,13 @@ constexpr std::array<int, 12> days_in_month = {{
     31,
 }};
 
-// Same backup JPEG used by acc IProfile::GetImage if no jpeg found
-constexpr std::array<u8, 107> backup_jpeg{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-};
-
-QString GetImagePath(Service::Account::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) {
-    Service::Account::ProfileBase profile;
-    if (!manager.GetProfileBase(uuid, profile)) {
-        return {};
-    }
-
-    const auto text = Common::StringFromFixedZeroTerminatedBuffer(
-        reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
-    return QString::fromStdString(text);
-}
-
-QString FormatUserEntryText(const QString& username, Service::Account::UUID uuid) {
-    return ConfigureSystem::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 icon{GetImagePath(uuid)};
-
-    if (!icon) {
-        icon.fill(Qt::black);
-        icon.loadFromData(backup_jpeg.data(), backup_jpeg.size());
-    }
-
-    return icon.scaled(64, 64, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
-}
-} // Anonymous namespace
-
-ConfigureSystem::ConfigureSystem(QWidget* parent)
-    : QWidget(parent), ui(new Ui::ConfigureSystem),
-      profile_manager(std::make_unique<Service::Account::ProfileManager>()) {
+ConfigureSystem::ConfigureSystem(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureSystem) {
     ui->setupUi(this);
     connect(ui->combo_birthmonth,
             static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-            &ConfigureSystem::UpdateBirthdayComboBox);
+            &ConfigureSystem::updateBirthdayComboBox);
     connect(ui->button_regenerate_console_id, &QPushButton::clicked, this,
-            &ConfigureSystem::RefreshConsoleID);
-
-    layout = new QVBoxLayout;
-    tree_view = new QTreeView;
-    item_model = new QStandardItemModel(tree_view);
-    tree_view->setModel(item_model);
-
-    tree_view->setAlternatingRowColors(true);
-    tree_view->setSelectionMode(QHeaderView::SingleSelection);
-    tree_view->setSelectionBehavior(QHeaderView::SelectRows);
-    tree_view->setVerticalScrollMode(QHeaderView::ScrollPerPixel);
-    tree_view->setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
-    tree_view->setSortingEnabled(true);
-    tree_view->setEditTriggers(QHeaderView::NoEditTriggers);
-    tree_view->setUniformRowHeights(true);
-    tree_view->setIconSize({64, 64});
-    tree_view->setContextMenuPolicy(Qt::NoContextMenu);
-
-    item_model->insertColumns(0, 1);
-    item_model->setHeaderData(0, Qt::Horizontal, "Users");
-
-    // We must register all custom types with the Qt Automoc system so that we are able to use it
-    // with signals/slots. In this case, QList falls under the umbrells of custom types.
-    qRegisterMetaType<QList<QStandardItem*>>("QList<QStandardItem*>");
-
-    layout->setContentsMargins(0, 0, 0, 0);
-    layout->setSpacing(0);
-    layout->addWidget(tree_view);
-
-    ui->scrollArea->setLayout(layout);
-
-    connect(tree_view, &QTreeView::clicked, this, &ConfigureSystem::SelectUser);
-
-    connect(ui->pm_add, &QPushButton::pressed, this, &ConfigureSystem::AddUser);
-    connect(ui->pm_rename, &QPushButton::pressed, this, &ConfigureSystem::RenameUser);
-    connect(ui->pm_remove, &QPushButton::pressed, this, &ConfigureSystem::DeleteUser);
-    connect(ui->pm_set_image, &QPushButton::pressed, this, &ConfigureSystem::SetUserImage);
-
-    scene = new QGraphicsScene;
-    ui->current_user_icon->setScene(scene);
+            &ConfigureSystem::refreshConsoleID);
 
     this->setConfiguration();
 }
@@ -141,45 +39,8 @@ ConfigureSystem::~ConfigureSystem() = default;
 
 void ConfigureSystem::setConfiguration() {
     enabled = !Core::System::GetInstance().IsPoweredOn();
-
+    ui->edit_username->setText(QString::fromStdString(Settings::values.username));
     ui->combo_language->setCurrentIndex(Settings::values.language_index);
-
-    item_model->removeRows(0, item_model->rowCount());
-    list_items.clear();
-
-    PopulateUserList();
-    UpdateCurrentUser();
-}
-
-void ConfigureSystem::PopulateUserList() {
-    const auto& profiles = profile_manager->GetAllUsers();
-    for (const auto& user : profiles) {
-        Service::Account::ProfileBase profile;
-        if (!profile_manager->GetProfileBase(user, profile))
-            continue;
-
-        const auto username = Common::StringFromFixedZeroTerminatedBuffer(
-            reinterpret_cast<const char*>(profile.username.data()), profile.username.size());
-
-        list_items.push_back(QList<QStandardItem*>{new QStandardItem{
-            GetIcon(user), FormatUserEntryText(QString::fromStdString(username), user)}});
-    }
-
-    for (const auto& item : list_items)
-        item_model->appendRow(item);
-}
-
-void ConfigureSystem::UpdateCurrentUser() {
-    ui->pm_add->setEnabled(profile_manager->GetUserCount() < Service::Account::MAX_USERS);
-
-    const auto& current_user = profile_manager->GetUser(Settings::values.current_user);
-    ASSERT(current_user != std::nullopt);
-    const auto username = GetAccountUsername(*profile_manager, *current_user);
-
-    scene->clear();
-    scene->addPixmap(
-        GetIcon(*current_user).scaled(48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
-    ui->current_user_username->setText(username);
 }
 
 void ConfigureSystem::ReadSystemSettings() {}
@@ -187,12 +48,12 @@ void ConfigureSystem::ReadSystemSettings() {}
 void ConfigureSystem::applyConfiguration() {
     if (!enabled)
         return;
-
+    Settings::values.username = ui->edit_username->text().toStdString();
     Settings::values.language_index = ui->combo_language->currentIndex();
     Settings::Apply();
 }
 
-void ConfigureSystem::UpdateBirthdayComboBox(int birthmonth_index) {
+void ConfigureSystem::updateBirthdayComboBox(int birthmonth_index) {
     if (birthmonth_index < 0 || birthmonth_index >= 12)
         return;
 
@@ -217,7 +78,7 @@ void ConfigureSystem::UpdateBirthdayComboBox(int birthmonth_index) {
     ui->combo_birthday->setCurrentIndex(birthday_index);
 }
 
-void ConfigureSystem::RefreshConsoleID() {
+void ConfigureSystem::refreshConsoleID() {
     QMessageBox::StandardButton reply;
     QString warning_text = tr("This will replace your current virtual Switch with a new one. "
                               "Your current virtual Switch will not be recoverable. "
@@ -231,141 +92,3 @@ void ConfigureSystem::RefreshConsoleID() {
     ui->label_console_id->setText(
         tr("Console ID: 0x%1").arg(QString::number(console_id, 16).toUpper()));
 }
-
-void ConfigureSystem::SelectUser(const QModelIndex& index) {
-    Settings::values.current_user =
-        std::clamp<std::size_t>(index.row(), 0, profile_manager->GetUserCount() - 1);
-
-    UpdateCurrentUser();
-
-    ui->pm_remove->setEnabled(profile_manager->GetUserCount() >= 2);
-    ui->pm_rename->setEnabled(true);
-    ui->pm_set_image->setEnabled(true);
-}
-
-void ConfigureSystem::AddUser() {
-    const auto uuid = Service::Account::UUID::Generate();
-
-    bool ok = false;
-    const auto username =
-        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a username for the new user:"),
-                              QLineEdit::Normal, QString(), &ok);
-    if (!ok)
-        return;
-
-    profile_manager->CreateNewUser(uuid, username.toStdString());
-
-    item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
-}
-
-void ConfigureSystem::RenameUser() {
-    const auto user = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(user);
-    ASSERT(uuid != std::nullopt);
-
-    Service::Account::ProfileBase profile;
-    if (!profile_manager->GetProfileBase(*uuid, profile))
-        return;
-
-    bool ok = false;
-    const auto old_username = GetAccountUsername(*profile_manager, *uuid);
-    const auto new_username =
-        QInputDialog::getText(this, tr("Enter Username"), tr("Enter a new username:"),
-                              QLineEdit::Normal, old_username, &ok);
-
-    if (!ok)
-        return;
-
-    std::fill(profile.username.begin(), profile.username.end(), '\0');
-    const auto username_std = new_username.toStdString();
-    if (username_std.size() > profile.username.size()) {
-        std::copy_n(username_std.begin(), std::min(profile.username.size(), username_std.size()),
-                    profile.username.begin());
-    } else {
-        std::copy(username_std.begin(), username_std.end(), profile.username.begin());
-    }
-
-    profile_manager->SetProfileBase(*uuid, profile);
-
-    item_model->setItem(
-        user, 0,
-        new QStandardItem{GetIcon(*uuid),
-                          FormatUserEntryText(QString::fromStdString(username_std), *uuid)});
-    UpdateCurrentUser();
-}
-
-void ConfigureSystem::DeleteUser() {
-    const auto index = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(index);
-    ASSERT(uuid != std::nullopt);
-    const auto username = GetAccountUsername(*profile_manager, *uuid);
-
-    const auto confirm = QMessageBox::question(
-        this, tr("Confirm Delete"),
-        tr("You are about to delete user with name \"%1\". Are you sure?").arg(username));
-
-    if (confirm == QMessageBox::No)
-        return;
-
-    if (Settings::values.current_user == tree_view->currentIndex().row())
-        Settings::values.current_user = 0;
-    UpdateCurrentUser();
-
-    if (!profile_manager->RemoveUser(*uuid))
-        return;
-
-    item_model->removeRows(tree_view->currentIndex().row(), 1);
-    tree_view->clearSelection();
-
-    ui->pm_remove->setEnabled(false);
-    ui->pm_rename->setEnabled(false);
-}
-
-void ConfigureSystem::SetUserImage() {
-    const auto index = tree_view->currentIndex().row();
-    const auto uuid = profile_manager->GetUser(index);
-    ASSERT(uuid != std::nullopt);
-
-    const auto file = QFileDialog::getOpenFileName(this, tr("Select User Image"), QString(),
-                                                   tr("JPEG Images (*.jpg *.jpeg)"));
-
-    if (file.isEmpty()) {
-        return;
-    }
-
-    const auto image_path = GetImagePath(*uuid);
-    if (QFile::exists(image_path) && !QFile::remove(image_path)) {
-        QMessageBox::warning(
-            this, tr("Error deleting image"),
-            tr("Error occurred attempting to overwrite previous image at: %1.").arg(image_path));
-        return;
-    }
-
-    const auto raw_path = QString::fromStdString(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) + "/system/save/8000000000000010");
-    const QFileInfo raw_info{raw_path};
-    if (raw_info.exists() && !raw_info.isDir() && !QFile::remove(raw_path)) {
-        QMessageBox::warning(this, tr("Error deleting file"),
-                             tr("Unable to delete existing file: %1.").arg(raw_path));
-        return;
-    }
-
-    const QString absolute_dst_path = QFileInfo{image_path}.absolutePath();
-    if (!QDir{raw_path}.mkpath(absolute_dst_path)) {
-        QMessageBox::warning(
-            this, tr("Error creating user image directory"),
-            tr("Unable to create directory %1 for storing user images.").arg(absolute_dst_path));
-        return;
-    }
-
-    if (!QFile::copy(file, image_path)) {
-        QMessageBox::warning(this, tr("Error copying user image"),
-                             tr("Unable to copy image from %1 to %2").arg(file, image_path));
-        return;
-    }
-
-    const auto username = GetAccountUsername(*profile_manager, *uuid);
-    item_model->setItem(index, 0,
-                        new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});
-    UpdateCurrentUser();
-}

src/yuzu/configuration/configure_system.h

@@ -5,20 +5,8 @@
 #pragma once
 
 #include <memory>
-
-#include <QList>
 #include <QWidget>
 
-class QGraphicsScene;
-class QStandardItem;
-class QStandardItemModel;
-class QTreeView;
-class QVBoxLayout;
-
-namespace Service::Account {
-class ProfileManager;
-}
-
 namespace Ui {
 class ConfigureSystem;
 }
@@ -28,39 +16,23 @@ class ConfigureSystem : public QWidget {
 
 public:
     explicit ConfigureSystem(QWidget* parent = nullptr);
-    ~ConfigureSystem() override;
+    ~ConfigureSystem();
 
     void applyConfiguration();
     void setConfiguration();
 
+public slots:
+    void updateBirthdayComboBox(int birthmonth_index);
+    void refreshConsoleID();
+
 private:
     void ReadSystemSettings();
 
-    void UpdateBirthdayComboBox(int birthmonth_index);
-    void RefreshConsoleID();
-
-    void PopulateUserList();
-    void UpdateCurrentUser();
-    void SelectUser(const QModelIndex& index);
-    void AddUser();
-    void RenameUser();
-    void DeleteUser();
-    void SetUserImage();
-
-    QVBoxLayout* layout;
-    QTreeView* tree_view;
-    QStandardItemModel* item_model;
-    QGraphicsScene* scene;
-
-    std::vector<QList<QStandardItem*>> list_items;
-
     std::unique_ptr<Ui::ConfigureSystem> ui;
-    bool enabled = false;
+    bool enabled;
 
-    int birthmonth = 0;
-    int birthday = 0;
-    int language_index = 0;
-    int sound_index = 0;
-
-    std::unique_ptr<Service::Account::ProfileManager> profile_manager;
+    std::u16string username;
+    int birthmonth, birthday;
+    int language_index;
+    int sound_index;
 };

src/yuzu/configuration/configure_system.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>360</width>
-    <height>483</height>
+    <height>377</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -22,28 +22,34 @@
         <string>System Settings</string>
        </property>
        <layout class="QGridLayout" name="gridLayout">
-        <item row="1" column="0">
-         <widget class="QLabel" name="label_language">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_username">
           <property name="text">
-           <string>Language</string>
+           <string>Username</string>
           </property>
          </widget>
         </item>
-        <item row="0" column="0">
+        <item row="0" column="1">
+         <widget class="QLineEdit" name="edit_username">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="maxLength">
+           <number>32</number>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
          <widget class="QLabel" name="label_birthday">
           <property name="text">
            <string>Birthday</string>
           </property>
          </widget>
         </item>
-        <item row="3" column="0">
-         <widget class="QLabel" name="label_console_id">
-          <property name="text">
-           <string>Console ID:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
+        <item row="1" column="1">
          <layout class="QHBoxLayout" name="horizontalLayout_birthday2">
           <item>
            <widget class="QComboBox" name="combo_birthmonth">
@@ -114,7 +120,14 @@
           </item>
          </layout>
         </item>
-        <item row="1" column="1">
+        <item row="2" column="0">
+         <widget class="QLabel" name="label_language">
+          <property name="text">
+           <string>Language</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
          <widget class="QComboBox" name="combo_language">
           <property name="toolTip">
            <string>Note: this can be overridden when region setting is auto-select</string>
@@ -174,31 +187,31 @@
             <string>Russian (Русский)</string>
            </property>
           </item>
-          <item>
-           <property name="text">
-            <string>Taiwanese</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>British English</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>Canadian French</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>Latin American Spanish</string>
-           </property>
-          </item>
-          <item>
-           <property name="text">
-            <string>Simplified Chinese</string>
-           </property>
-          </item>
+           <item>
+             <property name="text">
+               <string>Taiwanese</string>
+             </property>
+           </item>
+           <item>
+             <property name="text">
+               <string>British English</string>
+             </property>
+           </item>
+           <item>
+             <property name="text">
+               <string>Canadian French</string>
+             </property>
+           </item>
+           <item>
+             <property name="text">
+               <string>Latin American Spanish</string>
+             </property>
+           </item>
+           <item>
+             <property name="text">
+               <string>Simplified Chinese</string>
+             </property>
+           </item>
           <item>
            <property name="text">
             <string>Traditional Chinese (正體中文)</string>
@@ -206,14 +219,14 @@
           </item>
          </widget>
         </item>
-        <item row="2" column="0">
+        <item row="3" column="0">
          <widget class="QLabel" name="label_sound">
           <property name="text">
            <string>Sound output mode</string>
           </property>
          </widget>
         </item>
-        <item row="2" column="1">
+        <item row="3" column="1">
          <widget class="QComboBox" name="combo_sound">
           <item>
            <property name="text">
@@ -232,7 +245,14 @@
           </item>
          </widget>
         </item>
-        <item row="3" column="1">
+        <item row="4" column="0">
+         <widget class="QLabel" name="label_console_id">
+          <property name="text">
+           <string>Console ID:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="1">
          <widget class="QPushButton" name="button_regenerate_console_id">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
@@ -251,143 +271,6 @@
        </layout>
       </widget>
      </item>
-     <item>
-      <widget class="QGroupBox" name="gridGroupBox">
-       <property name="title">
-        <string>Profile Manager</string>
-       </property>
-       <layout class="QGridLayout" name="gridLayout_2">
-        <property name="sizeConstraint">
-         <enum>QLayout::SetNoConstraint</enum>
-        </property>
-        <item row="0" column="0">
-         <layout class="QHBoxLayout" name="horizontalLayout_2">
-          <item>
-           <widget class="QLabel" name="label">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="text">
-             <string>Current User</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QGraphicsView" name="current_user_icon">
-            <property name="minimumSize">
-             <size>
-              <width>48</width>
-              <height>48</height>
-             </size>
-            </property>
-            <property name="maximumSize">
-             <size>
-              <width>48</width>
-              <height>48</height>
-             </size>
-            </property>
-            <property name="verticalScrollBarPolicy">
-             <enum>Qt::ScrollBarAlwaysOff</enum>
-            </property>
-            <property name="horizontalScrollBarPolicy">
-             <enum>Qt::ScrollBarAlwaysOff</enum>
-            </property>
-            <property name="interactive">
-             <bool>false</bool>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QLabel" name="current_user_username">
-            <property name="sizePolicy">
-             <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-              <horstretch>0</horstretch>
-              <verstretch>0</verstretch>
-             </sizepolicy>
-            </property>
-            <property name="text">
-             <string>Username</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item row="1" column="0">
-         <widget class="QScrollArea" name="scrollArea">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="frameShape">
-           <enum>QFrame::StyledPanel</enum>
-          </property>
-          <property name="widgetResizable">
-           <bool>false</bool>
-          </property>
-         </widget>
-        </item>
-        <item row="2" column="0">
-         <layout class="QHBoxLayout" name="horizontalLayout_3">
-          <item>
-           <widget class="QPushButton" name="pm_set_image">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Set Image</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <spacer name="horizontalSpacer">
-            <property name="orientation">
-             <enum>Qt::Horizontal</enum>
-            </property>
-            <property name="sizeHint" stdset="0">
-             <size>
-              <width>40</width>
-              <height>20</height>
-             </size>
-            </property>
-           </spacer>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_add">
-            <property name="text">
-             <string>Add</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_rename">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Rename</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QPushButton" name="pm_remove">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="text">
-             <string>Remove</string>
-            </property>
-           </widget>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
-     </item>
      <item>
       <widget class="QLabel" name="label_disable_info">
        <property name="text">
@@ -398,6 +281,19 @@
        </property>
       </widget>
      </item>
+     <item>
+      <spacer name="verticalSpacer">
+       <property name="orientation">
+        <enum>Qt::Vertical</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>20</width>
+         <height>40</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
     </layout>
    </item>
   </layout>

src/yuzu/debugger/graphics/graphics_breakpoints.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <map>
 #include <QLabel>
 #include <QMetaType>
 #include <QPushButton>
@@ -31,8 +32,21 @@ QVariant BreakPointModel::data(const QModelIndex& index, int role) const {
     switch (role) {
     case Qt::DisplayRole: {
         if (index.column() == 0) {
-            return DebugContextEventToString(event);
+            static const std::map<Tegra::DebugContext::Event, QString> map = {
+                {Tegra::DebugContext::Event::MaxwellCommandLoaded, tr("Maxwell command loaded")},
+                {Tegra::DebugContext::Event::MaxwellCommandProcessed,
+                 tr("Maxwell command processed")},
+                {Tegra::DebugContext::Event::IncomingPrimitiveBatch,
+                 tr("Incoming primitive batch")},
+                {Tegra::DebugContext::Event::FinishedPrimitiveBatch,
+                 tr("Finished primitive batch")},
+            };
+
+            DEBUG_ASSERT(map.size() ==
+                         static_cast<std::size_t>(Tegra::DebugContext::Event::NumEvents));
+            return (map.find(event) != map.end()) ? map.at(event) : QString();
         }
+
         break;
     }
 
@@ -114,23 +128,6 @@ void BreakPointModel::OnResumed() {
     active_breakpoint = context->active_breakpoint;
 }
 
-QString BreakPointModel::DebugContextEventToString(Tegra::DebugContext::Event event) {
-    switch (event) {
-    case Tegra::DebugContext::Event::MaxwellCommandLoaded:
-        return tr("Maxwell command loaded");
-    case Tegra::DebugContext::Event::MaxwellCommandProcessed:
-        return tr("Maxwell command processed");
-    case Tegra::DebugContext::Event::IncomingPrimitiveBatch:
-        return tr("Incoming primitive batch");
-    case Tegra::DebugContext::Event::FinishedPrimitiveBatch:
-        return tr("Finished primitive batch");
-    case Tegra::DebugContext::Event::NumEvents:
-        break;
-    }
-
-    return tr("Unknown debug context event");
-}
-
 GraphicsBreakPointsWidget::GraphicsBreakPointsWidget(
     std::shared_ptr<Tegra::DebugContext> debug_context, QWidget* parent)
     : QDockWidget(tr("Maxwell Breakpoints"), parent), Tegra::DebugContext::BreakPointObserver(

src/yuzu/debugger/graphics/graphics_breakpoints_p.h

@@ -29,8 +29,6 @@ public:
     void OnResumed();
 
 private:
-    static QString DebugContextEventToString(Tegra::DebugContext::Event event);
-
     std::weak_ptr<Tegra::DebugContext> context_weak;
     bool at_breakpoint;
     Tegra::DebugContext::Event active_breakpoint;

src/yuzu/game_list.cpp

@@ -16,6 +16,7 @@
 #include <fmt/format.h>
 #include "common/common_paths.h"
 #include "common/common_types.h"
+#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/patch_manager.h"
 #include "yuzu/compatibility_list.h"
@@ -216,11 +217,11 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent)
     tree_view->setContextMenuPolicy(Qt::CustomContextMenu);
 
     item_model->insertColumns(0, COLUMN_COUNT);
-    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
-    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
-    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
-    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
-    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, "Name");
+    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, "Compatibility");
+    item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, "Add-ons");
+    item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, "File type");
+    item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, "Size");
 
     connect(tree_view, &QTreeView::activated, this, &GameList::ValidateEntry);
     connect(tree_view, &QTreeView::customContextMenuRequested, this, &GameList::PopupContextMenu);
@@ -386,9 +387,9 @@ void GameList::LoadCompatibilityList() {
 }
 
 void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
-    const QFileInfo dir_info{dir_path};
-    if (!dir_info.exists() || !dir_info.isDir()) {
-        LOG_ERROR(Frontend, "Could not find game list folder at {}", dir_path.toStdString());
+    if (!FileUtil::Exists(dir_path.toStdString()) ||
+        !FileUtil::IsDirectory(dir_path.toStdString())) {
+        LOG_ERROR(Frontend, "Could not find game list folder at {}", dir_path.toLocal8Bit().data());
         search_field->setFilterResult(0, 0);
         return;
     }

src/yuzu/game_list_worker.cpp

@@ -62,24 +62,19 @@ QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager,
     FileSys::VirtualFile update_raw;
     loader.ReadUpdateRaw(update_raw);
     for (const auto& kv : patch_manager.GetPatchVersionNames(update_raw)) {
-        const bool is_update = kv.first == "Update";
-        if (!updatable && is_update) {
+        if (!updatable && kv.first == "Update")
             continue;
-        }
-
-        const QString type = QString::fromStdString(kv.first);
 
         if (kv.second.empty()) {
-            out.append(QStringLiteral("%1\n").arg(type));
+            out.append(fmt::format("{}\n", kv.first).c_str());
         } else {
             auto ver = kv.second;
 
             // Display container name for packed updates
-            if (is_update && ver == "PACKED") {
+            if (ver == "PACKED" && kv.first == "Update")
                 ver = Loader::GetFileTypeString(loader.GetFileType());
-            }
 
-            out.append(QStringLiteral("%1 (%2)\n").arg(type, QString::fromStdString(ver)));
+            out.append(fmt::format("{} ({})\n", kv.first, ver).c_str());
         }
     }
 

src/yuzu/main.cpp

@@ -10,7 +10,6 @@
 // VFS includes must be before glad as they will conflict with Windows file api, which uses defines.
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/hle/service/acc/profile_manager.h"
 
 // These are wrappers to avoid the calls to CreateDirectory and CreateFile becuase of the Windows
 // defines.
@@ -30,7 +29,6 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #define QT_NO_OPENGL
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
-#include <QFile>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QtConcurrent/QtConcurrent>
@@ -62,8 +60,6 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_ldr.h"
-#include "core/hle/service/nfp/nfp.h"
-#include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
 #include "core/settings.h"
@@ -104,8 +100,6 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
 
-constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
-
 /**
  * "Callouts" are one-time instructional messages shown to the user. In the config settings, there
  * is a bitfield "callout_flags" options, used to track if a message has already been shown to the
@@ -428,7 +422,6 @@ void GMainWindow::ConnectMenuEvents() {
     connect(ui.action_Select_SDMC_Directory, &QAction::triggered, this,
             [this] { OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget::SDMC); });
     connect(ui.action_Exit, &QAction::triggered, this, &QMainWindow::close);
-    connect(ui.action_Load_Amiibo, &QAction::triggered, this, &GMainWindow::OnLoadAmiibo);
 
     // Emulation
     connect(ui.action_Start, &QAction::triggered, this, &GMainWindow::OnStartGame);
@@ -697,7 +690,6 @@ void GMainWindow::ShutdownGame() {
     ui.action_Stop->setEnabled(false);
     ui.action_Restart->setEnabled(false);
     ui.action_Report_Compatibility->setEnabled(false);
-    ui.action_Load_Amiibo->setEnabled(false);
     render_window->hide();
     game_list->show();
     game_list->setFilterFocus();
@@ -759,43 +751,12 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
         open_target = "Save Data";
         const std::string nand_dir = FileUtil::GetUserPath(FileUtil::UserPath::NANDDir);
         ASSERT(program_id != 0);
-
-        Service::Account::ProfileManager manager{};
-        const auto user_ids = manager.GetAllUsers();
-        QStringList list;
-        for (const auto& user_id : user_ids) {
-            if (user_id == Service::Account::UUID{})
-                continue;
-            Service::Account::ProfileBase base;
-            if (!manager.GetProfileBase(user_id, base))
-                continue;
-
-            list.push_back(QString::fromStdString(Common::StringFromFixedZeroTerminatedBuffer(
-                reinterpret_cast<const char*>(base.username.data()), base.username.size())));
-        }
-
-        bool ok = false;
-        const auto index_string =
-            QInputDialog::getItem(this, tr("Select User"),
-                                  tr("Please select the user's save data you would like to open."),
-                                  list, Settings::values.current_user, false, &ok);
-        if (!ok)
-            return;
-
-        const auto index = list.indexOf(index_string);
-        ASSERT(index != -1 && index < 8);
-
-        const auto user_id = manager.GetUser(index);
-        ASSERT(user_id != std::nullopt);
+        // TODO(tech4me): Update this to work with arbitrary user profile
+        // Refer to core/hle/service/acc/profile_manager.cpp ProfileManager constructor
+        constexpr u128 user_id = {1, 0};
         path = nand_dir + FileSys::SaveDataFactory::GetFullPath(FileSys::SaveDataSpaceId::NandUser,
                                                                 FileSys::SaveDataType::SaveData,
-                                                                program_id, user_id->uuid, 0);
-
-        if (!FileUtil::Exists(path)) {
-            FileUtil::CreateFullPath(path);
-            FileUtil::CreateDir(path);
-        }
-
+                                                                program_id, user_id, 0);
         break;
     }
     case GameListOpenTarget::ModData: {
@@ -862,10 +823,14 @@ static bool RomFSRawCopy(QProgressDialog& dialog, const FileSys::VirtualDir& src
 }
 
 void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_path) {
-    const auto failed = [this] {
+    const auto path = fmt::format("{}{:016X}/romfs",
+                                  FileUtil::GetUserPath(FileUtil::UserPath::DumpDir), program_id);
+
+    const auto failed = [this, &path] {
         QMessageBox::warning(this, tr("RomFS Extraction Failed!"),
                              tr("There was an error copying the RomFS files or the user "
                                 "cancelled the operation."));
+        vfs->DeleteDirectory(path);
     };
 
     const auto loader = Loader::GetLoader(vfs->OpenFile(game_path, FileSys::Mode::Read));
@@ -880,24 +845,10 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
         return;
     }
 
-    const auto installed = Service::FileSystem::GetUnionContents();
-    auto romfs_title_id = SelectRomFSDumpTarget(*installed, program_id);
-
-    if (!romfs_title_id) {
-        failed();
-        return;
-    }
-
-    const auto path = fmt::format(
-        "{}{:016X}/romfs", FileUtil::GetUserPath(FileUtil::UserPath::DumpDir), *romfs_title_id);
-
-    FileSys::VirtualFile romfs;
-
-    if (*romfs_title_id == program_id) {
-        romfs = file;
-    } else {
-        romfs = installed->GetEntry(*romfs_title_id, FileSys::ContentRecordType::Data)->GetRomFS();
-    }
+    const auto romfs =
+        loader->IsRomFSUpdatable()
+            ? FileSys::PatchManager(program_id).PatchRomFS(file, loader->ReadRomFSIVFCOffset())
+            : file;
 
     const auto extracted = FileSys::ExtractRomFS(romfs, FileSys::RomFSExtractionType::Full);
     if (extracted == nullptr) {
@@ -909,7 +860,6 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
 
     if (out == nullptr) {
         failed();
-        vfs->DeleteDirectory(path);
         return;
     }
 
@@ -920,11 +870,8 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
            "files into the new directory while <br>skeleton will only create the directory "
            "structure."),
         {"Full", "Skeleton"}, 0, false, &ok);
-    if (!ok) {
+    if (!ok)
         failed();
-        vfs->DeleteDirectory(path);
-        return;
-    }
 
     const auto full = res == "Full";
     const auto entry_size = CalculateRomFSEntrySize(extracted, full);
@@ -941,7 +888,6 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
     } else {
         progress.close();
         failed();
-        vfs->DeleteDirectory(path);
     }
 }
 
@@ -1228,7 +1174,6 @@ void GMainWindow::OnStartGame() {
     ui.action_Report_Compatibility->setEnabled(true);
 
     discord_rpc->Update();
-    ui.action_Load_Amiibo->setEnabled(true);
 }
 
 void GMainWindow::OnPauseGame() {
@@ -1333,47 +1278,6 @@ void GMainWindow::OnConfigure() {
     }
 }
 
-void GMainWindow::OnLoadAmiibo() {
-    const QString extensions{"*.bin"};
-    const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions);
-    const QString filename = QFileDialog::getOpenFileName(this, tr("Load Amiibo"), "", file_filter);
-
-    if (filename.isEmpty()) {
-        return;
-    }
-
-    Core::System& system{Core::System::GetInstance()};
-    Service::SM::ServiceManager& sm = system.ServiceManager();
-    auto nfc = sm.GetService<Service::NFP::Module::Interface>("nfp:user");
-    if (nfc == nullptr) {
-        return;
-    }
-
-    QFile nfc_file{filename};
-    if (!nfc_file.open(QIODevice::ReadOnly)) {
-        QMessageBox::warning(this, tr("Error opening Amiibo data file"),
-                             tr("Unable to open Amiibo file \"%1\" for reading.").arg(filename));
-        return;
-    }
-
-    const u64 nfc_file_size = nfc_file.size();
-    std::vector<u8> buffer(nfc_file_size);
-    const u64 read_size = nfc_file.read(reinterpret_cast<char*>(buffer.data()), nfc_file_size);
-    if (nfc_file_size != read_size) {
-        QMessageBox::warning(this, tr("Error reading Amiibo data file"),
-                             tr("Unable to fully read Amiibo data. Expected to read %1 bytes, but "
-                                "was only able to read %2 bytes.")
-                                 .arg(nfc_file_size)
-                                 .arg(read_size));
-        return;
-    }
-
-    if (!nfc->LoadAmiibo(buffer)) {
-        QMessageBox::warning(this, tr("Error loading Amiibo data"),
-                             tr("Unable to load Amiibo data."));
-    }
-}
-
 void GMainWindow::OnAbout() {
     AboutDialog aboutDialog(this);
     aboutDialog.exec();
@@ -1414,17 +1318,15 @@ void GMainWindow::UpdateStatusBar() {
 void GMainWindow::OnCoreError(Core::System::ResultStatus result, std::string details) {
     QMessageBox::StandardButton answer;
     QString status_message;
-    const QString common_message =
-        tr("The game you are trying to load requires additional files from your Switch to be "
-           "dumped "
-           "before playing.<br/><br/>For more information on dumping these files, please see the "
-           "following wiki page: <a "
-           "href='https://yuzu-emu.org/wiki/"
-           "dumping-system-archives-and-the-shared-fonts-from-a-switch-console/'>Dumping System "
-           "Archives and the Shared Fonts from a Switch Console</a>.<br/><br/>Would you like to "
-           "quit "
-           "back to the game list? Continuing emulation may result in crashes, corrupted save "
-           "data, or other bugs.");
+    const QString common_message = tr(
+        "The game you are trying to load requires additional files from your Switch to be dumped "
+        "before playing.<br/><br/>For more information on dumping these files, please see the "
+        "following wiki page: <a "
+        "href='https://yuzu-emu.org/wiki/"
+        "dumping-system-archives-and-the-shared-fonts-from-a-switch-console/'>Dumping System "
+        "Archives and the Shared Fonts from a Switch Console</a>.<br/><br/>Would you like to quit "
+        "back to the game list? Continuing emulation may result in crashes, corrupted save "
+        "data, or other bugs.");
     switch (result) {
     case Core::System::ResultStatus::ErrorSystemFiles: {
         QString message = "yuzu was unable to locate a Switch system archive";
@@ -1455,12 +1357,9 @@ void GMainWindow::OnCoreError(Core::System::ResultStatus result, std::string det
             this, tr("Fatal Error"),
             tr("yuzu has encountered a fatal error, please see the log for more details. "
                "For more information on accessing the log, please see the following page: "
-               "<a href='https://community.citra-emu.org/t/how-to-upload-the-log-file/296'>How "
-               "to "
-               "Upload the Log File</a>.<br/><br/>Would you like to quit back to the game "
-               "list? "
-               "Continuing emulation may result in crashes, corrupted save data, or other "
-               "bugs."),
+               "<a href='https://community.citra-emu.org/t/how-to-upload-the-log-file/296'>How to "
+               "Upload the Log File</a>.<br/><br/>Would you like to quit back to the game list? "
+               "Continuing emulation may result in crashes, corrupted save data, or other bugs."),
             QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
         status_message = "Fatal Error encountered";
         break;
@@ -1560,42 +1459,6 @@ void GMainWindow::OnReinitializeKeys(ReinitializeKeyBehavior behavior) {
     }
 }
 
-boost::optional<u64> GMainWindow::SelectRomFSDumpTarget(
-    const FileSys::RegisteredCacheUnion& installed, u64 program_id) {
-    const auto dlc_entries =
-        installed.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
-    std::vector<FileSys::RegisteredCacheEntry> dlc_match;
-    dlc_match.reserve(dlc_entries.size());
-    std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
-                 [&program_id, &installed](const FileSys::RegisteredCacheEntry& entry) {
-                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == program_id &&
-                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
-                 });
-
-    std::vector<u64> romfs_tids;
-    romfs_tids.push_back(program_id);
-    for (const auto& entry : dlc_match)
-        romfs_tids.push_back(entry.title_id);
-
-    if (romfs_tids.size() > 1) {
-        QStringList list{"Base"};
-        for (std::size_t i = 1; i < romfs_tids.size(); ++i)
-            list.push_back(QStringLiteral("DLC %1").arg(romfs_tids[i] & 0x7FF));
-
-        bool ok;
-        const auto res = QInputDialog::getItem(
-            this, tr("Select RomFS Dump Target"),
-            tr("Please select which RomFS you would like to dump."), list, 0, false, &ok);
-        if (!ok) {
-            return boost::none;
-        }
-
-        return romfs_tids[list.indexOf(res)];
-    }
-
-    return program_id;
-}
-
 bool GMainWindow::ConfirmClose() {
     if (emu_thread == nullptr || !UISettings::values.confirm_before_closing)
         return true;

src/yuzu/main.h

@@ -10,7 +10,6 @@
 #include <QMainWindow>
 #include <QTimer>
 
-#include <boost/optional.hpp>
 #include "common/common_types.h"
 #include "core/core.h"
 #include "ui_main.h"
@@ -30,9 +29,8 @@ class WaitTreeWidget;
 enum class GameListOpenTarget;
 
 namespace FileSys {
-class RegisteredCacheUnion;
 class VfsFilesystem;
-} // namespace FileSys
+}
 
 namespace Tegra {
 class DebugContext;
@@ -166,7 +164,6 @@ private slots:
     void OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget target);
     void OnMenuRecentFile();
     void OnConfigure();
-    void OnLoadAmiibo();
     void OnAbout();
     void OnToggleFilterBar();
     void OnDisplayTitleBars(bool);
@@ -178,8 +175,6 @@ private slots:
     void OnReinitializeKeys(ReinitializeKeyBehavior behavior);
 
 private:
-    boost::optional<u64> SelectRomFSDumpTarget(const FileSys::RegisteredCacheUnion&,
-                                               u64 program_id);
     void UpdateStatusBar();
 
     Ui::MainWindow ui;

src/yuzu/main.ui

@@ -57,8 +57,8 @@
       <string>Recent Files</string>
      </property>
     </widget>
-    <addaction name="action_Install_File_NAND"/>
-    <addaction name="separator"/>
+     <addaction name="action_Install_File_NAND" />
+     <addaction name="separator"/>
     <addaction name="action_Load_File"/>
     <addaction name="action_Load_Folder"/>
     <addaction name="separator"/>
@@ -68,8 +68,6 @@
     <addaction name="action_Select_NAND_Directory"/>
     <addaction name="action_Select_SDMC_Directory"/>
     <addaction name="separator"/>
-    <addaction name="action_Load_Amiibo"/>
-    <addaction name="separator"/>
     <addaction name="action_Exit"/>
    </widget>
    <widget class="QMenu" name="menu_Emulation">
@@ -119,14 +117,11 @@
    <addaction name="menu_Tools" />
    <addaction name="menu_Help"/>
   </widget>
-  <action name="action_Install_File_NAND">
-   <property name="enabled">
-    <bool>true</bool>
-   </property>
-   <property name="text">
-    <string>Install File to NAND...</string>
-   </property>
-  </action>
+   <action name="action_Install_File_NAND">
+     <property name="text">
+       <string>Install File to NAND...</string>
+     </property>
+   </action>
   <action name="action_Load_File">
    <property name="text">
     <string>Load File...</string>
@@ -258,14 +253,6 @@
        <string>Restart</string>
      </property>
    </action>
-  <action name="action_Load_Amiibo">
-    <property name="enabled">
-      <bool>false</bool>
-    </property>
-    <property name="text">
-      <string>Load Amiibo...</string>
-    </property>
-  </action>
    <action name="action_Report_Compatibility">
      <property name="enabled">
        <bool>false</bool>

src/yuzu_cmd/config.cpp

@@ -8,7 +8,6 @@
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/param_package.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 #include "input_common/main.h"
 #include "yuzu_cmd/config.h"
@@ -126,11 +125,10 @@ void Config::ReadValues() {
 
     // System
     Settings::values.use_docked_mode = sdl2_config->GetBoolean("System", "use_docked_mode", false);
-    Settings::values.enable_nfc = sdl2_config->GetBoolean("System", "enable_nfc", true);
-    const auto size = sdl2_config->GetInteger("System", "users_size", 0);
-
-    Settings::values.current_user = std::clamp<int>(
-        sdl2_config->GetInteger("System", "current_user", 0), 0, Service::Account::MAX_USERS - 1);
+    Settings::values.username = sdl2_config->Get("System", "username", "yuzu");
+    if (Settings::values.username.empty()) {
+        Settings::values.username = "yuzu";
+    }
 
     // Miscellaneous
     Settings::values.log_filter = sdl2_config->Get("Miscellaneous", "log_filter", "*:Trace");

src/yuzu_cmd/default_ini.h

@@ -174,10 +174,6 @@ use_virtual_sd =
 # 1: Yes, 0 (default): No
 use_docked_mode =
 
-# Allow the use of NFC in games
-# 1 (default): Yes, 0 : No
-enable_nfc =
-
 # Sets the account username, max length is 32 characters
 # yuzu (default)
 username = yuzu