buffer_cache: reset cached write bits after flushing invalidations

Add include to fix compiling

src/core/CMakeLists.txt

@@ -122,8 +122,8 @@ add_library(core STATIC
     frontend/applets/error.h
     frontend/applets/general_frontend.cpp
     frontend/applets/general_frontend.h
-    frontend/applets/mii.cpp
-    frontend/applets/mii.h
+    frontend/applets/mii_edit.cpp
+    frontend/applets/mii_edit.h
     frontend/applets/profile_select.cpp
     frontend/applets/profile_select.h
     frontend/applets/software_keyboard.cpp
@@ -306,8 +306,9 @@ add_library(core STATIC
     hle/service/am/applets/applet_error.h
     hle/service/am/applets/applet_general_backend.cpp
     hle/service/am/applets/applet_general_backend.h
-    hle/service/am/applets/applet_mii.cpp
-    hle/service/am/applets/applet_mii.h
+    hle/service/am/applets/applet_mii_edit.cpp
+    hle/service/am/applets/applet_mii_edit.h
+    hle/service/am/applets/applet_mii_edit_types.h
     hle/service/am/applets/applet_profile_select.cpp
     hle/service/am/applets/applet_profile_select.h
     hle/service/am/applets/applet_software_keyboard.cpp

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -148,8 +148,8 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.wall_clock_cntpct = uses_wall_clock;
 
     // Code cache size
-    config.code_cache_size = 128_MiB;
-    config.far_code_offset = 100_MiB;
+    config.code_cache_size = 512_MiB;
+    config.far_code_offset = 400_MiB;
 
     // Safe optimizations
     if (Settings::values.cpu_debug_mode) {

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -208,8 +208,8 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     config.wall_clock_cntpct = uses_wall_clock;
 
     // Code cache size
-    config.code_cache_size = 128_MiB;
-    config.far_code_offset = 100_MiB;
+    config.code_cache_size = 512_MiB;
+    config.far_code_offset = 400_MiB;
 
     // Safe optimizations
     if (Settings::values.cpu_debug_mode) {

src/core/frontend/applets/mii.cpp

@@ -1,19 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/frontend/applets/mii.h"
-
-namespace Core::Frontend {
-
-MiiApplet::~MiiApplet() = default;
-
-void DefaultMiiApplet::ShowMii(
-    const MiiParameters& parameters,
-    const std::function<void(const Core::Frontend::MiiParameters& parameters)> callback) const {
-    LOG_INFO(Service_HID, "(STUBBED) called");
-    callback(parameters);
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/mii.h

@@ -1,34 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-
-#include "core/hle/service/mii/mii_manager.h"
-
-namespace Core::Frontend {
-
-struct MiiParameters {
-    bool is_editable;
-    Service::Mii::MiiInfo mii_data{};
-};
-
-class MiiApplet {
-public:
-    virtual ~MiiApplet();
-
-    virtual void ShowMii(const MiiParameters& parameters,
-                         const std::function<void(const Core::Frontend::MiiParameters& parameters)>
-                             callback) const = 0;
-};
-
-class DefaultMiiApplet final : public MiiApplet {
-public:
-    void ShowMii(const MiiParameters& parameters,
-                 const std::function<void(const Core::Frontend::MiiParameters& parameters)>
-                     callback) const override;
-};
-
-} // namespace Core::Frontend

src/core/frontend/applets/mii_edit.cpp

@@ -0,0 +1,18 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/frontend/applets/mii_edit.h"
+
+namespace Core::Frontend {
+
+MiiEditApplet::~MiiEditApplet() = default;
+
+void DefaultMiiEditApplet::ShowMiiEdit(const std::function<void()>& callback) const {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    callback();
+}
+
+} // namespace Core::Frontend

src/core/frontend/applets/mii_edit.h

@@ -0,0 +1,23 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+
+namespace Core::Frontend {
+
+class MiiEditApplet {
+public:
+    virtual ~MiiEditApplet();
+
+    virtual void ShowMiiEdit(const std::function<void()>& callback) const = 0;
+};
+
+class DefaultMiiEditApplet final : public MiiEditApplet {
+public:
+    void ShowMiiEdit(const std::function<void()>& callback) const override;
+};
+
+} // namespace Core::Frontend

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

@@ -1,100 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/core.h"
-#include "core/frontend/applets/mii.h"
-#include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/applet_mii.h"
-
-namespace Service::AM::Applets {
-
-Mii::Mii(Core::System& system_, LibraryAppletMode applet_mode_,
-         const Core::Frontend::MiiApplet& frontend_)
-    : Applet{system_, applet_mode_}, frontend{frontend_}, system{system_} {}
-
-Mii::~Mii() = default;
-
-void Mii::Initialize() {
-    is_complete = false;
-
-    const auto storage = broker.PopNormalDataToApplet();
-    ASSERT(storage != nullptr);
-
-    const auto data = storage->GetData();
-    ASSERT(data.size() == sizeof(MiiAppletInput));
-
-    std::memcpy(&input_data, data.data(), sizeof(MiiAppletInput));
-}
-
-bool Mii::TransactionComplete() const {
-    return is_complete;
-}
-
-ResultCode Mii::GetStatus() const {
-    return ResultSuccess;
-}
-
-void Mii::ExecuteInteractive() {
-    UNREACHABLE_MSG("Unexpected interactive applet data!");
-}
-
-void Mii::Execute() {
-    if (is_complete) {
-        return;
-    }
-
-    const auto callback = [this](const Core::Frontend::MiiParameters& parameters) {
-        DisplayCompleted(parameters);
-    };
-
-    switch (input_data.applet_mode) {
-    case MiiAppletMode::ShowMiiEdit: {
-        Service::Mii::MiiManager manager;
-        Core::Frontend::MiiParameters params{
-            .is_editable = false,
-            .mii_data = input_data.mii_char_info.mii_data,
-        };
-        frontend.ShowMii(params, callback);
-        break;
-    }
-    case MiiAppletMode::EditMii: {
-        Service::Mii::MiiManager manager;
-        Core::Frontend::MiiParameters params{
-            .is_editable = true,
-            .mii_data = input_data.mii_char_info.mii_data,
-        };
-        frontend.ShowMii(params, callback);
-        break;
-    }
-    case MiiAppletMode::CreateMii: {
-        Service::Mii::MiiManager manager;
-        Core::Frontend::MiiParameters params{
-            .is_editable = true,
-            .mii_data = manager.BuildDefault(0),
-        };
-        frontend.ShowMii(params, callback);
-        break;
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletMiiEdit mode={:02X}!", input_data.applet_mode);
-    }
-}
-
-void Mii::DisplayCompleted(const Core::Frontend::MiiParameters& parameters) {
-    is_complete = true;
-
-    std::vector<u8> reply(sizeof(AppletOutputForCharInfoEditing));
-    output_data = {
-        .result = ResultSuccess,
-        .mii_data = parameters.mii_data,
-    };
-
-    std::memcpy(reply.data(), &output_data, sizeof(AppletOutputForCharInfoEditing));
-    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(reply)));
-    broker.SignalStateChanged();
-}
-
-} // namespace Service::AM::Applets

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

@@ -1,90 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include "core/hle/result.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/mii/mii_manager.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::AM::Applets {
-
-// This is nn::mii::AppletMode
-enum class MiiAppletMode : u32 {
-    ShowMiiEdit = 0,
-    AppendMii = 1,
-    AppendMiiImage = 2,
-    UpdateMiiImage = 3,
-    CreateMii = 4,
-    EditMii = 5,
-};
-
-struct MiiCharInfo {
-    Service::Mii::MiiInfo mii_data{};
-    INSERT_PADDING_BYTES(0x28);
-};
-static_assert(sizeof(MiiCharInfo) == 0x80, "MiiCharInfo has incorrect size.");
-
-// This is nn::mii::AppletInput
-struct MiiAppletInput {
-    s32 version{};
-    MiiAppletMode applet_mode{};
-    u32 special_mii_key_code{};
-    union {
-        std::array<Common::UUID, 8> valid_uuid;
-        MiiCharInfo mii_char_info;
-    };
-    Common::UUID used_uuid;
-    INSERT_PADDING_BYTES(0x64);
-};
-static_assert(sizeof(MiiAppletInput) == 0x100, "MiiAppletInput has incorrect size.");
-
-// This is nn::mii::AppletOutput
-struct MiiAppletOutput {
-    ResultCode result{ResultSuccess};
-    s32 index{};
-    INSERT_PADDING_BYTES(0x18);
-};
-static_assert(sizeof(MiiAppletOutput) == 0x20, "MiiAppletOutput has incorrect size.");
-
-// This is nn::mii::AppletOutputForCharInfoEditing
-struct AppletOutputForCharInfoEditing {
-    ResultCode result{ResultSuccess};
-    Service::Mii::MiiInfo mii_data{};
-    INSERT_PADDING_BYTES(0x24);
-};
-static_assert(sizeof(AppletOutputForCharInfoEditing) == 0x80,
-              "AppletOutputForCharInfoEditing has incorrect size.");
-
-class Mii final : public Applet {
-public:
-    explicit Mii(Core::System& system_, LibraryAppletMode applet_mode_,
-                 const Core::Frontend::MiiApplet& frontend_);
-    ~Mii() override;
-
-    void Initialize() override;
-
-    bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
-    void ExecuteInteractive() override;
-    void Execute() override;
-
-    void DisplayCompleted(const Core::Frontend::MiiParameters& parameters);
-
-private:
-    const Core::Frontend::MiiApplet& frontend;
-    MiiAppletInput input_data{};
-    AppletOutputForCharInfoEditing output_data{};
-
-    bool is_complete = false;
-    Core::System& system;
-};
-
-} // namespace Service::AM::Applets

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

@@ -0,0 +1,139 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/frontend/applets/mii_edit.h"
+#include "core/hle/service/am/am.h"
+#include "core/hle/service/am/applets/applet_mii_edit.h"
+#include "core/hle/service/mii/mii_manager.h"
+
+namespace Service::AM::Applets {
+
+MiiEdit::MiiEdit(Core::System& system_, LibraryAppletMode applet_mode_,
+                 const Core::Frontend::MiiEditApplet& frontend_)
+    : Applet{system_, applet_mode_}, frontend{frontend_}, system{system_} {}
+
+MiiEdit::~MiiEdit() = default;
+
+void MiiEdit::Initialize() {
+    // Note: MiiEdit is not initialized with common arguments.
+    //       Instead, it is initialized by an AppletInput storage with size 0x100 bytes.
+    //       Do NOT call Applet::Initialize() here.
+
+    const auto storage = broker.PopNormalDataToApplet();
+    ASSERT(storage != nullptr);
+
+    const auto applet_input_data = storage->GetData();
+    ASSERT(applet_input_data.size() >= sizeof(MiiEditAppletInputCommon));
+
+    std::memcpy(&applet_input_common, applet_input_data.data(), sizeof(MiiEditAppletInputCommon));
+
+    LOG_INFO(Service_AM,
+             "Initializing MiiEdit Applet with MiiEditAppletVersion={} and MiiEditAppletMode={}",
+             applet_input_common.version, applet_input_common.applet_mode);
+
+    switch (applet_input_common.version) {
+    case MiiEditAppletVersion::Version3:
+        ASSERT(applet_input_data.size() ==
+               sizeof(MiiEditAppletInputCommon) + sizeof(MiiEditAppletInputV3));
+        std::memcpy(&applet_input_v3, applet_input_data.data() + sizeof(MiiEditAppletInputCommon),
+                    sizeof(MiiEditAppletInputV3));
+        break;
+    case MiiEditAppletVersion::Version4:
+        ASSERT(applet_input_data.size() ==
+               sizeof(MiiEditAppletInputCommon) + sizeof(MiiEditAppletInputV4));
+        std::memcpy(&applet_input_v4, applet_input_data.data() + sizeof(MiiEditAppletInputCommon),
+                    sizeof(MiiEditAppletInputV4));
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unknown MiiEditAppletVersion={} with size={}",
+                          applet_input_common.version, applet_input_data.size());
+        ASSERT(applet_input_data.size() >=
+               sizeof(MiiEditAppletInputCommon) + sizeof(MiiEditAppletInputV4));
+        std::memcpy(&applet_input_v4, applet_input_data.data() + sizeof(MiiEditAppletInputCommon),
+                    sizeof(MiiEditAppletInputV4));
+        break;
+    }
+}
+
+bool MiiEdit::TransactionComplete() const {
+    return is_complete;
+}
+
+ResultCode MiiEdit::GetStatus() const {
+    return ResultSuccess;
+}
+
+void MiiEdit::ExecuteInteractive() {
+    UNREACHABLE_MSG("Attempted to call interactive execution on non-interactive applet.");
+}
+
+void MiiEdit::Execute() {
+    if (is_complete) {
+        return;
+    }
+
+    // This is a default stub for each of the MiiEdit applet modes.
+    switch (applet_input_common.applet_mode) {
+    case MiiEditAppletMode::ShowMiiEdit:
+    case MiiEditAppletMode::AppendMii:
+    case MiiEditAppletMode::AppendMiiImage:
+    case MiiEditAppletMode::UpdateMiiImage:
+        MiiEditOutput(MiiEditResult::Success, 0);
+        break;
+    case MiiEditAppletMode::CreateMii:
+    case MiiEditAppletMode::EditMii: {
+        Service::Mii::MiiManager mii_manager;
+
+        const MiiEditCharInfo char_info{
+            .mii_info{applet_input_common.applet_mode == MiiEditAppletMode::EditMii
+                          ? applet_input_v4.char_info.mii_info
+                          : mii_manager.BuildDefault(0)},
+        };
+
+        MiiEditOutputForCharInfoEditing(MiiEditResult::Success, char_info);
+        break;
+    }
+    default:
+        UNIMPLEMENTED_MSG("Unknown MiiEditAppletMode={}", applet_input_common.applet_mode);
+
+        MiiEditOutput(MiiEditResult::Success, 0);
+        break;
+    }
+}
+
+void MiiEdit::MiiEditOutput(MiiEditResult result, s32 index) {
+    const MiiEditAppletOutput applet_output{
+        .result{result},
+        .index{index},
+    };
+
+    std::vector<u8> out_data(sizeof(MiiEditAppletOutput));
+    std::memcpy(out_data.data(), &applet_output, sizeof(MiiEditAppletOutput));
+
+    is_complete = true;
+
+    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(out_data)));
+    broker.SignalStateChanged();
+}
+
+void MiiEdit::MiiEditOutputForCharInfoEditing(MiiEditResult result,
+                                              const MiiEditCharInfo& char_info) {
+    const MiiEditAppletOutputForCharInfoEditing applet_output{
+        .result{result},
+        .char_info{char_info},
+    };
+
+    std::vector<u8> out_data(sizeof(MiiEditAppletOutputForCharInfoEditing));
+    std::memcpy(out_data.data(), &applet_output, sizeof(MiiEditAppletOutputForCharInfoEditing));
+
+    is_complete = true;
+
+    broker.PushNormalDataFromApplet(std::make_shared<IStorage>(system, std::move(out_data)));
+    broker.SignalStateChanged();
+}
+
+} // namespace Service::AM::Applets

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

@@ -0,0 +1,45 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/result.h"
+#include "core/hle/service/am/applets/applet_mii_edit_types.h"
+#include "core/hle/service/am/applets/applets.h"
+
+namespace Core {
+class System;
+} // namespace Core
+
+namespace Service::AM::Applets {
+
+class MiiEdit final : public Applet {
+public:
+    explicit MiiEdit(Core::System& system_, LibraryAppletMode applet_mode_,
+                     const Core::Frontend::MiiEditApplet& frontend_);
+    ~MiiEdit() override;
+
+    void Initialize() override;
+
+    bool TransactionComplete() const override;
+    ResultCode GetStatus() const override;
+    void ExecuteInteractive() override;
+    void Execute() override;
+
+    void MiiEditOutput(MiiEditResult result, s32 index);
+
+    void MiiEditOutputForCharInfoEditing(MiiEditResult result, const MiiEditCharInfo& char_info);
+
+private:
+    const Core::Frontend::MiiEditApplet& frontend;
+    Core::System& system;
+
+    MiiEditAppletInputCommon applet_input_common{};
+    MiiEditAppletInputV3 applet_input_v3{};
+    MiiEditAppletInputV4 applet_input_v4{};
+
+    bool is_complete{false};
+};
+
+} // namespace Service::AM::Applets

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

@@ -0,0 +1,83 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "core/hle/service/mii/types.h"
+
+namespace Service::AM::Applets {
+
+enum class MiiEditAppletVersion : s32 {
+    Version3 = 0x3, // 1.0.0 - 10.1.1
+    Version4 = 0x4, // 10.2.0+
+};
+
+// This is nn::mii::AppletMode
+enum class MiiEditAppletMode : u32 {
+    ShowMiiEdit = 0,
+    AppendMii = 1,
+    AppendMiiImage = 2,
+    UpdateMiiImage = 3,
+    CreateMii = 4,
+    EditMii = 5,
+};
+
+enum class MiiEditResult : u32 {
+    Success,
+    Cancel,
+};
+
+struct MiiEditCharInfo {
+    Service::Mii::MiiInfo mii_info{};
+};
+static_assert(sizeof(MiiEditCharInfo) == 0x58, "MiiEditCharInfo has incorrect size.");
+
+struct MiiEditAppletInputCommon {
+    MiiEditAppletVersion version{};
+    MiiEditAppletMode applet_mode{};
+};
+static_assert(sizeof(MiiEditAppletInputCommon) == 0x8,
+              "MiiEditAppletInputCommon has incorrect size.");
+
+struct MiiEditAppletInputV3 {
+    u32 special_mii_key_code{};
+    std::array<Common::UUID, 8> valid_uuids{};
+    Common::UUID used_uuid{};
+    INSERT_PADDING_BYTES(0x64);
+};
+static_assert(sizeof(MiiEditAppletInputV3) == 0x100 - sizeof(MiiEditAppletInputCommon),
+              "MiiEditAppletInputV3 has incorrect size.");
+
+struct MiiEditAppletInputV4 {
+    u32 special_mii_key_code{};
+    MiiEditCharInfo char_info{};
+    INSERT_PADDING_BYTES(0x28);
+    Common::UUID used_uuid{};
+    INSERT_PADDING_BYTES(0x64);
+};
+static_assert(sizeof(MiiEditAppletInputV4) == 0x100 - sizeof(MiiEditAppletInputCommon),
+              "MiiEditAppletInputV4 has incorrect size.");
+
+// This is nn::mii::AppletOutput
+struct MiiEditAppletOutput {
+    MiiEditResult result{};
+    s32 index{};
+    INSERT_PADDING_BYTES(0x18);
+};
+static_assert(sizeof(MiiEditAppletOutput) == 0x20, "MiiEditAppletOutput has incorrect size.");
+
+// This is nn::mii::AppletOutputForCharInfoEditing
+struct MiiEditAppletOutputForCharInfoEditing {
+    MiiEditResult result{};
+    MiiEditCharInfo char_info{};
+    INSERT_PADDING_BYTES(0x24);
+};
+static_assert(sizeof(MiiEditAppletOutputForCharInfoEditing) == 0x80,
+              "MiiEditAppletOutputForCharInfoEditing has incorrect size.");
+
+} // namespace Service::AM::Applets

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

@@ -9,7 +9,7 @@
 #include "core/frontend/applets/controller.h"
 #include "core/frontend/applets/error.h"
 #include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/mii.h"
+#include "core/frontend/applets/mii_edit.h"
 #include "core/frontend/applets/profile_select.h"
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/frontend/applets/web_browser.h"
@@ -20,7 +20,7 @@
 #include "core/hle/service/am/applets/applet_controller.h"
 #include "core/hle/service/am/applets/applet_error.h"
 #include "core/hle/service/am/applets/applet_general_backend.h"
-#include "core/hle/service/am/applets/applet_mii.h"
+#include "core/hle/service/am/applets/applet_mii_edit.h"
 #include "core/hle/service/am/applets/applet_profile_select.h"
 #include "core/hle/service/am/applets/applet_software_keyboard.h"
 #include "core/hle/service/am/applets/applet_web_browser.h"
@@ -173,12 +173,12 @@ void Applet::Initialize() {
 AppletFrontendSet::AppletFrontendSet() = default;
 
 AppletFrontendSet::AppletFrontendSet(ControllerApplet controller_applet, ErrorApplet error_applet,
+                                     MiiEdit mii_edit_,
                                      ParentalControlsApplet parental_controls_applet,
-                                     MiiApplet mii_applet, PhotoViewer photo_viewer_,
-                                     ProfileSelect profile_select_,
+                                     PhotoViewer photo_viewer_, ProfileSelect profile_select_,
                                      SoftwareKeyboard software_keyboard_, WebBrowser web_browser_)
     : controller{std::move(controller_applet)}, error{std::move(error_applet)},
-      parental_controls{std::move(parental_controls_applet)}, mii{std::move(mii_applet)},
+      mii_edit{std::move(mii_edit_)}, parental_controls{std::move(parental_controls_applet)},
       photo_viewer{std::move(photo_viewer_)}, profile_select{std::move(profile_select_)},
       software_keyboard{std::move(software_keyboard_)}, web_browser{std::move(web_browser_)} {}
 
@@ -205,12 +205,12 @@ void AppletManager::SetAppletFrontendSet(AppletFrontendSet set) {
         frontend.error = std::move(set.error);
     }
 
-    if (set.parental_controls != nullptr) {
-        frontend.parental_controls = std::move(set.parental_controls);
+    if (set.mii_edit != nullptr) {
+        frontend.mii_edit = std::move(set.mii_edit);
     }
 
-    if (set.mii != nullptr) {
-        frontend.mii = std::move(set.mii);
+    if (set.parental_controls != nullptr) {
+        frontend.parental_controls = std::move(set.parental_controls);
     }
 
     if (set.photo_viewer != nullptr) {
@@ -245,15 +245,15 @@ void AppletManager::SetDefaultAppletsIfMissing() {
         frontend.error = std::make_unique<Core::Frontend::DefaultErrorApplet>();
     }
 
+    if (frontend.mii_edit == nullptr) {
+        frontend.mii_edit = std::make_unique<Core::Frontend::DefaultMiiEditApplet>();
+    }
+
     if (frontend.parental_controls == nullptr) {
         frontend.parental_controls =
             std::make_unique<Core::Frontend::DefaultParentalControlsApplet>();
     }
 
-    if (frontend.mii == nullptr) {
-        frontend.mii = std::make_unique<Core::Frontend::DefaultMiiApplet>();
-    }
-
     if (frontend.photo_viewer == nullptr) {
         frontend.photo_viewer = std::make_unique<Core::Frontend::DefaultPhotoViewerApplet>();
     }
@@ -289,7 +289,7 @@ std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id, LibraryAppletMode
     case AppletId::SoftwareKeyboard:
         return std::make_shared<SoftwareKeyboard>(system, mode, *frontend.software_keyboard);
     case AppletId::MiiEdit:
-        return std::make_shared<Mii>(system, mode, *frontend.mii);
+        return std::make_shared<MiiEdit>(system, mode, *frontend.mii_edit);
     case AppletId::Web:
     case AppletId::Shop:
     case AppletId::OfflineWeb:

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

@@ -20,8 +20,8 @@ namespace Core::Frontend {
 class ControllerApplet;
 class ECommerceApplet;
 class ErrorApplet;
+class MiiEditApplet;
 class ParentalControlsApplet;
-class MiiApplet;
 class PhotoViewerApplet;
 class ProfileSelectApplet;
 class SoftwareKeyboardApplet;
@@ -179,8 +179,8 @@ protected:
 struct AppletFrontendSet {
     using ControllerApplet = std::unique_ptr<Core::Frontend::ControllerApplet>;
     using ErrorApplet = std::unique_ptr<Core::Frontend::ErrorApplet>;
+    using MiiEdit = std::unique_ptr<Core::Frontend::MiiEditApplet>;
     using ParentalControlsApplet = std::unique_ptr<Core::Frontend::ParentalControlsApplet>;
-    using MiiApplet = std::unique_ptr<Core::Frontend::MiiApplet>;
     using PhotoViewer = std::unique_ptr<Core::Frontend::PhotoViewerApplet>;
     using ProfileSelect = std::unique_ptr<Core::Frontend::ProfileSelectApplet>;
     using SoftwareKeyboard = std::unique_ptr<Core::Frontend::SoftwareKeyboardApplet>;
@@ -188,7 +188,7 @@ struct AppletFrontendSet {
 
     AppletFrontendSet();
     AppletFrontendSet(ControllerApplet controller_applet, ErrorApplet error_applet,
-                      ParentalControlsApplet parental_controls_applet, MiiApplet mii_applet,
+                      MiiEdit mii_edit_, ParentalControlsApplet parental_controls_applet,
                       PhotoViewer photo_viewer_, ProfileSelect profile_select_,
                       SoftwareKeyboard software_keyboard_, WebBrowser web_browser_);
     ~AppletFrontendSet();
@@ -201,8 +201,8 @@ struct AppletFrontendSet {
 
     ControllerApplet controller;
     ErrorApplet error;
+    MiiEdit mii_edit;
     ParentalControlsApplet parental_controls;
-    MiiApplet mii;
     PhotoViewer photo_viewer;
     ProfileSelect profile_select;
     SoftwareKeyboard software_keyboard;

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

@@ -1,4 +1,4 @@
-// Copyright 2020 yuzu emulator team
+// Copyright 2020 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
@@ -12,7 +12,6 @@
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/mii/mii_manager.h"
 #include "core/hle/service/mii/raw_data.h"
-#include "core/hle/service/mii/types.h"
 
 namespace Service::Mii {
 

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

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

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

@@ -6,7 +6,7 @@
 
 #include <array>
 
-#include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/mii/types.h"
 
 namespace Service::Mii::RawData {
 

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

@@ -1,11 +1,16 @@
-// Copyright 2020 yuzu emulator team
+// Copyright 2020 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
 #pragma once
 
+#include <array>
+#include <type_traits>
+
+#include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/uuid.h"
 
 namespace Service::Mii {
 
@@ -25,7 +30,11 @@ enum class BeardType : u32 {
     Beard5,
 };
 
-enum class BeardAndMustacheFlag : u32 { Beard = 1, Mustache, All = Beard | Mustache };
+enum class BeardAndMustacheFlag : u32 {
+    Beard = 1,
+    Mustache,
+    All = Beard | Mustache,
+};
 DECLARE_ENUM_FLAG_OPERATORS(BeardAndMustacheFlag);
 
 enum class FontRegion : u32 {
@@ -64,4 +73,298 @@ enum class Race : u32 {
     All,
 };
 
+enum class Source : u32 {
+    Database = 0,
+    Default = 1,
+    Account = 2,
+    Friend = 3,
+};
+
+enum class SourceFlag : u32 {
+    None = 0,
+    Database = 1 << 0,
+    Default = 1 << 1,
+};
+DECLARE_ENUM_FLAG_OPERATORS(SourceFlag);
+
+struct MiiInfo {
+    Common::UUID uuid;
+    std::array<char16_t, 11> name;
+    u8 font_region;
+    u8 favorite_color;
+    u8 gender;
+    u8 height;
+    u8 build;
+    u8 type;
+    u8 region_move;
+    u8 faceline_type;
+    u8 faceline_color;
+    u8 faceline_wrinkle;
+    u8 faceline_make;
+    u8 hair_type;
+    u8 hair_color;
+    u8 hair_flip;
+    u8 eye_type;
+    u8 eye_color;
+    u8 eye_scale;
+    u8 eye_aspect;
+    u8 eye_rotate;
+    u8 eye_x;
+    u8 eye_y;
+    u8 eyebrow_type;
+    u8 eyebrow_color;
+    u8 eyebrow_scale;
+    u8 eyebrow_aspect;
+    u8 eyebrow_rotate;
+    u8 eyebrow_x;
+    u8 eyebrow_y;
+    u8 nose_type;
+    u8 nose_scale;
+    u8 nose_y;
+    u8 mouth_type;
+    u8 mouth_color;
+    u8 mouth_scale;
+    u8 mouth_aspect;
+    u8 mouth_y;
+    u8 beard_color;
+    u8 beard_type;
+    u8 mustache_type;
+    u8 mustache_scale;
+    u8 mustache_y;
+    u8 glasses_type;
+    u8 glasses_color;
+    u8 glasses_scale;
+    u8 glasses_y;
+    u8 mole_type;
+    u8 mole_scale;
+    u8 mole_x;
+    u8 mole_y;
+    u8 padding;
+};
+static_assert(sizeof(MiiInfo) == 0x58, "MiiInfo has incorrect size.");
+static_assert(std::has_unique_object_representations_v<MiiInfo>,
+              "All bits of MiiInfo must contribute to its value.");
+
+#pragma pack(push, 4)
+
+struct MiiInfoElement {
+    MiiInfoElement(const MiiInfo& info_, Source source_) : info{info_}, source{source_} {}
+
+    MiiInfo info{};
+    Source source{};
+};
+static_assert(sizeof(MiiInfoElement) == 0x5c, "MiiInfoElement has incorrect size.");
+
+struct MiiStoreBitFields {
+    union {
+        u32 word_0{};
+
+        BitField<0, 8, u32> hair_type;
+        BitField<8, 7, u32> height;
+        BitField<15, 1, u32> mole_type;
+        BitField<16, 7, u32> build;
+        BitField<23, 1, HairFlip> hair_flip;
+        BitField<24, 7, u32> hair_color;
+        BitField<31, 1, u32> type;
+    };
+
+    union {
+        u32 word_1{};
+
+        BitField<0, 7, u32> eye_color;
+        BitField<7, 1, Gender> gender;
+        BitField<8, 7, u32> eyebrow_color;
+        BitField<16, 7, u32> mouth_color;
+        BitField<24, 7, u32> beard_color;
+    };
+
+    union {
+        u32 word_2{};
+
+        BitField<0, 7, u32> glasses_color;
+        BitField<8, 6, u32> eye_type;
+        BitField<14, 2, u32> region_move;
+        BitField<16, 6, u32> mouth_type;
+        BitField<22, 2, FontRegion> font_region;
+        BitField<24, 5, u32> eye_y;
+        BitField<29, 3, u32> glasses_scale;
+    };
+
+    union {
+        u32 word_3{};
+
+        BitField<0, 5, u32> eyebrow_type;
+        BitField<5, 3, MustacheType> mustache_type;
+        BitField<8, 5, u32> nose_type;
+        BitField<13, 3, BeardType> beard_type;
+        BitField<16, 5, u32> nose_y;
+        BitField<21, 3, u32> mouth_aspect;
+        BitField<24, 5, u32> mouth_y;
+        BitField<29, 3, u32> eyebrow_aspect;
+    };
+
+    union {
+        u32 word_4{};
+
+        BitField<0, 5, u32> mustache_y;
+        BitField<5, 3, u32> eye_rotate;
+        BitField<8, 5, u32> glasses_y;
+        BitField<13, 3, u32> eye_aspect;
+        BitField<16, 5, u32> mole_x;
+        BitField<21, 3, u32> eye_scale;
+        BitField<24, 5, u32> mole_y;
+    };
+
+    union {
+        u32 word_5{};
+
+        BitField<0, 5, u32> glasses_type;
+        BitField<8, 4, u32> favorite_color;
+        BitField<12, 4, u32> faceline_type;
+        BitField<16, 4, u32> faceline_color;
+        BitField<20, 4, u32> faceline_wrinkle;
+        BitField<24, 4, u32> faceline_makeup;
+        BitField<28, 4, u32> eye_x;
+    };
+
+    union {
+        u32 word_6{};
+
+        BitField<0, 4, u32> eyebrow_scale;
+        BitField<4, 4, u32> eyebrow_rotate;
+        BitField<8, 4, u32> eyebrow_x;
+        BitField<12, 4, u32> eyebrow_y;
+        BitField<16, 4, u32> nose_scale;
+        BitField<20, 4, u32> mouth_scale;
+        BitField<24, 4, u32> mustache_scale;
+        BitField<28, 4, u32> mole_scale;
+    };
+};
+static_assert(sizeof(MiiStoreBitFields) == 0x1c, "MiiStoreBitFields has incorrect size.");
+static_assert(std::is_trivially_copyable_v<MiiStoreBitFields>,
+              "MiiStoreBitFields is not trivially copyable.");
+
+struct MiiStoreData {
+    using Name = std::array<char16_t, 10>;
+
+    MiiStoreData();
+    MiiStoreData(const Name& name, const MiiStoreBitFields& bit_fields,
+                 const Common::UUID& user_id);
+
+    // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
+    // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
+    // not suitable for our uses.
+    struct {
+        std::array<u8, 0x1C> data{};
+        static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
+
+        Name name{};
+        Common::UUID uuid{};
+    } data;
+
+    u16 data_crc{};
+    u16 device_crc{};
+};
+static_assert(sizeof(MiiStoreData) == 0x44, "MiiStoreData has incorrect size.");
+
+struct MiiStoreDataElement {
+    MiiStoreData data{};
+    Source source{};
+};
+static_assert(sizeof(MiiStoreDataElement) == 0x48, "MiiStoreDataElement has incorrect size.");
+
+struct MiiDatabase {
+    u32 magic{}; // 'NFDB'
+    std::array<MiiStoreData, 0x64> miis{};
+    INSERT_PADDING_BYTES(1);
+    u8 count{};
+    u16 crc{};
+};
+static_assert(sizeof(MiiDatabase) == 0x1A98, "MiiDatabase has incorrect size.");
+
+struct RandomMiiValues {
+    std::array<u8, 0xbc> values{};
+};
+static_assert(sizeof(RandomMiiValues) == 0xbc, "RandomMiiValues has incorrect size.");
+
+struct RandomMiiData4 {
+    Gender gender{};
+    Age age{};
+    Race race{};
+    u32 values_count{};
+    std::array<u32, 47> values{};
+};
+static_assert(sizeof(RandomMiiData4) == 0xcc, "RandomMiiData4 has incorrect size.");
+
+struct RandomMiiData3 {
+    u32 arg_1;
+    u32 arg_2;
+    u32 values_count;
+    std::array<u32, 47> values{};
+};
+static_assert(sizeof(RandomMiiData3) == 0xc8, "RandomMiiData3 has incorrect size.");
+
+struct RandomMiiData2 {
+    u32 arg_1;
+    u32 values_count;
+    std::array<u32, 47> values{};
+};
+static_assert(sizeof(RandomMiiData2) == 0xc4, "RandomMiiData2 has incorrect size.");
+
+struct DefaultMii {
+    u32 face_type{};
+    u32 face_color{};
+    u32 face_wrinkle{};
+    u32 face_makeup{};
+    u32 hair_type{};
+    u32 hair_color{};
+    u32 hair_flip{};
+    u32 eye_type{};
+    u32 eye_color{};
+    u32 eye_scale{};
+    u32 eye_aspect{};
+    u32 eye_rotate{};
+    u32 eye_x{};
+    u32 eye_y{};
+    u32 eyebrow_type{};
+    u32 eyebrow_color{};
+    u32 eyebrow_scale{};
+    u32 eyebrow_aspect{};
+    u32 eyebrow_rotate{};
+    u32 eyebrow_x{};
+    u32 eyebrow_y{};
+    u32 nose_type{};
+    u32 nose_scale{};
+    u32 nose_y{};
+    u32 mouth_type{};
+    u32 mouth_color{};
+    u32 mouth_scale{};
+    u32 mouth_aspect{};
+    u32 mouth_y{};
+    u32 mustache_type{};
+    u32 beard_type{};
+    u32 beard_color{};
+    u32 mustache_scale{};
+    u32 mustache_y{};
+    u32 glasses_type{};
+    u32 glasses_color{};
+    u32 glasses_scale{};
+    u32 glasses_y{};
+    u32 mole_type{};
+    u32 mole_scale{};
+    u32 mole_x{};
+    u32 mole_y{};
+    u32 height{};
+    u32 weight{};
+    Gender gender{};
+    u32 favorite_color{};
+    u32 region{};
+    FontRegion font_region{};
+    u32 type{};
+    INSERT_PADDING_WORDS(5);
+};
+static_assert(sizeof(DefaultMii) == 0xd8, "MiiStoreData has incorrect size.");
+
+#pragma pack(pop)
+
 } // namespace Service::Mii

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

@@ -12,6 +12,7 @@
 #include "core/hid/hid_types.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
+#include "core/hle/service/mii/mii_manager.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
 

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

@@ -9,7 +9,7 @@
 
 #include "common/common_funcs.h"
 #include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/mii/types.h"
 #include "core/hle/service/service.h"
 
 namespace Kernel {

src/shader_recompiler/frontend/ir/microinstruction.cpp

@@ -326,11 +326,6 @@ void Inst::AddPhiOperand(Block* predecessor, const Value& value) {
     phi_args.emplace_back(predecessor, value);
 }
 
-void Inst::ErasePhiOperand(size_t index) {
-    const auto operand_it{phi_args.begin() + static_cast<ptrdiff_t>(index)};
-    phi_args.erase(operand_it);
-}
-
 void Inst::OrderPhiArgs() {
     if (op != Opcode::Phi) {
         throw LogicError("{} is not a Phi instruction", op);

src/shader_recompiler/frontend/ir/value.h

@@ -179,13 +179,9 @@ public:
 
     /// Get a pointer to the block of a phi argument.
     [[nodiscard]] Block* PhiBlock(size_t index) const;
-
     /// Add phi operand to a phi instruction.
     void AddPhiOperand(Block* predecessor, const Value& value);
 
-    // Erase the phi operand at the given index.
-    void ErasePhiOperand(size_t index);
-
     /// Orders the Phi arguments from farthest away to nearest.
     void OrderPhiArgs();
 

src/shader_recompiler/ir_opt/dead_code_elimination_pass.cpp

@@ -2,104 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
-
-#include <boost/container/small_vector.hpp>
-
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
-namespace {
-template <bool TEST_USES>
-void DeadInstElimination(IR::Block* const block) {
-    // We iterate over the instructions in reverse order.
-    // This is because removing an instruction reduces the number of uses for earlier instructions.
-    auto it{block->end()};
-    while (it != block->begin()) {
-        --it;
-        if constexpr (TEST_USES) {
-            if (it->HasUses() || it->MayHaveSideEffects()) {
-                continue;
-            }
-        }
-        it->Invalidate();
-        it = block->Instructions().erase(it);
-    }
-}
-
-void DeletedPhiArgElimination(IR::Program& program, std::span<const IR::Block*> dead_blocks) {
-    for (IR::Block* const block : program.blocks) {
-        for (IR::Inst& phi : *block) {
-            if (!IR::IsPhi(phi)) {
-                continue;
-            }
-            for (size_t i = 0; i < phi.NumArgs(); ++i) {
-                if (std::ranges::find(dead_blocks, phi.PhiBlock(i)) == dead_blocks.end()) {
-                    continue;
-                }
-                // Phi operand at this index is an unreachable block
-                phi.ErasePhiOperand(i);
-                --i;
-            }
-        }
-    }
-}
-
-void DeadBranchElimination(IR::Program& program) {
-    boost::container::small_vector<const IR::Block*, 3> dead_blocks;
-    const auto begin_it{program.syntax_list.begin()};
-    for (auto node_it = begin_it; node_it != program.syntax_list.end(); ++node_it) {
-        if (node_it->type != IR::AbstractSyntaxNode::Type::If) {
-            continue;
-        }
-        IR::Inst* const cond_ref{node_it->data.if_node.cond.Inst()};
-        const IR::U1 cond{cond_ref->Arg(0)};
-        if (!cond.IsImmediate()) {
-            continue;
-        }
-        if (cond.U1()) {
-            continue;
-        }
-        // False immediate condition. Remove condition ref, erase the entire branch.
-        cond_ref->Invalidate();
-        // Account for nested if-statements within the if(false) branch
-        u32 nested_ifs{1u};
-        while (node_it->type != IR::AbstractSyntaxNode::Type::EndIf || nested_ifs > 0) {
-            node_it = program.syntax_list.erase(node_it);
-            switch (node_it->type) {
-            case IR::AbstractSyntaxNode::Type::If:
-                ++nested_ifs;
-                break;
-            case IR::AbstractSyntaxNode::Type::EndIf:
-                --nested_ifs;
-                break;
-            case IR::AbstractSyntaxNode::Type::Block: {
-                IR::Block* const block{node_it->data.block};
-                DeadInstElimination<false>(block);
-                dead_blocks.push_back(block);
-                break;
-            }
-            default:
-                break;
-            }
-        }
-        // Erase EndIf node of the if(false) branch
-        node_it = program.syntax_list.erase(node_it);
-        // Account for loop increment
-        --node_it;
-    }
-    if (!dead_blocks.empty()) {
-        DeletedPhiArgElimination(program, std::span(dead_blocks.data(), dead_blocks.size()));
-    }
-}
-} // namespace
 
 void DeadCodeEliminationPass(IR::Program& program) {
-    DeadBranchElimination(program);
+    // We iterate over the instructions in reverse order.
+    // This is because removing an instruction reduces the number of uses for earlier instructions.
     for (IR::Block* const block : program.post_order_blocks) {
-        DeadInstElimination<true>(block);
+        auto it{block->end()};
+        while (it != block->begin()) {
+            --it;
+            if (!it->HasUses() && !it->MayHaveSideEffects()) {
+                it->Invalidate();
+                it = block->Instructions().erase(it);
+            }
+        }
     }
 }
 

src/video_core/buffer_cache/buffer_base.h

@@ -212,7 +212,7 @@ public:
     void FlushCachedWrites() noexcept {
         flags &= ~BufferFlagBits::CachedWrites;
         const u64 num_words = NumWords();
-        const u64* const cached_words = Array<Type::CachedCPU>();
+        u64* const cached_words = Array<Type::CachedCPU>();
         u64* const untracked_words = Array<Type::Untracked>();
         u64* const cpu_words = Array<Type::CPU>();
         for (u64 word_index = 0; word_index < num_words; ++word_index) {
@@ -220,6 +220,7 @@ public:
             NotifyRasterizer<false>(word_index, untracked_words[word_index], cached_bits);
             untracked_words[word_index] |= cached_bits;
             cpu_words[word_index] |= cached_bits;
+            cached_words[word_index] = 0;
         }
     }
 

src/yuzu/applets/qt_web_browser.cpp

@@ -11,6 +11,9 @@
 #include <QWebEngineScriptCollection>
 #include <QWebEngineSettings>
 #include <QWebEngineUrlScheme>
+
+#include "core/hid/input_interpreter.h"
+#include "yuzu/applets/qt_web_browser_scripts.h"
 #endif
 
 #include "common/fs/path_util.h"

src/yuzu/applets/qt_web_browser.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <atomic>
+#include <thread>
 
 #include <QObject>
 

src/yuzu/main.cpp

@@ -24,7 +24,7 @@
 #include "core/file_sys/vfs_real.h"
 #include "core/frontend/applets/controller.h"
 #include "core/frontend/applets/general_frontend.h"
-#include "core/frontend/applets/mii.h"
+#include "core/frontend/applets/mii_edit.h"
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
@@ -1280,8 +1280,8 @@ bool GMainWindow::LoadROM(const QString& filename, u64 program_id, std::size_t p
     system->SetAppletFrontendSet({
         std::make_unique<QtControllerSelector>(*this), // Controller Selector
         std::make_unique<QtErrorDisplay>(*this),       // Error Display
+        nullptr,                                       // Mii Editor
         nullptr,                                       // Parental Controls
-        nullptr,                                       // Mii editor
         nullptr,                                       // Photo Viewer
         std::make_unique<QtProfileSelector>(*this),    // Profile Selector
         std::make_unique<QtSoftwareKeyboard>(*this),   // Software Keyboard