Android #99

Merge PR 11649
2023-10-13 00:57:52 +00:00 · 2023-10-13 00:57:52 +00:00
122 changed files with 10504 additions and 12770 deletions
--- a/.codespellrc
+++ b/.codespellrc
@@ -3,4 +3,4 @@

 [codespell]
 skip = ./.git,./build,./dist,./Doxyfile,./externals,./LICENSES,./src/android/app/src/main/res
-ignore-words-list = aci,allright,ba,canonicalizations,deques,froms,hda,inout,lod,masia,nam,nax,nd,optin,pullrequests,pullrequest,te,transfered,unstall,uscaled,vas,zink
+ignore-words-list = aci,allright,ba,canonicalizations,deques,froms,hda,inout,lod,masia,nam,nax,nd,optin,pullrequests,pullrequest,te,transfered,unstall,uscaled,zink
--- a/.reuse/dep5
+++ b/.reuse/dep5
@@ -147,7 +147,3 @@ License: GPL-3.0-or-later
 Files: src/android/gradle/wrapper/*
 Copyright: 2023 yuzu Emulator Project
 License: GPL-3.0-or-later
-
-Files: externals/stb/*
-Copyright: Sean Barrett
-License: MIT
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,6 +11,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modul
 include(DownloadExternals)
 include(CMakeDependentOption)
 include(CTest)
+include(FetchContent)

 # Set bundled sdl2/qt as dependent options.
 # OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
@@ -98,8 +99,47 @@ if (ANDROID AND YUZU_DOWNLOAD_ANDROID_VVL)
            DESTINATION "${vvl_lib_path}")
 endif()

+# On Android, fetch and compile libcxx before doing anything else
 if (ANDROID)
    set(CMAKE_SKIP_INSTALL_RULES ON)
+    set(LLVM_VERSION "15.0.6")
+
+    # Note: even though libcxx and libcxxabi have separate releases on the project page,
+    # the separated releases cannot be compiled. Only in-tree builds work. Therefore we
+    # must fetch the source release for the entire llvm tree.
+    FetchContent_Declare(llvm
+        URL "https://github.com/llvm/llvm-project/releases/download/llvmorg-${LLVM_VERSION}/llvm-project-${LLVM_VERSION}.src.tar.xz"
+        URL_HASH SHA256=9d53ad04dc60cb7b30e810faf64c5ab8157dadef46c8766f67f286238256ff92
+        TLS_VERIFY TRUE
+    )
+    FetchContent_MakeAvailable(llvm)
+
+    # libcxx has support for most of the range library, but it's gated behind a flag:
+    add_compile_definitions(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+    # Disable standard header inclusion
+    set(ANDROID_STL "none")
+
+    # libcxxabi
+    set(LIBCXXABI_INCLUDE_TESTS OFF)
+    set(LIBCXXABI_ENABLE_SHARED FALSE)
+    set(LIBCXXABI_ENABLE_STATIC TRUE)
+    set(LIBCXXABI_LIBCXX_INCLUDES "${LIBCXX_TARGET_INCLUDE_DIRECTORY}" CACHE STRING "" FORCE)
+    add_subdirectory("${llvm_SOURCE_DIR}/libcxxabi" "${llvm_BINARY_DIR}/libcxxabi")
+    link_libraries(cxxabi_static)
+
+    # libcxx
+    set(LIBCXX_ABI_NAMESPACE "__ndk1" CACHE STRING "" FORCE)
+    set(LIBCXX_CXX_ABI "libcxxabi")
+    set(LIBCXX_INCLUDE_TESTS OFF)
+    set(LIBCXX_INCLUDE_BENCHMARKS OFF)
+    set(LIBCXX_INCLUDE_DOCS OFF)
+    set(LIBCXX_ENABLE_SHARED FALSE)
+    set(LIBCXX_ENABLE_STATIC TRUE)
+    set(LIBCXX_ENABLE_ASSERTIONS FALSE)
+    add_subdirectory("${llvm_SOURCE_DIR}/libcxx" "${llvm_BINARY_DIR}/libcxx")
+    set_target_properties(cxx-headers PROPERTIES INTERFACE_COMPILE_OPTIONS "-isystem${CMAKE_BINARY_DIR}/${LIBCXX_INSTALL_INCLUDE_DIR}")
+    link_libraries(cxx_static cxx-headers)
 endif()

 if (YUZU_USE_BUNDLED_VCPKG)
@@ -289,12 +329,11 @@ find_package(Boost 1.79.0 REQUIRED context)
 find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
 find_package(inih 52 MODULE COMPONENTS INIReader)
-find_package(LLVM 17.0.2 MODULE COMPONENTS Demangle)
+find_package(LLVM 17 MODULE COMPONENTS Demangle)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
 find_package(RenderDoc MODULE)
-find_package(stb MODULE)
 find_package(VulkanMemoryAllocator CONFIG)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
@@ -361,9 +400,6 @@ function(set_yuzu_qt_components)
    if (ENABLE_QT_TRANSLATION)
        list(APPEND YUZU_QT_COMPONENTS2 LinguistTools)
    endif()
-    if (USE_DISCORD_PRESENCE)
-        list(APPEND YUZU_QT_COMPONENTS2 Network)
-    endif()
    set(YUZU_QT_COMPONENTS ${YUZU_QT_COMPONENTS2} PARENT_SCOPE)
 endfunction(set_yuzu_qt_components)

--- a/CMakeModules/Findstb.cmake
+++ b/CMakeModules/Findstb.cmake
@@ -1,31 +0,0 @@
-# SPDX-FileCopyrightText: 2023 Alexandre Bouvier <contact@amb.tf>
-#
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-find_path(stb_image_INCLUDE_DIR stb_image.h PATH_SUFFIXES stb)
-find_path(stb_image_resize_INCLUDE_DIR stb_image_resize.h PATH_SUFFIXES stb)
-find_path(stb_image_write_INCLUDE_DIR stb_image_write.h PATH_SUFFIXES stb)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(stb
-    REQUIRED_VARS
-        stb_image_INCLUDE_DIR
-        stb_image_resize_INCLUDE_DIR
-        stb_image_write_INCLUDE_DIR
-)
-
-if (stb_FOUND AND NOT TARGET stb::headers)
-    add_library(stb::headers INTERFACE IMPORTED)
-    set_property(TARGET stb::headers PROPERTY
-        INTERFACE_INCLUDE_DIRECTORIES
-            "${stb_image_INCLUDE_DIR}"
-            "${stb_image_resize_INCLUDE_DIR}"
-            "${stb_image_write_INCLUDE_DIR}"
-    )
-endif()
-
-mark_as_advanced(
-    stb_image_INCLUDE_DIR
-    stb_image_resize_INCLUDE_DIR
-    stb_image_write_INCLUDE_DIR
-)
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
-| [11827](https://github.com/yuzu-emu/yuzu//pull/11827) | [`689f346e9`](https://github.com/yuzu-emu/yuzu//pull/11827/files) | nvnflinger: fix reporting and freeing of preallocated buffers | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [11649](https://github.com/yuzu-emu/yuzu//pull/11649) | [`a5fb9de6f`](https://github.com/yuzu-emu/yuzu//pull/11649/files) | android: Driver manager | [t895](https://github.com/t895/) | Yes |


 End of merge log. You can find the original README.md below the break.
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -168,13 +168,9 @@ if (NOT TARGET LLVM::Demangle)
    add_library(LLVM::Demangle ALIAS demangle)
 endif()

-add_library(stb stb/stb_dxt.cpp)
+add_library(stb stb/stb_dxt.cpp stb/stb_image.cpp stb/stb_image_resize.cpp)
 target_include_directories(stb PUBLIC ./stb)

-if (NOT TARGET stb::headers)
-    add_library(stb::headers ALIAS stb)
-endif()
-
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)

--- a/externals/stb/stb_image.cpp
+++ b/externals/stb/stb_image.cpp
--- a/externals/stb/stb_image.h
+++ b/externals/stb/stb_image.h
--- a/externals/stb/stb_image_resize.cpp
+++ b/externals/stb/stb_image_resize.cpp
--- a/externals/stb/stb_image_resize.h
+++ b/externals/stb/stb_image_resize.h
--- a/externals/stb/stb_image_write.h
+++ b/externals/stb/stb_image_write.h
--- a/src/android/app/build.gradle.kts
+++ b/src/android/app/build.gradle.kts
@@ -27,7 +27,7 @@ android {
    namespace = "org.yuzu.yuzu_emu"

    compileSdkVersion = "android-34"
-    ndkVersion = "26.1.10909125"
+    ndkVersion = "25.2.9519653"

    buildFeatures {
        viewBinding = true
@@ -203,23 +203,23 @@ ktlint {
 }

 dependencies {
-    implementation("androidx.core:core-ktx:1.12.0")
+    implementation("androidx.core:core-ktx:1.10.1")
    implementation("androidx.appcompat:appcompat:1.6.1")
-    implementation("androidx.recyclerview:recyclerview:1.3.1")
+    implementation("androidx.recyclerview:recyclerview:1.3.0")
    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
-    implementation("androidx.fragment:fragment-ktx:1.6.1")
+    implementation("androidx.fragment:fragment-ktx:1.6.0")
    implementation("androidx.documentfile:documentfile:1.0.1")
    implementation("com.google.android.material:material:1.9.0")
-    implementation("androidx.preference:preference-ktx:1.2.1")
-    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2")
+    implementation("androidx.preference:preference:1.2.0")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1")
    implementation("io.coil-kt:coil:2.2.2")
    implementation("androidx.core:core-splashscreen:1.0.1")
    implementation("androidx.window:window:1.2.0-beta03")
    implementation("org.ini4j:ini4j:0.5.4")
    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
    implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")
-    implementation("androidx.navigation:navigation-fragment-ktx:2.7.4")
-    implementation("androidx.navigation:navigation-ui-ktx:2.7.4")
+    implementation("androidx.navigation:navigation-fragment-ktx:2.6.0")
+    implementation("androidx.navigation:navigation-ui-ktx:2.6.0")
    implementation("info.debatty:java-string-similarity:2.0.0")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
 }
--- a/src/android/app/src/main/AndroidManifest.xml
+++ b/src/android/app/src/main/AndroidManifest.xml
@@ -28,6 +28,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
        android:appCategory="game"
        android:localeConfig="@xml/locales_config"
        android:banner="@drawable/tv_banner"
+        android:extractNativeLibs="true"
        android:fullBackupContent="@xml/data_extraction_rules"
        android:dataExtractionRules="@xml/data_extraction_rules_api_31"
        android:enableOnBackInvokedCallback="true">
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/DriverManagerFragment.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/DriverManagerFragment.kt
@@ -26,7 +26,6 @@ import org.yuzu.yuzu_emu.model.DriverViewModel
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.utils.FileUtil
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
-import java.io.File
 import java.io.IOException

 class DriverManagerFragment : Fragment() {
@@ -155,29 +154,29 @@ class DriverManagerFragment : Fragment() {
                R.string.installing_driver,
                false
            ) {
-                val driverPath =
-                    "${GpuDriverHelper.driverStoragePath}/${FileUtil.getFilename(result)}"
-                val driverFile = File(driverPath)
-
                // Ignore file exceptions when a user selects an invalid zip
                try {
-                    if (!GpuDriverHelper.copyDriverToInternalStorage(result)) {
-                        throw IOException("Driver failed validation!")
-                    }
+                    GpuDriverHelper.copyDriverToInternalStorage(result)
                } catch (_: IOException) {
-                    if (driverFile.exists()) {
-                        driverFile.delete()
-                    }
                    return@newInstance getString(R.string.select_gpu_driver_error)
                }

-                val driverData = GpuDriverHelper.getMetadataFromZip(driverFile)
+                val driverData = GpuDriverHelper.customDriverData
+                if (driverData.name == null) {
+                    return@newInstance getString(R.string.select_gpu_driver_error)
+                }
+
                val driverInList =
                    driverViewModel.driverList.value.firstOrNull { it.second == driverData }
                if (driverInList != null) {
                    return@newInstance getString(R.string.driver_already_installed)
                } else {
-                    driverViewModel.addDriver(Pair(driverPath, driverData))
+                    driverViewModel.addDriver(
+                        Pair(
+                            "${GpuDriverHelper.driverStoragePath}/${FileUtil.getFilename(result)}",
+                            driverData
+                        )
+                    )
                    driverViewModel.setNewDriverInstalled(true)
                }
                return@newInstance Any()
--- a/src/android/build.gradle.kts
+++ b/src/android/build.gradle.kts
@@ -3,8 +3,8 @@

 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id("com.android.application") version "8.1.2" apply false
-    id("com.android.library") version "8.1.2" apply false
+    id("com.android.application") version "8.0.2" apply false
+    id("com.android.library") version "8.0.2" apply false
    id("org.jetbrains.kotlin.android") version "1.8.21" apply false
 }

--- a/src/audio_core/sink/sink_stream.cpp
+++ b/src/audio_core/sink/sink_stream.cpp
@@ -204,10 +204,6 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
    // paused and we'll desync, so just play silence.
    if (system.IsPaused() || system.IsShuttingDown()) {
        if (system.IsShuttingDown()) {
-            {
-                std::scoped_lock lk{release_mutex};
-                queued_buffers.store(0);
-            }
            release_cv.notify_one();
        }

--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -120,8 +120,6 @@ add_library(common STATIC
    socket_types.h
    spin_lock.cpp
    spin_lock.h
-    stb.cpp
-    stb.h
    steady_clock.cpp
    steady_clock.h
    stream.cpp
@@ -210,8 +208,6 @@ if (MSVC)
    /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
    /we4800 # Implicit conversion from 'type' to bool. Possible information loss
  )
-else()
-  set_source_files_properties(stb.cpp PROPERTIES COMPILE_OPTIONS "-Wno-implicit-fallthrough;-Wno-missing-declarations;-Wno-missing-field-initializers")
 endif()

 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@@ -227,7 +223,7 @@ endif()

 create_target_directory_groups(common)

-target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile stb::headers Threads::Threads)
+target_link_libraries(common PUBLIC Boost::context Boost::headers fmt::fmt microprofile Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd LLVM::Demangle)

 if (ANDROID)
--- a/src/common/polyfill_thread.h
+++ b/src/common/polyfill_thread.h
@@ -15,13 +15,12 @@
 #include <condition_variable>
 #include <stop_token>
 #include <thread>
-#include <utility>

 namespace Common {

 template <typename Condvar, typename Lock, typename Pred>
 void CondvarWait(Condvar& cv, std::unique_lock<Lock>& lk, std::stop_token token, Pred&& pred) {
-    cv.wait(lk, token, std::forward<Pred>(pred));
+    cv.wait(lk, token, std::move(pred));
 }

 template <typename Rep, typename Period>
@@ -110,7 +109,7 @@ public:

        // Insert the callback.
        stop_state_callback ret = ++m_next_callback;
-        m_callbacks.emplace(ret, std::move(f));
+        m_callbacks.emplace(ret, move(f));
        return ret;
    }

@@ -163,7 +162,7 @@ private:
    friend class stop_source;
    template <typename Callback>
    friend class stop_callback;
-    stop_token(shared_ptr<polyfill::stop_state> stop_state) : m_stop_state(std::move(stop_state)) {}
+    stop_token(shared_ptr<polyfill::stop_state> stop_state) : m_stop_state(move(stop_state)) {}

 private:
    shared_ptr<polyfill::stop_state> m_stop_state;
@@ -199,7 +198,7 @@ public:
 private:
    friend class jthread;
    explicit stop_source(shared_ptr<polyfill::stop_state> stop_state)
-        : m_stop_state(std::move(stop_state)) {}
+        : m_stop_state(move(stop_state)) {}

 private:
    shared_ptr<polyfill::stop_state> m_stop_state;
@@ -219,16 +218,16 @@ public:
                           C&& cb) noexcept(is_nothrow_constructible_v<Callback, C>)
        : m_stop_state(st.m_stop_state) {
        if (m_stop_state) {
-            m_callback = m_stop_state->insert_callback(std::move(cb));
+            m_callback = m_stop_state->insert_callback(move(cb));
        }
    }
    template <typename C>
        requires constructible_from<Callback, C>
    explicit stop_callback(stop_token&& st,
                           C&& cb) noexcept(is_nothrow_constructible_v<Callback, C>)
-        : m_stop_state(std::move(st.m_stop_state)) {
+        : m_stop_state(move(st.m_stop_state)) {
        if (m_stop_state) {
-            m_callback = m_stop_state->insert_callback(std::move(cb));
+            m_callback = m_stop_state->insert_callback(move(cb));
        }
    }
    ~stop_callback() {
@@ -261,7 +260,7 @@ public:
              typename = enable_if_t<!is_same_v<remove_cvref_t<F>, jthread>>>
    explicit jthread(F&& f, Args&&... args)
        : m_stop_state(make_shared<polyfill::stop_state>()),
-          m_thread(make_thread(std::forward<F>(f), std::forward<Args>(args)...)) {}
+          m_thread(make_thread(move(f), move(args)...)) {}

    ~jthread() {
        if (joinable()) {
@@ -318,9 +317,9 @@ private:
    template <typename F, typename... Args>
    thread make_thread(F&& f, Args&&... args) {
        if constexpr (is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>) {
-            return thread(std::forward<F>(f), get_stop_token(), std::forward<Args>(args)...);
+            return thread(move(f), get_stop_token(), move(args)...);
        } else {
-            return thread(std::forward<F>(f), std::forward<Args>(args)...);
+            return thread(move(f), move(args)...);
        }
    }

--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@@ -45,7 +45,6 @@ SWITCHABLE(CpuAccuracy, true);
 SWITCHABLE(FullscreenMode, true);
 SWITCHABLE(GpuAccuracy, true);
 SWITCHABLE(Language, true);
-SWITCHABLE(MemoryLayout, true);
 SWITCHABLE(NvdecEmulation, false);
 SWITCHABLE(Region, true);
 SWITCHABLE(RendererBackend, true);
@@ -62,10 +61,6 @@ SWITCHABLE(u32, false);
 SWITCHABLE(u8, false);
 SWITCHABLE(u8, true);

-// Used in UISettings
-// TODO see if we can move this to uisettings.cpp
-SWITCHABLE(ConfirmStop, true);
-
 #undef SETTING
 #undef SWITCHABLE
 #endif
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -67,7 +67,6 @@ SWITCHABLE(CpuAccuracy, true);
 SWITCHABLE(FullscreenMode, true);
 SWITCHABLE(GpuAccuracy, true);
 SWITCHABLE(Language, true);
-SWITCHABLE(MemoryLayout, true);
 SWITCHABLE(NvdecEmulation, false);
 SWITCHABLE(Region, true);
 SWITCHABLE(RendererBackend, true);
@@ -84,10 +83,6 @@ SWITCHABLE(u32, false);
 SWITCHABLE(u8, false);
 SWITCHABLE(u8, true);

-// Used in UISettings
-// TODO see if we can move this to uisettings.h
-SWITCHABLE(ConfirmStop, true);
-
 #undef SETTING
 #undef SWITCHABLE
 #endif
--- a/src/common/settings_enums.h
+++ b/src/common/settings_enums.h
@@ -133,8 +133,6 @@ ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);

 ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb);

-ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
-
 ENUM(FullscreenMode, Borderless, Exclusive);

 ENUM(NvdecEmulation, Off, Cpu, Gpu);
--- a/src/common/stb.cpp
+++ b/src/common/stb.cpp
@@ -1,8 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_RESIZE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-
-#include "common/stb.h"
--- a/src/common/stb.h
+++ b/src/common/stb.h
@@ -1,8 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <stb_image.h>
-#include <stb_image_resize.h>
-#include <stb_image_write.h>
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -11,7 +11,6 @@
 #include <mach/mach.h>
 #elif defined(_WIN32)
 #include <windows.h>
-#include "common/string_util.h"
 #else
 #if defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <pthread_np.h>
@@ -83,8 +82,29 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 #ifdef _MSC_VER

 // Sets the debugger-visible name of the current thread.
+// Uses trick documented in:
+// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
 void SetCurrentThreadName(const char* name) {
-    SetThreadDescription(GetCurrentThread(), UTF8ToUTF16W(name).data());
+    static const DWORD MS_VC_EXCEPTION = 0x406D1388;
+
+#pragma pack(push, 8)
+    struct THREADNAME_INFO {
+        DWORD dwType;     // must be 0x1000
+        LPCSTR szName;    // pointer to name (in user addr space)
+        DWORD dwThreadID; // thread ID (-1=caller thread)
+        DWORD dwFlags;    // reserved for future use, must be zero
+    } info;
+#pragma pack(pop)
+
+    info.dwType = 0x1000;
+    info.szName = name;
+    info.dwThreadID = std::numeric_limits<DWORD>::max();
+    info.dwFlags = 0;
+
+    __try {
+        RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
+    } __except (EXCEPTION_CONTINUE_EXECUTION) {
+    }
 }

 #else // !MSVC_VER, so must be POSIX threads
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -116,8 +116,11 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
            }
        }

-        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(dir->GetName(),
-                                                                  std::move(concat));
+        if (concat.empty()) {
+            return nullptr;
+        }
+
+        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
    }

    if (Common::FS::IsDir(path)) {
--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@@ -822,13 +822,11 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
                const char i = True(mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
                const char d = True(mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
                const char u = True(mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
-                const char p =
-                    True(mem_info.attribute & MemoryAttribute::PermissionLocked) ? 'P' : '-';

-                reply += fmt::format("  {:#012x} - {:#012x} {} {} {}{}{}{}{} [{}, {}]\n",
-                                     mem_info.base_address,
-                                     mem_info.base_address + mem_info.size - 1, perm, state, l, i,
-                                     d, u, p, mem_info.ipc_count, mem_info.device_count);
+                reply +=
+                    fmt::format("  {:#012x} - {:#012x} {} {} {}{}{}{} [{}, {}]\n",
+                                mem_info.base_address, mem_info.base_address + mem_info.size - 1,
+                                perm, state, l, i, d, u, mem_info.ipc_count, mem_info.device_count);
            }

            const uintptr_t next_address = mem_info.base_address + mem_info.size;
--- a/src/core/file_sys/fsmitm_romfsbuild.cpp
+++ b/src/core/file_sys/fsmitm_romfsbuild.cpp
@@ -107,56 +107,62 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {

 void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
                                       std::shared_ptr<RomFSBuildDirectoryContext> parent) {
-    for (auto& child_romfs_file : romfs_dir->GetFiles()) {
-        const auto name = child_romfs_file->GetName();
-        const auto child = std::make_shared<RomFSBuildFileContext>();
-        // Set child's path.
-        child->cur_path_ofs = parent->path_len + 1;
-        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
-        child->path = parent->path + "/" + name;
+    std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;

-        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
-            continue;
-        }
+    const auto entries = romfs_dir->GetEntries();

-        // Sanity check on path_len
-        ASSERT(child->path_len < FS_MAX_PATH);
+    for (const auto& kv : entries) {
+        if (kv.second == VfsEntryType::Directory) {
+            const auto child = std::make_shared<RomFSBuildDirectoryContext>();
+            // Set child's path.
+            child->cur_path_ofs = parent->path_len + 1;
+            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
+            child->path = parent->path + "/" + kv.first;

-        child->source = std::move(child_romfs_file);
+            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
+                continue;
+            }

-        if (ext_dir != nullptr) {
-            if (const auto ips = ext_dir->GetFile(name + ".ips")) {
-                if (auto patched = PatchIPS(child->source, ips)) {
-                    child->source = std::move(patched);
+            // Sanity check on path_len
+            ASSERT(child->path_len < FS_MAX_PATH);
+
+            if (AddDirectory(parent, child)) {
+                child_dirs.push_back(child);
+            }
+        } else {
+            const auto child = std::make_shared<RomFSBuildFileContext>();
+            // Set child's path.
+            child->cur_path_ofs = parent->path_len + 1;
+            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
+            child->path = parent->path + "/" + kv.first;
+
+            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
+                continue;
+            }
+
+            // Sanity check on path_len
+            ASSERT(child->path_len < FS_MAX_PATH);
+
+            child->source = romfs_dir->GetFile(kv.first);
+
+            if (ext_dir != nullptr) {
+                if (const auto ips = ext_dir->GetFile(kv.first + ".ips")) {
+                    if (auto patched = PatchIPS(child->source, ips)) {
+                        child->source = std::move(patched);
+                    }
                }
            }
+
+            child->size = child->source->GetSize();
+
+            AddFile(parent, child);
        }
-
-        child->size = child->source->GetSize();
-
-        AddFile(parent, child);
    }

-    for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) {
-        const auto name = child_romfs_dir->GetName();
-        const auto child = std::make_shared<RomFSBuildDirectoryContext>();
-        // Set child's path.
-        child->cur_path_ofs = parent->path_len + 1;
-        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
-        child->path = parent->path + "/" + name;
-
-        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
-            continue;
-        }
-
-        // Sanity check on path_len
-        ASSERT(child->path_len < FS_MAX_PATH);
-
-        if (!AddDirectory(parent, child)) {
-            continue;
-        }
-
-        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(name) : nullptr;
+    for (auto& child : child_dirs) {
+        auto subdir_name = std::string_view(child->path).substr(child->cur_path_ofs);
+        auto child_romfs_dir = romfs_dir->GetSubdirectory(subdir_name);
+        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(subdir_name) : nullptr;
        this->VisitDirectory(child_romfs_dir, child_ext_dir, child);
    }
 }
@@ -287,7 +293,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {

        cur_entry.name_size = name_size;

-        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
+        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, cur_file->source);
        std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry));
        std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0,
                    Common::AlignUp(cur_entry.name_size, 4));
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -377,16 +377,16 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t

        auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
        if (romfs_dir != nullptr)
-            layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(romfs_dir)));
+            layers.push_back(std::make_shared<CachedVfsDirectory>(romfs_dir));

        auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
        if (ext_dir != nullptr)
-            layers_ext.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(ext_dir)));
+            layers_ext.push_back(std::make_shared<CachedVfsDirectory>(ext_dir));

        if (type == ContentRecordType::HtmlDocument) {
            auto manual_dir = FindSubdirectoryCaseless(subdir, "manual_html");
            if (manual_dir != nullptr)
-                layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(manual_dir)));
+                layers.push_back(std::make_shared<CachedVfsDirectory>(manual_dir));
        }
    }

@@ -400,7 +400,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
        return;
    }

-    layers.emplace_back(std::move(extracted));
+    layers.push_back(std::move(extracted));

    auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
    if (layered == nullptr) {
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -322,8 +322,7 @@ VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& open_di
        return nullptr;
    }

-    auto name = concat.front()->GetName();
-    return ConcatenatedVfsFile::MakeConcatenatedFile(std::move(name), std::move(concat));
+    return ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
 }

 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
--- a/src/core/file_sys/romfs.cpp
+++ b/src/core/file_sys/romfs.cpp
@@ -133,7 +133,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
        out = out->GetSubdirectories().front();
    }

-    return std::make_shared<CachedVfsDirectory>(std::move(out));
+    return std::make_shared<CachedVfsDirectory>(out);
 }

 VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
@@ -141,7 +141,8 @@ VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
        return nullptr;

    RomFSBuildContext ctx{dir, ext};
-    return ConcatenatedVfsFile::MakeConcatenatedFile(0, dir->GetName(), ctx.Build());
+    auto file_map = ctx.Build();
+    return ConcatenatedVfsFile::MakeConcatenatedFile(0, file_map, dir->GetName());
 }

 } // namespace FileSys
--- a/src/core/file_sys/system_archive/system_version.cpp
+++ b/src/core/file_sys/system_archive/system_version.cpp
@@ -1,7 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include "common/logging/log.h"
 #include "core/file_sys/system_archive/system_version.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/hle/api_version.h"
@@ -13,9 +12,6 @@ std::string GetLongDisplayVersion() {
 }

 VirtualDir SystemVersion() {
-    LOG_WARNING(Common_Filesystem, "called - Using hardcoded firmware version '{}'",
-                GetLongDisplayVersion());
-
    VirtualFile file = std::make_shared<VectorVfsFile>(std::vector<u8>(0x100), "file");
    file->WriteObject(HLE::ApiVersion::HOS_VERSION_MAJOR, 0);
    file->WriteObject(HLE::ApiVersion::HOS_VERSION_MINOR, 1);
--- a/src/core/file_sys/vfs_cached.cpp
+++ b/src/core/file_sys/vfs_cached.cpp
@@ -6,13 +6,13 @@

 namespace FileSys {

-CachedVfsDirectory::CachedVfsDirectory(VirtualDir&& source_dir)
+CachedVfsDirectory::CachedVfsDirectory(VirtualDir& source_dir)
    : name(source_dir->GetName()), parent(source_dir->GetParentDirectory()) {
    for (auto& dir : source_dir->GetSubdirectories()) {
-        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(std::move(dir)));
+        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(dir));
    }
    for (auto& file : source_dir->GetFiles()) {
-        files.emplace(file->GetName(), std::move(file));
+        files.emplace(file->GetName(), file);
    }
 }

--- a/src/core/file_sys/vfs_cached.h
+++ b/src/core/file_sys/vfs_cached.h
@@ -11,7 +11,7 @@ namespace FileSys {

 class CachedVfsDirectory : public ReadOnlyVfsDirectory {
 public:
-    CachedVfsDirectory(VirtualDir&& source_directory);
+    CachedVfsDirectory(VirtualDir& source_directory);

    ~CachedVfsDirectory() override;
    VirtualFile GetFile(std::string_view file_name) const override;
--- a/src/core/file_sys/vfs_concat.cpp
+++ b/src/core/file_sys/vfs_concat.cpp
@@ -10,7 +10,7 @@

 namespace FileSys {

-ConcatenatedVfsFile::ConcatenatedVfsFile(std::string&& name_, ConcatenationMap&& concatenation_map_)
+ConcatenatedVfsFile::ConcatenatedVfsFile(ConcatenationMap&& concatenation_map_, std::string&& name_)
    : concatenation_map(std::move(concatenation_map_)), name(std::move(name_)) {
    DEBUG_ASSERT(this->VerifyContinuity());
 }
@@ -30,8 +30,8 @@ bool ConcatenatedVfsFile::VerifyContinuity() const {

 ConcatenatedVfsFile::~ConcatenatedVfsFile() = default;

-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
-                                                      std::vector<VirtualFile>&& files) {
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(const std::vector<VirtualFile>& files,
+                                                      std::string&& name) {
    // Fold trivial cases.
    if (files.empty()) {
        return nullptr;
@@ -46,21 +46,20 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
    u64 last_offset = 0;

    for (auto& file : files) {
-        const auto size = file->GetSize();
-
        concatenation_map.emplace_back(ConcatenationEntry{
            .offset = last_offset,
-            .file = std::move(file),
+            .file = file,
        });

-        last_offset += size;
+        last_offset += file->GetSize();
    }

-    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
 }

-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                                      std::multimap<u64, VirtualFile>&& files) {
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
+                                                      const std::multimap<u64, VirtualFile>& files,
+                                                      std::string&& name) {
    // Fold trivial cases.
    if (files.empty()) {
        return nullptr;
@@ -77,8 +76,6 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::strin

    // Iteration of a multimap is ordered, so offset will be strictly non-decreasing.
    for (auto& [offset, file] : files) {
-        const auto size = file->GetSize();
-
        if (offset > last_offset) {
            concatenation_map.emplace_back(ConcatenationEntry{
                .offset = last_offset,
@@ -88,13 +85,13 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::strin

        concatenation_map.emplace_back(ConcatenationEntry{
            .offset = offset,
-            .file = std::move(file),
+            .file = file,
        });

-        last_offset = offset + size;
+        last_offset = offset + file->GetSize();
    }

-    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
 }

 std::string ConcatenatedVfsFile::GetName() const {
--- a/src/core/file_sys/vfs_concat.h
+++ b/src/core/file_sys/vfs_concat.h
@@ -24,20 +24,22 @@ private:
    };
    using ConcatenationMap = std::vector<ConcatenationEntry>;

-    explicit ConcatenatedVfsFile(std::string&& name,
-                                 std::vector<ConcatenationEntry>&& concatenation_map);
+    explicit ConcatenatedVfsFile(std::vector<ConcatenationEntry>&& concatenation_map,
+                                 std::string&& name);
    bool VerifyContinuity() const;

 public:
    ~ConcatenatedVfsFile() override;

    /// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases.
-    static VirtualFile MakeConcatenatedFile(std::string&& name, std::vector<VirtualFile>&& files);
+    static VirtualFile MakeConcatenatedFile(const std::vector<VirtualFile>& files,
+                                            std::string&& name);

    /// Convenience function that turns a map of offsets to files into a concatenated file, filling
    /// gaps with a given filler byte.
-    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                            std::multimap<u64, VirtualFile>&& files);
+    static VirtualFile MakeConcatenatedFile(u8 filler_byte,
+                                            const std::multimap<u64, VirtualFile>& files,
+                                            std::string&& name);

    std::string GetName() const override;
    std::size_t GetSize() const override;
--- a/src/core/file_sys/vfs_layered.cpp
+++ b/src/core/file_sys/vfs_layered.cpp
@@ -38,7 +38,7 @@ VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) cons
    for (const auto& layer : dirs) {
        auto dir = layer->GetDirectoryRelative(path);
        if (dir != nullptr) {
-            out.emplace_back(std::move(dir));
+            out.push_back(std::move(dir));
        }
    }

@@ -62,11 +62,11 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
    std::set<std::string, std::less<>> out_names;

    for (const auto& layer : dirs) {
-        for (auto& file : layer->GetFiles()) {
+        for (const auto& file : layer->GetFiles()) {
            auto file_name = file->GetName();
            if (!out_names.contains(file_name)) {
                out_names.emplace(std::move(file_name));
-                out.emplace_back(std::move(file));
+                out.push_back(file);
            }
        }
    }
@@ -86,7 +86,7 @@ std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
    std::vector<VirtualDir> out;
    out.reserve(names.size());
    for (const auto& subdir : names)
-        out.emplace_back(GetSubdirectory(subdir));
+        out.push_back(GetSubdirectory(subdir));

    return out;
 }
--- a/src/core/hle/kernel/init/init_slab_setup.cpp
+++ b/src/core/hle/kernel/init/init_slab_setup.cpp
@@ -106,7 +106,7 @@ static_assert(KernelPageBufferAdditionalSize ==
 /// memory.
 static KPhysicalAddress TranslateSlabAddrToPhysical(KMemoryLayout& memory_layout,
                                                    KVirtualAddress slab_addr) {
-    slab_addr -= memory_layout.GetSlabRegion().GetAddress();
+    slab_addr -= GetInteger(memory_layout.GetSlabRegionAddress());
    return GetInteger(slab_addr) + Core::DramMemoryMap::SlabHeapBase;
 }

@@ -196,12 +196,7 @@ void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {
    auto& kernel = system.Kernel();

    // Get the start of the slab region, since that's where we'll be working.
-    const KMemoryRegion& slab_region = memory_layout.GetSlabRegion();
-    KVirtualAddress address = slab_region.GetAddress();
-
-    // Clear the slab region.
-    // TODO: implement access to kernel VAs.
-    // std::memset(device_ptr, 0, slab_region.GetSize());
+    KVirtualAddress address = memory_layout.GetSlabRegionAddress();

    // Initialize slab type array to be in sorted order.
    std::array<KSlabType, KSlabType_Count> slab_types;
--- a/src/core/hle/kernel/initial_process.h
+++ b/src/core/hle/kernel/initial_process.h
@@ -19,8 +19,4 @@ static inline KPhysicalAddress GetInitialProcessBinaryPhysicalAddress() {
        MainMemoryAddress);
 }

-static inline size_t GetInitialProcessBinarySize() {
-    return InitialProcessBinarySizeMax;
-}
-
 } // namespace Kernel
--- a/src/core/hle/kernel/k_memory_block.h
+++ b/src/core/hle/kernel/k_memory_block.h
@@ -36,7 +36,6 @@ enum class KMemoryState : u32 {
    FlagCanChangeAttribute = (1 << 24),
    FlagCanCodeMemory = (1 << 25),
    FlagLinearMapped = (1 << 26),
-    FlagCanPermissionLock = (1 << 27),

    FlagsData = FlagCanReprotect | FlagCanUseIpc | FlagCanUseNonDeviceIpc | FlagCanUseNonSecureIpc |
                FlagMapped | FlagCanAlias | FlagCanTransfer | FlagCanQueryPhysical |
@@ -51,16 +50,12 @@ enum class KMemoryState : u32 {
                FlagLinearMapped,

    Free = static_cast<u32>(Svc::MemoryState::Free),
-
-    IoMemory = static_cast<u32>(Svc::MemoryState::Io) | FlagMapped | FlagCanDeviceMap |
-               FlagCanAlignedDeviceMap,
-    IoRegister =
-        static_cast<u32>(Svc::MemoryState::Io) | FlagCanDeviceMap | FlagCanAlignedDeviceMap,
-
+    Io = static_cast<u32>(Svc::MemoryState::Io) | FlagMapped | FlagCanDeviceMap |
+         FlagCanAlignedDeviceMap,
    Static = static_cast<u32>(Svc::MemoryState::Static) | FlagMapped | FlagCanQueryPhysical,
    Code = static_cast<u32>(Svc::MemoryState::Code) | FlagsCode | FlagCanMapProcess,
    CodeData = static_cast<u32>(Svc::MemoryState::CodeData) | FlagsData | FlagCanMapProcess |
-               FlagCanCodeMemory | FlagCanPermissionLock,
+               FlagCanCodeMemory,
    Normal = static_cast<u32>(Svc::MemoryState::Normal) | FlagsData | FlagCanCodeMemory,
    Shared = static_cast<u32>(Svc::MemoryState::Shared) | FlagMapped | FlagReferenceCounted |
             FlagLinearMapped,
@@ -70,8 +65,7 @@ enum class KMemoryState : u32 {
    AliasCode = static_cast<u32>(Svc::MemoryState::AliasCode) | FlagsCode | FlagCanMapProcess |
                FlagCanCodeAlias,
    AliasCodeData = static_cast<u32>(Svc::MemoryState::AliasCodeData) | FlagsData |
-                    FlagCanMapProcess | FlagCanCodeAlias | FlagCanCodeMemory |
-                    FlagCanPermissionLock,
+                    FlagCanMapProcess | FlagCanCodeAlias | FlagCanCodeMemory,

    Ipc = static_cast<u32>(Svc::MemoryState::Ipc) | FlagsMisc | FlagCanAlignedDeviceMap |
          FlagCanUseIpc | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
@@ -79,7 +73,7 @@ enum class KMemoryState : u32 {
    Stack = static_cast<u32>(Svc::MemoryState::Stack) | FlagsMisc | FlagCanAlignedDeviceMap |
            FlagCanUseIpc | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,

-    ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagLinearMapped,
+    ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagLinearMapped,

    Transfered = static_cast<u32>(Svc::MemoryState::Transfered) | FlagsMisc |
                 FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
@@ -100,7 +94,7 @@ enum class KMemoryState : u32 {
    NonDeviceIpc =
        static_cast<u32>(Svc::MemoryState::NonDeviceIpc) | FlagsMisc | FlagCanUseNonDeviceIpc,

-    Kernel = static_cast<u32>(Svc::MemoryState::Kernel),
+    Kernel = static_cast<u32>(Svc::MemoryState::Kernel) | FlagMapped,

    GeneratedCode = static_cast<u32>(Svc::MemoryState::GeneratedCode) | FlagMapped |
                    FlagReferenceCounted | FlagCanDebug | FlagLinearMapped,
@@ -111,36 +105,34 @@ enum class KMemoryState : u32 {

    Insecure = static_cast<u32>(Svc::MemoryState::Insecure) | FlagMapped | FlagReferenceCounted |
               FlagLinearMapped | FlagCanChangeAttribute | FlagCanDeviceMap |
-               FlagCanAlignedDeviceMap | FlagCanQueryPhysical | FlagCanUseNonSecureIpc |
-               FlagCanUseNonDeviceIpc,
+               FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryState);

 static_assert(static_cast<u32>(KMemoryState::Free) == 0x00000000);
-static_assert(static_cast<u32>(KMemoryState::IoMemory) == 0x00182001);
-static_assert(static_cast<u32>(KMemoryState::IoRegister) == 0x00180001);
+static_assert(static_cast<u32>(KMemoryState::Io) == 0x00182001);
 static_assert(static_cast<u32>(KMemoryState::Static) == 0x00042002);
 static_assert(static_cast<u32>(KMemoryState::Code) == 0x04DC7E03);
-static_assert(static_cast<u32>(KMemoryState::CodeData) == 0x0FFEBD04);
+static_assert(static_cast<u32>(KMemoryState::CodeData) == 0x07FEBD04);
 static_assert(static_cast<u32>(KMemoryState::Normal) == 0x077EBD05);
 static_assert(static_cast<u32>(KMemoryState::Shared) == 0x04402006);

 static_assert(static_cast<u32>(KMemoryState::AliasCode) == 0x04DD7E08);
-static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x0FFFBD09);
+static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x07FFBD09);
 static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x045C3C0A);
 static_assert(static_cast<u32>(KMemoryState::Stack) == 0x045C3C0B);
-static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400000C);
+static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400200C);
 static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x055C3C0D);
 static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x045C380E);
 static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0440380F);
 static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010);
 static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x045C3811);
 static_assert(static_cast<u32>(KMemoryState::NonDeviceIpc) == 0x044C2812);
-static_assert(static_cast<u32>(KMemoryState::Kernel) == 0x00000013);
+static_assert(static_cast<u32>(KMemoryState::Kernel) == 0x00002013);
 static_assert(static_cast<u32>(KMemoryState::GeneratedCode) == 0x04402214);
 static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x04402015);
 static_assert(static_cast<u32>(KMemoryState::Coverage) == 0x00002016);
-static_assert(static_cast<u32>(KMemoryState::Insecure) == 0x055C3817);
+static_assert(static_cast<u32>(KMemoryState::Insecure) == 0x05583817);

 enum class KMemoryPermission : u8 {
    None = 0,
@@ -190,9 +182,8 @@ enum class KMemoryAttribute : u8 {
    IpcLocked = static_cast<u8>(Svc::MemoryAttribute::IpcLocked),
    DeviceShared = static_cast<u8>(Svc::MemoryAttribute::DeviceShared),
    Uncached = static_cast<u8>(Svc::MemoryAttribute::Uncached),
-    PermissionLocked = static_cast<u8>(Svc::MemoryAttribute::PermissionLocked),

-    SetMask = Uncached | PermissionLocked,
+    SetMask = Uncached,
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryAttribute);

@@ -270,10 +261,6 @@ struct KMemoryInfo {
        return m_state;
    }

-    constexpr Svc::MemoryState GetSvcState() const {
-        return static_cast<Svc::MemoryState>(m_state & KMemoryState::Mask);
-    }
-
    constexpr KMemoryPermission GetPermission() const {
        return m_permission;
    }
@@ -339,10 +326,6 @@ public:
        return this->GetEndAddress() - 1;
    }

-    constexpr KMemoryState GetState() const {
-        return m_memory_state;
-    }
-
    constexpr u16 GetIpcLockCount() const {
        return m_ipc_lock_count;
    }
@@ -460,13 +443,6 @@ public:
        }
    }

-    constexpr void UpdateAttribute(KMemoryAttribute mask, KMemoryAttribute attr) {
-        ASSERT(False(mask & KMemoryAttribute::IpcLocked));
-        ASSERT(False(mask & KMemoryAttribute::DeviceShared));
-
-        m_attribute = (m_attribute & ~mask) | attr;
-    }
-
    constexpr void Split(KMemoryBlock* block, KProcessAddress addr) {
        ASSERT(this->GetAddress() < addr);
        ASSERT(this->Contains(addr));
--- a/src/core/hle/kernel/k_memory_block_manager.cpp
+++ b/src/core/hle/kernel/k_memory_block_manager.cpp
@@ -160,8 +160,8 @@ void KMemoryBlockManager::Update(KMemoryBlockManagerUpdateAllocator* allocator,
            }

            // Update block state.
-            it->Update(state, perm, attr, it->GetAddress() == address,
-                       static_cast<u8>(set_disable_attr), static_cast<u8>(clear_disable_attr));
+            it->Update(state, perm, attr, cur_address == address, static_cast<u8>(set_disable_attr),
+                       static_cast<u8>(clear_disable_attr));
            cur_address += cur_info.GetSize();
            remaining_pages -= cur_info.GetNumPages();
        }
@@ -175,9 +175,7 @@ void KMemoryBlockManager::UpdateIfMatch(KMemoryBlockManagerUpdateAllocator* allo
                                        KProcessAddress address, size_t num_pages,
                                        KMemoryState test_state, KMemoryPermission test_perm,
                                        KMemoryAttribute test_attr, KMemoryState state,
-                                        KMemoryPermission perm, KMemoryAttribute attr,
-                                        KMemoryBlockDisableMergeAttribute set_disable_attr,
-                                        KMemoryBlockDisableMergeAttribute clear_disable_attr) {
+                                        KMemoryPermission perm, KMemoryAttribute attr) {
    // Ensure for auditing that we never end up with an invalid tree.
    KScopedMemoryBlockManagerAuditor auditor(this);
    ASSERT(Common::IsAligned(GetInteger(address), PageSize));
@@ -216,8 +214,7 @@ void KMemoryBlockManager::UpdateIfMatch(KMemoryBlockManagerUpdateAllocator* allo
            }

            // Update block state.
-            it->Update(state, perm, attr, false, static_cast<u8>(set_disable_attr),
-                       static_cast<u8>(clear_disable_attr));
+            it->Update(state, perm, attr, false, 0, 0);
            cur_address += cur_info.GetSize();
            remaining_pages -= cur_info.GetNumPages();
        } else {
@@ -287,65 +284,6 @@ void KMemoryBlockManager::UpdateLock(KMemoryBlockManagerUpdateAllocator* allocat
    this->CoalesceForUpdate(allocator, address, num_pages);
 }

-void KMemoryBlockManager::UpdateAttribute(KMemoryBlockManagerUpdateAllocator* allocator,
-                                          KProcessAddress address, size_t num_pages,
-                                          KMemoryAttribute mask, KMemoryAttribute attr) {
-    // Ensure for auditing that we never end up with an invalid tree.
-    KScopedMemoryBlockManagerAuditor auditor(this);
-    ASSERT(Common::IsAligned(GetInteger(address), PageSize));
-
-    KProcessAddress cur_address = address;
-    size_t remaining_pages = num_pages;
-    iterator it = this->FindIterator(address);
-
-    while (remaining_pages > 0) {
-        const size_t remaining_size = remaining_pages * PageSize;
-        KMemoryInfo cur_info = it->GetMemoryInfo();
-
-        if ((it->GetAttribute() & mask) != attr) {
-            // If we need to, create a new block before and insert it.
-            if (cur_info.GetAddress() != GetInteger(cur_address)) {
-                KMemoryBlock* new_block = allocator->Allocate();
-
-                it->Split(new_block, cur_address);
-                it = m_memory_block_tree.insert(*new_block);
-                it++;
-
-                cur_info = it->GetMemoryInfo();
-                cur_address = cur_info.GetAddress();
-            }
-
-            // If we need to, create a new block after and insert it.
-            if (cur_info.GetSize() > remaining_size) {
-                KMemoryBlock* new_block = allocator->Allocate();
-
-                it->Split(new_block, cur_address + remaining_size);
-                it = m_memory_block_tree.insert(*new_block);
-
-                cur_info = it->GetMemoryInfo();
-            }
-
-            // Update block state.
-            it->UpdateAttribute(mask, attr);
-            cur_address += cur_info.GetSize();
-            remaining_pages -= cur_info.GetNumPages();
-        } else {
-            // If we already have the right attributes, just advance.
-            if (cur_address + remaining_size < cur_info.GetEndAddress()) {
-                remaining_pages = 0;
-                cur_address += remaining_size;
-            } else {
-                remaining_pages =
-                    (cur_address + remaining_size - cur_info.GetEndAddress()) / PageSize;
-                cur_address = cur_info.GetEndAddress();
-            }
-        }
-        it++;
-    }
-
-    this->CoalesceForUpdate(allocator, address, num_pages);
-}
-
 // Debug.
 bool KMemoryBlockManager::CheckState() const {
    // Loop over every block, ensuring that we are sorted and coalesced.
--- a/src/core/hle/kernel/k_memory_block_manager.h
+++ b/src/core/hle/kernel/k_memory_block_manager.h
@@ -115,11 +115,7 @@ public:
    void UpdateIfMatch(KMemoryBlockManagerUpdateAllocator* allocator, KProcessAddress address,
                       size_t num_pages, KMemoryState test_state, KMemoryPermission test_perm,
                       KMemoryAttribute test_attr, KMemoryState state, KMemoryPermission perm,
-                       KMemoryAttribute attr, KMemoryBlockDisableMergeAttribute set_disable_attr,
-                       KMemoryBlockDisableMergeAttribute clear_disable_attr);
-
-    void UpdateAttribute(KMemoryBlockManagerUpdateAllocator* allocator, KProcessAddress address,
-                         size_t num_pages, KMemoryAttribute mask, KMemoryAttribute attr);
+                       KMemoryAttribute attr);

    iterator FindIterator(KProcessAddress address) const {
        return m_memory_block_tree.find(KMemoryBlock(
--- a/src/core/hle/kernel/k_memory_layout.h
+++ b/src/core/hle/kernel/k_memory_layout.h
@@ -137,9 +137,11 @@ public:
        return GetStackTopAddress(core_id, KMemoryRegionType_KernelMiscExceptionStack);
    }

-    const KMemoryRegion& GetSlabRegion() const {
-        return Dereference(GetVirtualMemoryRegionTree().FindByType(KMemoryRegionType_KernelSlab));
+    KVirtualAddress GetSlabRegionAddress() const {
+        return Dereference(GetVirtualMemoryRegionTree().FindByType(KMemoryRegionType_KernelSlab))
+            .GetAddress();
    }
+
    const KMemoryRegion& GetDeviceRegion(KMemoryRegionType type) const {
        return Dereference(GetPhysicalMemoryRegionTree().FindFirstDerived(type));
    }
--- a/src/core/hle/kernel/k_memory_manager.cpp
+++ b/src/core/hle/kernel/k_memory_manager.cpp
@@ -119,8 +119,7 @@ void KMemoryManager::Initialize(KVirtualAddress management_region, size_t manage
    // Free each region to its corresponding heap.
    size_t reserved_sizes[MaxManagerCount] = {};
    const KPhysicalAddress ini_start = GetInitialProcessBinaryPhysicalAddress();
-    const size_t ini_size = GetInitialProcessBinarySize();
-    const KPhysicalAddress ini_end = ini_start + ini_size;
+    const KPhysicalAddress ini_end = ini_start + InitialProcessBinarySizeMax;
    const KPhysicalAddress ini_last = ini_end - 1;
    for (const auto& it : m_system.Kernel().MemoryLayout().GetPhysicalMemoryRegionTree()) {
        if (it.IsDerivedFrom(KMemoryRegionType_DramUserPool)) {
@@ -138,13 +137,13 @@ void KMemoryManager::Initialize(KVirtualAddress management_region, size_t manage
                }

                // Open/reserve the ini memory.
-                manager.OpenFirst(ini_start, ini_size / PageSize);
-                reserved_sizes[it.GetAttributes()] += ini_size;
+                manager.OpenFirst(ini_start, InitialProcessBinarySizeMax / PageSize);
+                reserved_sizes[it.GetAttributes()] += InitialProcessBinarySizeMax;

                // Free memory after the ini to the heap.
                if (ini_last != cur_last) {
                    ASSERT(cur_end != 0);
-                    manager.Free(ini_end, (cur_end - ini_end) / PageSize);
+                    manager.Free(ini_end, cur_end - ini_end);
                }
            } else {
                // Ensure there's no partial overlap with the ini image.
--- a/src/core/hle/kernel/k_memory_region_type.h
+++ b/src/core/hle/kernel/k_memory_region_type.h
@@ -190,15 +190,9 @@ static_assert(KMemoryRegionType_DramKernelInitPt.GetValue() ==
 constexpr inline auto KMemoryRegionType_DramKernelSecureAppletMemory =
    KMemoryRegionType_DramKernelBase.DeriveSparse(1, 3, 0).SetAttribute(
        KMemoryRegionAttr_LinearMapped);
-constexpr inline const auto KMemoryRegionType_DramKernelSecureUnknown =
-    KMemoryRegionType_DramKernelBase.DeriveSparse(1, 3, 1).SetAttribute(
-        KMemoryRegionAttr_LinearMapped);
 static_assert(KMemoryRegionType_DramKernelSecureAppletMemory.GetValue() ==
              (0x18E | KMemoryRegionAttr_CarveoutProtected | KMemoryRegionAttr_NoUserMap |
               KMemoryRegionAttr_LinearMapped));
-static_assert(KMemoryRegionType_DramKernelSecureUnknown.GetValue() ==
-              (0x28E | KMemoryRegionAttr_CarveoutProtected | KMemoryRegionAttr_NoUserMap |
-               KMemoryRegionAttr_LinearMapped));

 constexpr inline auto KMemoryRegionType_DramReservedEarly =
    KMemoryRegionType_DramReservedBase.DeriveAttribute(KMemoryRegionAttr_NoUserMap);
@@ -223,18 +217,16 @@ constexpr inline auto KMemoryRegionType_DramPoolPartition =
 static_assert(KMemoryRegionType_DramPoolPartition.GetValue() ==
              (0x26 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));

-// UNUSED: .Derive(4, 1);
-// UNUSED: .Derive(4, 2);
-constexpr inline const auto KMemoryRegionType_DramPoolManagement =
-    KMemoryRegionType_DramPoolPartition.Derive(4, 0).SetAttribute(
+constexpr inline auto KMemoryRegionType_DramPoolManagement =
+    KMemoryRegionType_DramPoolPartition.DeriveTransition(0, 2).DeriveTransition().SetAttribute(
        KMemoryRegionAttr_CarveoutProtected);
-constexpr inline const auto KMemoryRegionType_DramUserPool =
-    KMemoryRegionType_DramPoolPartition.Derive(4, 3);
+constexpr inline auto KMemoryRegionType_DramUserPool =
+    KMemoryRegionType_DramPoolPartition.DeriveTransition(1, 2).DeriveTransition();
 static_assert(KMemoryRegionType_DramPoolManagement.GetValue() ==
-              (0xE6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
+              (0x166 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
               KMemoryRegionAttr_CarveoutProtected));
 static_assert(KMemoryRegionType_DramUserPool.GetValue() ==
-              (0x266 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
+              (0x1A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));

 constexpr inline auto KMemoryRegionType_DramApplicationPool =
    KMemoryRegionType_DramUserPool.Derive(4, 0);
@@ -245,63 +237,60 @@ constexpr inline auto KMemoryRegionType_DramSystemNonSecurePool =
 constexpr inline auto KMemoryRegionType_DramSystemPool =
    KMemoryRegionType_DramUserPool.Derive(4, 3).SetAttribute(KMemoryRegionAttr_CarveoutProtected);
 static_assert(KMemoryRegionType_DramApplicationPool.GetValue() ==
-              (0xE66 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
+              (0x7A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
 static_assert(KMemoryRegionType_DramAppletPool.GetValue() ==
-              (0x1666 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
+              (0xBA6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
 static_assert(KMemoryRegionType_DramSystemNonSecurePool.GetValue() ==
-              (0x1A66 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
+              (0xDA6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
 static_assert(KMemoryRegionType_DramSystemPool.GetValue() ==
-              (0x2666 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
+              (0x13A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
               KMemoryRegionAttr_CarveoutProtected));

 constexpr inline auto KMemoryRegionType_VirtualDramHeapBase =
-    KMemoryRegionType_Dram.DeriveSparse(1, 4, 0);
+    KMemoryRegionType_Dram.DeriveSparse(1, 3, 0);
 constexpr inline auto KMemoryRegionType_VirtualDramKernelPtHeap =
-    KMemoryRegionType_Dram.DeriveSparse(1, 4, 1);
+    KMemoryRegionType_Dram.DeriveSparse(1, 3, 1);
 constexpr inline auto KMemoryRegionType_VirtualDramKernelTraceBuffer =
-    KMemoryRegionType_Dram.DeriveSparse(1, 4, 2);
+    KMemoryRegionType_Dram.DeriveSparse(1, 3, 2);
 static_assert(KMemoryRegionType_VirtualDramHeapBase.GetValue() == 0x1A);
 static_assert(KMemoryRegionType_VirtualDramKernelPtHeap.GetValue() == 0x2A);
 static_assert(KMemoryRegionType_VirtualDramKernelTraceBuffer.GetValue() == 0x4A);

-// UNUSED: .Derive(4, 2);
-constexpr inline const auto KMemoryRegionType_VirtualDramUnknownDebug =
-    KMemoryRegionType_Dram.Advance(2).Derive(4, 0);
-constexpr inline const auto KMemoryRegionType_VirtualDramKernelSecureAppletMemory =
-    KMemoryRegionType_Dram.Advance(2).Derive(4, 1);
-constexpr inline const auto KMemoryRegionType_VirtualDramKernelSecureUnknown =
-    KMemoryRegionType_Dram.Advance(2).Derive(4, 3);
-static_assert(KMemoryRegionType_VirtualDramUnknownDebug.GetValue() == (0x32));
-static_assert(KMemoryRegionType_VirtualDramKernelSecureAppletMemory.GetValue() == (0x52));
-static_assert(KMemoryRegionType_VirtualDramKernelSecureUnknown.GetValue() == (0x92));
+// UNUSED: .DeriveSparse(2, 2, 0);
+constexpr inline auto KMemoryRegionType_VirtualDramUnknownDebug =
+    KMemoryRegionType_Dram.DeriveSparse(2, 2, 1);
+static_assert(KMemoryRegionType_VirtualDramUnknownDebug.GetValue() == (0x52));

-// UNUSED: .Derive(4, 3);
-constexpr inline const auto KMemoryRegionType_VirtualDramKernelInitPt =
-    KMemoryRegionType_VirtualDramHeapBase.Derive(4, 0);
-constexpr inline const auto KMemoryRegionType_VirtualDramPoolManagement =
-    KMemoryRegionType_VirtualDramHeapBase.Derive(4, 1);
-constexpr inline const auto KMemoryRegionType_VirtualDramUserPool =
-    KMemoryRegionType_VirtualDramHeapBase.Derive(4, 2);
-static_assert(KMemoryRegionType_VirtualDramKernelInitPt.GetValue() == 0x31A);
-static_assert(KMemoryRegionType_VirtualDramPoolManagement.GetValue() == 0x51A);
-static_assert(KMemoryRegionType_VirtualDramUserPool.GetValue() == 0x61A);
+constexpr inline auto KMemoryRegionType_VirtualDramKernelSecureAppletMemory =
+    KMemoryRegionType_Dram.DeriveSparse(3, 1, 0);
+static_assert(KMemoryRegionType_VirtualDramKernelSecureAppletMemory.GetValue() == (0x62));
+
+constexpr inline auto KMemoryRegionType_VirtualDramKernelInitPt =
+    KMemoryRegionType_VirtualDramHeapBase.Derive(3, 0);
+constexpr inline auto KMemoryRegionType_VirtualDramPoolManagement =
+    KMemoryRegionType_VirtualDramHeapBase.Derive(3, 1);
+constexpr inline auto KMemoryRegionType_VirtualDramUserPool =
+    KMemoryRegionType_VirtualDramHeapBase.Derive(3, 2);
+static_assert(KMemoryRegionType_VirtualDramKernelInitPt.GetValue() == 0x19A);
+static_assert(KMemoryRegionType_VirtualDramPoolManagement.GetValue() == 0x29A);
+static_assert(KMemoryRegionType_VirtualDramUserPool.GetValue() == 0x31A);

 // NOTE: For unknown reason, the pools are derived out-of-order here.
 // It's worth eventually trying to understand why Nintendo made this choice.
 // UNUSED: .Derive(6, 0);
 // UNUSED: .Derive(6, 1);
-constexpr inline const auto KMemoryRegionType_VirtualDramApplicationPool =
-    KMemoryRegionType_VirtualDramUserPool.Derive(4, 0);
-constexpr inline const auto KMemoryRegionType_VirtualDramAppletPool =
-    KMemoryRegionType_VirtualDramUserPool.Derive(4, 1);
-constexpr inline const auto KMemoryRegionType_VirtualDramSystemNonSecurePool =
-    KMemoryRegionType_VirtualDramUserPool.Derive(4, 2);
-constexpr inline const auto KMemoryRegionType_VirtualDramSystemPool =
-    KMemoryRegionType_VirtualDramUserPool.Derive(4, 3);
-static_assert(KMemoryRegionType_VirtualDramApplicationPool.GetValue() == 0x361A);
-static_assert(KMemoryRegionType_VirtualDramAppletPool.GetValue() == 0x561A);
-static_assert(KMemoryRegionType_VirtualDramSystemNonSecurePool.GetValue() == 0x661A);
-static_assert(KMemoryRegionType_VirtualDramSystemPool.GetValue() == 0x961A);
+constexpr inline auto KMemoryRegionType_VirtualDramAppletPool =
+    KMemoryRegionType_VirtualDramUserPool.Derive(6, 2);
+constexpr inline auto KMemoryRegionType_VirtualDramApplicationPool =
+    KMemoryRegionType_VirtualDramUserPool.Derive(6, 3);
+constexpr inline auto KMemoryRegionType_VirtualDramSystemNonSecurePool =
+    KMemoryRegionType_VirtualDramUserPool.Derive(6, 4);
+constexpr inline auto KMemoryRegionType_VirtualDramSystemPool =
+    KMemoryRegionType_VirtualDramUserPool.Derive(6, 5);
+static_assert(KMemoryRegionType_VirtualDramAppletPool.GetValue() == 0x1B1A);
+static_assert(KMemoryRegionType_VirtualDramApplicationPool.GetValue() == 0x271A);
+static_assert(KMemoryRegionType_VirtualDramSystemNonSecurePool.GetValue() == 0x2B1A);
+static_assert(KMemoryRegionType_VirtualDramSystemPool.GetValue() == 0x331A);

 constexpr inline auto KMemoryRegionType_ArchDeviceBase =
    KMemoryRegionType_Kernel.DeriveTransition(0, 1).SetSparseOnly();
@@ -365,14 +354,12 @@ constexpr inline auto KMemoryRegionType_KernelTemp =
 static_assert(KMemoryRegionType_KernelTemp.GetValue() == 0x31);

 constexpr KMemoryRegionType GetTypeForVirtualLinearMapping(u32 type_id) {
-    if (KMemoryRegionType_DramKernelPtHeap.IsAncestorOf(type_id)) {
+    if (KMemoryRegionType_KernelTraceBuffer.IsAncestorOf(type_id)) {
+        return KMemoryRegionType_VirtualDramKernelTraceBuffer;
+    } else if (KMemoryRegionType_DramKernelPtHeap.IsAncestorOf(type_id)) {
        return KMemoryRegionType_VirtualDramKernelPtHeap;
    } else if (KMemoryRegionType_DramKernelSecureAppletMemory.IsAncestorOf(type_id)) {
        return KMemoryRegionType_VirtualDramKernelSecureAppletMemory;
-    } else if (KMemoryRegionType_DramKernelSecureUnknown.IsAncestorOf(type_id)) {
-        return KMemoryRegionType_VirtualDramKernelSecureUnknown;
-    } else if (KMemoryRegionType_KernelTraceBuffer.IsAncestorOf(type_id)) {
-        return KMemoryRegionType_VirtualDramKernelTraceBuffer;
    } else if ((type_id | KMemoryRegionAttr_ShouldKernelMap) == type_id) {
        return KMemoryRegionType_VirtualDramUnknownDebug;
    } else {
--- a/src/core/hle/kernel/k_page_group.h
+++ b/src/core/hle/kernel/k_page_group.h
@@ -183,17 +183,12 @@ private:

 class KScopedPageGroup {
 public:
-    explicit KScopedPageGroup(const KPageGroup* gp, bool not_first = true) : m_pg(gp) {
+    explicit KScopedPageGroup(const KPageGroup* gp) : m_pg(gp) {
        if (m_pg) {
-            if (not_first) {
-                m_pg->Open();
-            } else {
-                m_pg->OpenFirst();
-            }
+            m_pg->Open();
        }
    }
-    explicit KScopedPageGroup(const KPageGroup& gp, bool not_first = true)
-        : KScopedPageGroup(std::addressof(gp), not_first) {}
+    explicit KScopedPageGroup(const KPageGroup& gp) : KScopedPageGroup(std::addressof(gp)) {}
    ~KScopedPageGroup() {
        if (m_pg) {
            m_pg->Close();
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -505,7 +505,7 @@ Result KPageTable::UnmapCodeMemory(KProcessAddress dst_address, KProcessAddress
    R_TRY(this->CheckMemoryStateContiguous(
        std::addressof(num_dst_allocator_blocks), dst_address, size, KMemoryState::FlagCanCodeAlias,
        KMemoryState::FlagCanCodeAlias, KMemoryPermission::None, KMemoryPermission::None,
-        KMemoryAttribute::All & ~KMemoryAttribute::PermissionLocked, KMemoryAttribute::None));
+        KMemoryAttribute::All, KMemoryAttribute::None));

    // Determine whether any pages being unmapped are code.
    bool any_code_pages = false;
@@ -1724,43 +1724,29 @@ Result KPageTable::MapPhysicalMemory(KProcessAddress address, size_t size) {
                            PageSize;

                        // While we have pages to map, map them.
-                        {
-                            // Create a page group for the current mapping range.
-                            KPageGroup cur_pg(m_kernel, m_block_info_manager);
-                            {
-                                ON_RESULT_FAILURE_2 {
-                                    cur_pg.OpenFirst();
-                                    cur_pg.Close();
-                                };
+                        while (map_pages > 0) {
+                            // Check if we're at the end of the physical block.
+                            if (pg_pages == 0) {
+                                // Ensure there are more pages to map.
+                                ASSERT(pg_it != pg.end());

-                                size_t remain_pages = map_pages;
-                                while (remain_pages > 0) {
-                                    // Check if we're at the end of the physical block.
-                                    if (pg_pages == 0) {
-                                        // Ensure there are more pages to map.
-                                        ASSERT(pg_it != pg.end());
-
-                                        // Advance our physical block.
-                                        ++pg_it;
-                                        pg_phys_addr = pg_it->GetAddress();
-                                        pg_pages = pg_it->GetNumPages();
-                                    }
-
-                                    // Add whatever we can to the current block.
-                                    const size_t cur_pages = std::min(pg_pages, remain_pages);
-                                    R_TRY(cur_pg.AddBlock(pg_phys_addr +
-                                                              ((pg_pages - cur_pages) * PageSize),
-                                                          cur_pages));
-
-                                    // Advance.
-                                    remain_pages -= cur_pages;
-                                    pg_pages -= cur_pages;
-                                }
+                                // Advance our physical block.
+                                ++pg_it;
+                                pg_phys_addr = pg_it->GetAddress();
+                                pg_pages = pg_it->GetNumPages();
                            }

-                            // Map the pages.
-                            R_TRY(this->Operate(cur_address, map_pages, cur_pg,
-                                                OperationType::MapFirstGroup));
+                            // Map whatever we can.
+                            const size_t cur_pages = std::min(pg_pages, map_pages);
+                            R_TRY(Operate(cur_address, cur_pages, KMemoryPermission::UserReadWrite,
+                                          OperationType::MapFirst, pg_phys_addr));
+
+                            // Advance.
+                            cur_address += cur_pages * PageSize;
+                            map_pages -= cur_pages;
+
+                            pg_phys_addr += cur_pages * PageSize;
+                            pg_pages -= cur_pages;
                        }
                    }

@@ -1784,11 +1770,7 @@ Result KPageTable::MapPhysicalMemory(KProcessAddress address, size_t size) {
                m_memory_block_manager.UpdateIfMatch(
                    std::addressof(allocator), address, size / PageSize, KMemoryState::Free,
                    KMemoryPermission::None, KMemoryAttribute::None, KMemoryState::Normal,
-                    KMemoryPermission::UserReadWrite, KMemoryAttribute::None,
-                    address == this->GetAliasRegionStart()
-                        ? KMemoryBlockDisableMergeAttribute::Normal
-                        : KMemoryBlockDisableMergeAttribute::None,
-                    KMemoryBlockDisableMergeAttribute::None);
+                    KMemoryPermission::UserReadWrite, KMemoryAttribute::None);

                R_SUCCEED();
            }
@@ -1886,13 +1868,6 @@ Result KPageTable::UnmapPhysicalMemory(KProcessAddress address, size_t size) {

    // Iterate over the memory, unmapping as we go.
    auto it = m_memory_block_manager.FindIterator(cur_address);
-
-    const auto clear_merge_attr =
-        (it->GetState() == KMemoryState::Normal &&
-         it->GetAddress() == this->GetAliasRegionStart() && it->GetAddress() == address)
-            ? KMemoryBlockDisableMergeAttribute::Normal
-            : KMemoryBlockDisableMergeAttribute::None;
-
    while (true) {
        // Check that the iterator is valid.
        ASSERT(it != m_memory_block_manager.end());
@@ -1930,7 +1905,7 @@ Result KPageTable::UnmapPhysicalMemory(KProcessAddress address, size_t size) {
    m_memory_block_manager.Update(std::addressof(allocator), address, size / PageSize,
                                  KMemoryState::Free, KMemoryPermission::None,
                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::None,
-                                  clear_merge_attr);
+                                  KMemoryBlockDisableMergeAttribute::None);

    // We succeeded.
    R_SUCCEED();
@@ -2404,7 +2379,8 @@ Result KPageTable::MapPageGroup(KProcessAddress* out_addr, const KPageGroup& pg,
    KScopedPageTableUpdater updater(this);

    // Perform mapping operation.
-    const KPageProperties properties = {perm, false, false, DisableMergeAttribute::DisableHead};
+    const KPageProperties properties = {perm, state == KMemoryState::Io, false,
+                                        DisableMergeAttribute::DisableHead};
    R_TRY(this->MapPageGroupImpl(updater.GetPageList(), addr, pg, properties, false));

    // Update the blocks.
@@ -2446,7 +2422,8 @@ Result KPageTable::MapPageGroup(KProcessAddress addr, const KPageGroup& pg, KMem
    KScopedPageTableUpdater updater(this);

    // Perform mapping operation.
-    const KPageProperties properties = {perm, false, false, DisableMergeAttribute::DisableHead};
+    const KPageProperties properties = {perm, state == KMemoryState::Io, false,
+                                        DisableMergeAttribute::DisableHead};
    R_TRY(this->MapPageGroupImpl(updater.GetPageList(), addr, pg, properties, false));

    // Update the blocks.
@@ -2675,18 +2652,11 @@ Result KPageTable::SetMemoryAttribute(KProcessAddress addr, size_t size, u32 mas
    size_t num_allocator_blocks;
    constexpr auto AttributeTestMask =
        ~(KMemoryAttribute::SetMask | KMemoryAttribute::DeviceShared);
-    const KMemoryState state_test_mask =
-        static_cast<KMemoryState>(((mask & static_cast<u32>(KMemoryAttribute::Uncached))
-                                       ? static_cast<u32>(KMemoryState::FlagCanChangeAttribute)
-                                       : 0) |
-                                  ((mask & static_cast<u32>(KMemoryAttribute::PermissionLocked))
-                                       ? static_cast<u32>(KMemoryState::FlagCanPermissionLock)
-                                       : 0));
-    R_TRY(this->CheckMemoryState(std::addressof(old_state), std::addressof(old_perm),
-                                 std::addressof(old_attr), std::addressof(num_allocator_blocks),
-                                 addr, size, state_test_mask, state_test_mask,
-                                 KMemoryPermission::None, KMemoryPermission::None,
-                                 AttributeTestMask, KMemoryAttribute::None, ~AttributeTestMask));
+    R_TRY(this->CheckMemoryState(
+        std::addressof(old_state), std::addressof(old_perm), std::addressof(old_attr),
+        std::addressof(num_allocator_blocks), addr, size, KMemoryState::FlagCanChangeAttribute,
+        KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
+        AttributeTestMask, KMemoryAttribute::None, ~AttributeTestMask));

    // Create an update allocator.
    Result allocator_result{ResultSuccess};
@@ -2694,17 +2664,18 @@ Result KPageTable::SetMemoryAttribute(KProcessAddress addr, size_t size, u32 mas
                                                 m_memory_block_slab_manager, num_allocator_blocks);
    R_TRY(allocator_result);

-    // If we need to, perform a change attribute operation.
-    if (True(KMemoryAttribute::Uncached & static_cast<KMemoryAttribute>(mask))) {
-        // Perform operation.
-        R_TRY(this->Operate(addr, num_pages, old_perm,
-                            OperationType::ChangePermissionsAndRefreshAndFlush, 0));
-    }
+    // Determine the new attribute.
+    const KMemoryAttribute new_attr =
+        static_cast<KMemoryAttribute>(((old_attr & static_cast<KMemoryAttribute>(~mask)) |
+                                       static_cast<KMemoryAttribute>(attr & mask)));
+
+    // Perform operation.
+    this->Operate(addr, num_pages, old_perm, OperationType::ChangePermissionsAndRefresh);

    // Update the blocks.
-    m_memory_block_manager.UpdateAttribute(std::addressof(allocator), addr, num_pages,
-                                           static_cast<KMemoryAttribute>(mask),
-                                           static_cast<KMemoryAttribute>(attr));
+    m_memory_block_manager.Update(std::addressof(allocator), addr, num_pages, old_state, old_perm,
+                                  new_attr, KMemoryBlockDisableMergeAttribute::None,
+                                  KMemoryBlockDisableMergeAttribute::None);

    R_SUCCEED();
 }
@@ -2892,8 +2863,7 @@ Result KPageTable::LockForMapDeviceAddressSpace(bool* out_is_io, KProcessAddress
                                      &KMemoryBlock::ShareToDevice, KMemoryPermission::None);

    // Set whether the locked memory was io.
-    *out_is_io =
-        static_cast<Svc::MemoryState>(old_state & KMemoryState::Mask) == Svc::MemoryState::Io;
+    *out_is_io = old_state == KMemoryState::Io;

    R_SUCCEED();
 }
@@ -3051,10 +3021,9 @@ Result KPageTable::Operate(KProcessAddress addr, size_t num_pages, const KPageGr
    ASSERT(num_pages == page_group.GetNumPages());

    switch (operation) {
-    case OperationType::MapGroup:
-    case OperationType::MapFirstGroup: {
+    case OperationType::MapGroup: {
        // We want to maintain a new reference to every page in the group.
-        KScopedPageGroup spg(page_group, operation != OperationType::MapFirstGroup);
+        KScopedPageGroup spg(page_group);

        for (const auto& node : page_group) {
            const size_t size{node.GetNumPages() * PageSize};
@@ -3096,6 +3065,7 @@ Result KPageTable::Operate(KProcessAddress addr, size_t num_pages, KMemoryPermis
        m_memory->UnmapRegion(*m_page_table_impl, addr, num_pages * PageSize);
        break;
    }
+    case OperationType::MapFirst:
    case OperationType::Map: {
        ASSERT(map_addr);
        ASSERT(Common::IsAligned(GetInteger(map_addr), PageSize));
@@ -3103,7 +3073,11 @@ Result KPageTable::Operate(KProcessAddress addr, size_t num_pages, KMemoryPermis

        // Open references to pages, if we should.
        if (IsHeapPhysicalAddress(m_kernel.MemoryLayout(), map_addr)) {
-            m_kernel.MemoryManager().Open(map_addr, num_pages);
+            if (operation == OperationType::MapFirst) {
+                m_kernel.MemoryManager().OpenFirst(map_addr, num_pages);
+            } else {
+                m_kernel.MemoryManager().Open(map_addr, num_pages);
+            }
        }
        break;
    }
@@ -3113,7 +3087,6 @@ Result KPageTable::Operate(KProcessAddress addr, size_t num_pages, KMemoryPermis
    }
    case OperationType::ChangePermissions:
    case OperationType::ChangePermissionsAndRefresh:
-    case OperationType::ChangePermissionsAndRefreshAndFlush:
        break;
    default:
        ASSERT(false);
@@ -3133,79 +3106,79 @@ void KPageTable::FinalizeUpdate(PageLinkedList* page_list) {
    }
 }

-KProcessAddress KPageTable::GetRegionAddress(Svc::MemoryState state) const {
+KProcessAddress KPageTable::GetRegionAddress(KMemoryState state) const {
    switch (state) {
-    case Svc::MemoryState::Free:
-    case Svc::MemoryState::Kernel:
+    case KMemoryState::Free:
+    case KMemoryState::Kernel:
        return m_address_space_start;
-    case Svc::MemoryState::Normal:
+    case KMemoryState::Normal:
        return m_heap_region_start;
-    case Svc::MemoryState::Ipc:
-    case Svc::MemoryState::NonSecureIpc:
-    case Svc::MemoryState::NonDeviceIpc:
+    case KMemoryState::Ipc:
+    case KMemoryState::NonSecureIpc:
+    case KMemoryState::NonDeviceIpc:
        return m_alias_region_start;
-    case Svc::MemoryState::Stack:
+    case KMemoryState::Stack:
        return m_stack_region_start;
-    case Svc::MemoryState::Static:
-    case Svc::MemoryState::ThreadLocal:
+    case KMemoryState::Static:
+    case KMemoryState::ThreadLocal:
        return m_kernel_map_region_start;
-    case Svc::MemoryState::Io:
-    case Svc::MemoryState::Shared:
-    case Svc::MemoryState::AliasCode:
-    case Svc::MemoryState::AliasCodeData:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
-    case Svc::MemoryState::SharedCode:
-    case Svc::MemoryState::GeneratedCode:
-    case Svc::MemoryState::CodeOut:
-    case Svc::MemoryState::Coverage:
-    case Svc::MemoryState::Insecure:
+    case KMemoryState::Io:
+    case KMemoryState::Shared:
+    case KMemoryState::AliasCode:
+    case KMemoryState::AliasCodeData:
+    case KMemoryState::Transfered:
+    case KMemoryState::SharedTransfered:
+    case KMemoryState::SharedCode:
+    case KMemoryState::GeneratedCode:
+    case KMemoryState::CodeOut:
+    case KMemoryState::Coverage:
+    case KMemoryState::Insecure:
        return m_alias_code_region_start;
-    case Svc::MemoryState::Code:
-    case Svc::MemoryState::CodeData:
+    case KMemoryState::Code:
+    case KMemoryState::CodeData:
        return m_code_region_start;
    default:
        UNREACHABLE();
    }
 }

-size_t KPageTable::GetRegionSize(Svc::MemoryState state) const {
+size_t KPageTable::GetRegionSize(KMemoryState state) const {
    switch (state) {
-    case Svc::MemoryState::Free:
-    case Svc::MemoryState::Kernel:
+    case KMemoryState::Free:
+    case KMemoryState::Kernel:
        return m_address_space_end - m_address_space_start;
-    case Svc::MemoryState::Normal:
+    case KMemoryState::Normal:
        return m_heap_region_end - m_heap_region_start;
-    case Svc::MemoryState::Ipc:
-    case Svc::MemoryState::NonSecureIpc:
-    case Svc::MemoryState::NonDeviceIpc:
+    case KMemoryState::Ipc:
+    case KMemoryState::NonSecureIpc:
+    case KMemoryState::NonDeviceIpc:
        return m_alias_region_end - m_alias_region_start;
-    case Svc::MemoryState::Stack:
+    case KMemoryState::Stack:
        return m_stack_region_end - m_stack_region_start;
-    case Svc::MemoryState::Static:
-    case Svc::MemoryState::ThreadLocal:
+    case KMemoryState::Static:
+    case KMemoryState::ThreadLocal:
        return m_kernel_map_region_end - m_kernel_map_region_start;
-    case Svc::MemoryState::Io:
-    case Svc::MemoryState::Shared:
-    case Svc::MemoryState::AliasCode:
-    case Svc::MemoryState::AliasCodeData:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
-    case Svc::MemoryState::SharedCode:
-    case Svc::MemoryState::GeneratedCode:
-    case Svc::MemoryState::CodeOut:
-    case Svc::MemoryState::Coverage:
-    case Svc::MemoryState::Insecure:
+    case KMemoryState::Io:
+    case KMemoryState::Shared:
+    case KMemoryState::AliasCode:
+    case KMemoryState::AliasCodeData:
+    case KMemoryState::Transfered:
+    case KMemoryState::SharedTransfered:
+    case KMemoryState::SharedCode:
+    case KMemoryState::GeneratedCode:
+    case KMemoryState::CodeOut:
+    case KMemoryState::Coverage:
+    case KMemoryState::Insecure:
        return m_alias_code_region_end - m_alias_code_region_start;
-    case Svc::MemoryState::Code:
-    case Svc::MemoryState::CodeData:
+    case KMemoryState::Code:
+    case KMemoryState::CodeData:
        return m_code_region_end - m_code_region_start;
    default:
        UNREACHABLE();
    }
 }

-bool KPageTable::CanContain(KProcessAddress addr, size_t size, Svc::MemoryState state) const {
+bool KPageTable::CanContain(KProcessAddress addr, size_t size, KMemoryState state) const {
    const KProcessAddress end = addr + size;
    const KProcessAddress last = end - 1;

@@ -3219,32 +3192,32 @@ bool KPageTable::CanContain(KProcessAddress addr, size_t size, Svc::MemoryState
    const bool is_in_alias = !(end <= m_alias_region_start || m_alias_region_end <= addr ||
                               m_alias_region_start == m_alias_region_end);
    switch (state) {
-    case Svc::MemoryState::Free:
-    case Svc::MemoryState::Kernel:
+    case KMemoryState::Free:
+    case KMemoryState::Kernel:
        return is_in_region;
-    case Svc::MemoryState::Io:
-    case Svc::MemoryState::Static:
-    case Svc::MemoryState::Code:
-    case Svc::MemoryState::CodeData:
-    case Svc::MemoryState::Shared:
-    case Svc::MemoryState::AliasCode:
-    case Svc::MemoryState::AliasCodeData:
-    case Svc::MemoryState::Stack:
-    case Svc::MemoryState::ThreadLocal:
-    case Svc::MemoryState::Transfered:
-    case Svc::MemoryState::SharedTransfered:
-    case Svc::MemoryState::SharedCode:
-    case Svc::MemoryState::GeneratedCode:
-    case Svc::MemoryState::CodeOut:
-    case Svc::MemoryState::Coverage:
-    case Svc::MemoryState::Insecure:
+    case KMemoryState::Io:
+    case KMemoryState::Static:
+    case KMemoryState::Code:
+    case KMemoryState::CodeData:
+    case KMemoryState::Shared:
+    case KMemoryState::AliasCode:
+    case KMemoryState::AliasCodeData:
+    case KMemoryState::Stack:
+    case KMemoryState::ThreadLocal:
+    case KMemoryState::Transfered:
+    case KMemoryState::SharedTransfered:
+    case KMemoryState::SharedCode:
+    case KMemoryState::GeneratedCode:
+    case KMemoryState::CodeOut:
+    case KMemoryState::Coverage:
+    case KMemoryState::Insecure:
        return is_in_region && !is_in_heap && !is_in_alias;
-    case Svc::MemoryState::Normal:
+    case KMemoryState::Normal:
        ASSERT(is_in_heap);
        return is_in_region && !is_in_alias;
-    case Svc::MemoryState::Ipc:
-    case Svc::MemoryState::NonSecureIpc:
-    case Svc::MemoryState::NonDeviceIpc:
+    case KMemoryState::Ipc:
+    case KMemoryState::NonSecureIpc:
+    case KMemoryState::NonDeviceIpc:
        ASSERT(is_in_alias);
        return is_in_region && !is_in_heap;
    default:
@@ -3308,16 +3281,21 @@ Result KPageTable::CheckMemoryStateContiguous(size_t* out_blocks_needed, KProces

 Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
                                    KMemoryAttribute* out_attr, size_t* out_blocks_needed,
-                                    KMemoryBlockManager::const_iterator it,
-                                    KProcessAddress last_addr, KMemoryState state_mask,
+                                    KProcessAddress addr, size_t size, KMemoryState state_mask,
                                    KMemoryState state, KMemoryPermission perm_mask,
                                    KMemoryPermission perm, KMemoryAttribute attr_mask,
                                    KMemoryAttribute attr, KMemoryAttribute ignore_attr) const {
    ASSERT(this->IsLockedByCurrentThread());

    // Get information about the first block.
+    const KProcessAddress last_addr = addr + size - 1;
+    KMemoryBlockManager::const_iterator it = m_memory_block_manager.FindIterator(addr);
    KMemoryInfo info = it->GetMemoryInfo();

+    // If the start address isn't aligned, we need a block.
+    const size_t blocks_for_start_align =
+        (Common::AlignDown(GetInteger(addr), PageSize) != info.GetAddress()) ? 1 : 0;
+
    // Validate all blocks in the range have correct state.
    const KMemoryState first_state = info.m_state;
    const KMemoryPermission first_perm = info.m_permission;
@@ -3343,6 +3321,10 @@ Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission*
        info = it->GetMemoryInfo();
    }

+    // If the end address isn't aligned, we need a block.
+    const size_t blocks_for_end_align =
+        (Common::AlignUp(GetInteger(addr) + size, PageSize) != info.GetEndAddress()) ? 1 : 0;
+
    // Write output state.
    if (out_state != nullptr) {
        *out_state = first_state;
@@ -3353,39 +3335,9 @@ Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission*
    if (out_attr != nullptr) {
        *out_attr = static_cast<KMemoryAttribute>(first_attr & ~ignore_attr);
    }
-
-    // If the end address isn't aligned, we need a block.
    if (out_blocks_needed != nullptr) {
-        const size_t blocks_for_end_align =
-            (Common::AlignDown(GetInteger(last_addr), PageSize) + PageSize != info.GetEndAddress())
-                ? 1
-                : 0;
-        *out_blocks_needed = blocks_for_end_align;
+        *out_blocks_needed = blocks_for_start_align + blocks_for_end_align;
    }
-
-    R_SUCCEED();
-}
-
-Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                    KMemoryAttribute* out_attr, size_t* out_blocks_needed,
-                                    KProcessAddress addr, size_t size, KMemoryState state_mask,
-                                    KMemoryState state, KMemoryPermission perm_mask,
-                                    KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                    KMemoryAttribute attr, KMemoryAttribute ignore_attr) const {
-    ASSERT(this->IsLockedByCurrentThread());
-
-    // Check memory state.
-    const KProcessAddress last_addr = addr + size - 1;
-    KMemoryBlockManager::const_iterator it = m_memory_block_manager.FindIterator(addr);
-    R_TRY(this->CheckMemoryState(out_state, out_perm, out_attr, out_blocks_needed, it, last_addr,
-                                 state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr));
-
-    // If the start address isn't aligned, we need a block.
-    if (out_blocks_needed != nullptr &&
-        Common::AlignDown(GetInteger(addr), PageSize) != it->GetAddress()) {
-        ++(*out_blocks_needed);
-    }
-
    R_SUCCEED();
 }

@@ -3453,11 +3405,6 @@ Result KPageTable::LockMemoryAndOpen(KPageGroup* out_pg, KPhysicalAddress* out_K
                                  new_attr, KMemoryBlockDisableMergeAttribute::Locked,
                                  KMemoryBlockDisableMergeAttribute::None);

-    // If we have an output page group, open.
-    if (out_pg) {
-        out_pg->Open();
-    }
-
    R_SUCCEED();
 }

--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -126,6 +126,8 @@ public:
        return m_block_info_manager;
    }

+    bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const;
+
    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
                    KPhysicalAddress phys_addr, KProcessAddress region_start,
                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm) {
@@ -160,21 +162,6 @@ public:
    void RemapPageGroup(PageLinkedList* page_list, KProcessAddress address, size_t size,
                        const KPageGroup& pg);

-    KProcessAddress GetRegionAddress(Svc::MemoryState state) const;
-    size_t GetRegionSize(Svc::MemoryState state) const;
-    bool CanContain(KProcessAddress addr, size_t size, Svc::MemoryState state) const;
-
-    KProcessAddress GetRegionAddress(KMemoryState state) const {
-        return this->GetRegionAddress(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-    size_t GetRegionSize(KMemoryState state) const {
-        return this->GetRegionSize(static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-    bool CanContain(KProcessAddress addr, size_t size, KMemoryState state) const {
-        return this->CanContain(addr, size,
-                                static_cast<Svc::MemoryState>(state & KMemoryState::Mask));
-    }
-
 protected:
    struct PageLinkedList {
    private:
@@ -217,13 +204,12 @@ protected:
 private:
    enum class OperationType : u32 {
        Map = 0,
-        MapGroup = 1,
-        MapFirstGroup = 2,
+        MapFirst = 1,
+        MapGroup = 2,
        Unmap = 3,
        ChangePermissions = 4,
        ChangePermissionsAndRefresh = 5,
-        ChangePermissionsAndRefreshAndFlush = 6,
-        Separate = 7,
+        Separate = 6,
    };

    static constexpr KMemoryAttribute DefaultMemoryIgnoreAttr =
@@ -242,6 +228,8 @@ private:
    Result Operate(KProcessAddress addr, size_t num_pages, KMemoryPermission perm,
                   OperationType operation, KPhysicalAddress map_addr = 0);
    void FinalizeUpdate(PageLinkedList* page_list);
+    KProcessAddress GetRegionAddress(KMemoryState state) const;
+    size_t GetRegionSize(KMemoryState state) const;

    KProcessAddress FindFreeArea(KProcessAddress region_start, size_t region_num_pages,
                                 size_t num_pages, size_t alignment, size_t offset,
@@ -262,13 +250,6 @@ private:
    Result CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, KMemoryState state,
                            KMemoryPermission perm_mask, KMemoryPermission perm,
                            KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
-    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
-                            KMemoryBlockManager::const_iterator it, KProcessAddress last_addr,
-                            KMemoryState state_mask, KMemoryState state,
-                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
                            KMemoryAttribute* out_attr, size_t* out_blocks_needed,
                            KProcessAddress addr, size_t size, KMemoryState state_mask,
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@@ -149,7 +149,7 @@ u64 KProcess::GetTotalPhysicalMemoryUsed() {
 }

 u64 KProcess::GetTotalPhysicalMemoryUsedWithoutSystemResource() {
-    return this->GetTotalPhysicalMemoryUsed() - this->GetSystemResourceSize();
+    return this->GetTotalPhysicalMemoryUsed() - this->GetSystemResourceUsage();
 }

 bool KProcess::ReleaseUserException(KThread* thread) {
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -623,33 +623,14 @@ struct KernelCore::Impl {
        ASSERT(memory_layout->GetPhysicalMemoryRegionTree().Insert(
            GetInteger(slab_start_phys_addr), slab_region_size, KMemoryRegionType_DramKernelSlab));

-        // Insert a physical region for the secure applet memory.
-        const auto secure_applet_end_phys_addr =
-            slab_end_phys_addr + KSystemControl::SecureAppletMemorySize;
-        if constexpr (KSystemControl::SecureAppletMemorySize > 0) {
-            ASSERT(memory_layout->GetPhysicalMemoryRegionTree().Insert(
-                GetInteger(slab_end_phys_addr), KSystemControl::SecureAppletMemorySize,
-                KMemoryRegionType_DramKernelSecureAppletMemory));
-        }
-
-        // Insert a physical region for the unknown debug2 region.
-        constexpr size_t SecureUnknownRegionSize = 0;
-        const size_t secure_unknown_size = SecureUnknownRegionSize;
-        const auto secure_unknown_end_phys_addr = secure_applet_end_phys_addr + secure_unknown_size;
-        if constexpr (SecureUnknownRegionSize > 0) {
-            ASSERT(memory_layout->GetPhysicalMemoryRegionTree().Insert(
-                GetInteger(secure_applet_end_phys_addr), secure_unknown_size,
-                KMemoryRegionType_DramKernelSecureUnknown));
-        }
-
        // Determine size available for kernel page table heaps, requiring > 8 MB.
        const KPhysicalAddress resource_end_phys_addr = slab_start_phys_addr + resource_region_size;
-        const size_t page_table_heap_size = resource_end_phys_addr - secure_unknown_end_phys_addr;
+        const size_t page_table_heap_size = resource_end_phys_addr - slab_end_phys_addr;
        ASSERT(page_table_heap_size / 4_MiB > 2);

        // Insert a physical region for the kernel page table heap region
        ASSERT(memory_layout->GetPhysicalMemoryRegionTree().Insert(
-            GetInteger(secure_unknown_end_phys_addr), page_table_heap_size,
+            GetInteger(slab_end_phys_addr), page_table_heap_size,
            KMemoryRegionType_DramKernelPtHeap));

        // All DRAM regions that we haven't tagged by this point will be mapped under the linear
--- a/src/core/hle/kernel/svc/svc_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_memory.cpp
@@ -76,7 +76,7 @@ Result MapUnmapMemorySanityChecks(const KPageTable& manager, u64 dst_addr, u64 s
 } // namespace

 Result SetMemoryPermission(Core::System& system, u64 address, u64 size, MemoryPermission perm) {
-    LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X}", address, size,
+    LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X", address, size,
              perm);

    // Validate address / size.
@@ -108,16 +108,10 @@ Result SetMemoryAttribute(Core::System& system, u64 address, u64 size, u32 mask,
    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);

    // Validate the attribute and mask.
-    constexpr u32 SupportedMask =
-        static_cast<u32>(MemoryAttribute::Uncached | MemoryAttribute::PermissionLocked);
+    constexpr u32 SupportedMask = static_cast<u32>(MemoryAttribute::Uncached);
    R_UNLESS((mask | attr) == mask, ResultInvalidCombination);
    R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination);

-    // Check that permission locked is either being set or not masked.
-    R_UNLESS((static_cast<Svc::MemoryAttribute>(mask) & Svc::MemoryAttribute::PermissionLocked) ==
-                 (static_cast<Svc::MemoryAttribute>(attr) & Svc::MemoryAttribute::PermissionLocked),
-             ResultInvalidCombination);
-
    // Validate that the region is in range for the current process.
    auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};
    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
--- a/src/core/hle/kernel/svc_types.h
+++ b/src/core/hle/kernel/svc_types.h
@@ -46,7 +46,6 @@ enum class MemoryAttribute : u32 {
    IpcLocked = (1 << 1),
    DeviceShared = (1 << 2),
    Uncached = (1 << 3),
-    PermissionLocked = (1 << 4),
 };
 DECLARE_ENUM_FLAG_OPERATORS(MemoryAttribute);

--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -49,7 +49,7 @@ public:
        : ServiceFramework{system_, "IManagerForSystemService"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, &IManagerForSystemService::CheckAvailability, "CheckAvailability"},
+            {0, nullptr, "CheckAvailability"},
            {1, nullptr, "GetAccountId"},
            {2, nullptr, "EnsureIdTokenCacheAsync"},
            {3, nullptr, "LoadIdTokenCache"},
@@ -78,13 +78,6 @@ public:

        RegisterHandlers(functions);
    }
-
-private:
-    void CheckAvailability(HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
 };

 // 3.0.0+
@@ -407,13 +400,13 @@ protected:
        IPC::RequestParser rp{ctx};
        const auto base = rp.PopRaw<ProfileBase>();

-        const auto image_data = ctx.ReadBufferA(0);
-        const auto user_data = ctx.ReadBufferX(0);
+        const auto user_data = ctx.ReadBuffer();
+        const auto image_data = ctx.ReadBuffer(1);

-        LOG_INFO(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
-                 Common::StringFromFixedZeroTerminatedBuffer(
-                     reinterpret_cast<const char*>(base.username.data()), base.username.size()),
-                 base.timestamp, base.user_uuid.RawString());
+        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
+                  Common::StringFromFixedZeroTerminatedBuffer(
+                      reinterpret_cast<const char*>(base.username.data()), base.username.size()),
+                  base.timestamp, base.user_uuid.RawString());

        if (user_data.size() < sizeof(UserData)) {
            LOG_ERROR(Service_ACC, "UserData buffer too small!");
@@ -844,29 +837,6 @@ void Module::Interface::InitializeApplicationInfoV2(HLERequestContext& ctx) {
    rb.Push(ResultSuccess);
 }

-void Module::Interface::BeginUserRegistration(HLERequestContext& ctx) {
-    const auto user_id = Common::UUID::MakeRandom();
-    profile_manager->CreateNewUser(user_id, "yuzu");
-
-    LOG_INFO(Service_ACC, "called, uuid={}", user_id.FormattedString());
-
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(user_id);
-}
-
-void Module::Interface::CompleteUserRegistration(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
-
-    LOG_INFO(Service_ACC, "called, uuid={}", user_id.FormattedString());
-
-    profile_manager->WriteUserSaveFile();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void Module::Interface::GetProfileEditor(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    Common::UUID user_id = rp.PopRaw<Common::UUID>();
@@ -910,17 +880,6 @@ void Module::Interface::StoreSaveDataThumbnailApplication(HLERequestContext& ctx
    StoreSaveDataThumbnail(ctx, uuid, tid);
 }

-void Module::Interface::GetBaasAccountManagerForSystemService(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto uuid = rp.PopRaw<Common::UUID>();
-
-    LOG_INFO(Service_ACC, "called, uuid=0x{}", uuid.RawString());
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IManagerForSystemService>(system, uuid);
-}
-
 void Module::Interface::StoreSaveDataThumbnailSystem(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto uuid = rp.PopRaw<Common::UUID>();
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -33,13 +33,10 @@ public:
        void TrySelectUserWithoutInteraction(HLERequestContext& ctx);
        void IsUserAccountSwitchLocked(HLERequestContext& ctx);
        void InitializeApplicationInfoV2(HLERequestContext& ctx);
-        void BeginUserRegistration(HLERequestContext& ctx);
-        void CompleteUserRegistration(HLERequestContext& ctx);
        void GetProfileEditor(HLERequestContext& ctx);
        void ListQualifiedUsers(HLERequestContext& ctx);
        void ListOpenContextStoredUsers(HLERequestContext& ctx);
        void StoreSaveDataThumbnailApplication(HLERequestContext& ctx);
-        void GetBaasAccountManagerForSystemService(HLERequestContext& ctx);
        void StoreSaveDataThumbnailSystem(HLERequestContext& ctx);

    private:
--- a/src/core/hle/service/acc/acc_su.cpp
+++ b/src/core/hle/service/acc/acc_su.cpp
@@ -23,7 +23,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
        {99, nullptr, "DebugActivateOpenContextRetention"},
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, &ACC_SU::GetBaasAccountManagerForSystemService, "GetBaasAccountManagerForSystemService"},
+        {102, nullptr, "GetBaasAccountManagerForSystemService"},
        {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
        {104, nullptr, "GetProfileUpdateNotifier"},
        {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},
@@ -40,8 +40,8 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
        {152, nullptr, "LoadSignedDeviceIdentifierCacheForNintendoAccount"},
        {190, nullptr, "GetUserLastOpenedApplication"},
        {191, nullptr, "ActivateOpenContextHolder"},
-        {200, &ACC_SU::BeginUserRegistration, "BeginUserRegistration"},
-        {201, &ACC_SU::CompleteUserRegistration, "CompleteUserRegistration"},
+        {200, nullptr, "BeginUserRegistration"},
+        {201, nullptr, "CompleteUserRegistration"},
        {202, nullptr, "CancelUserRegistration"},
        {203, nullptr, "DeleteUser"},
        {204, nullptr, "SetUserPosition"},
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -96,10 +96,9 @@ public:
    bool SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
                               const UserData& data_new);

-    void WriteUserSaveFile();
-
 private:
    void ParseUserSaveFile();
+    void WriteUserSaveFile();
    std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
    bool RemoveProfileAtIndex(std::size_t index);

--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -210,8 +210,8 @@ IDisplayController::IDisplayController(Core::System& system_)
        {21, nullptr, "ClearAppletTransitionBuffer"},
        {22, nullptr, "AcquireLastApplicationCaptureSharedBuffer"},
        {23, nullptr, "ReleaseLastApplicationCaptureSharedBuffer"},
-        {24, &IDisplayController::AcquireLastForegroundCaptureSharedBuffer, "AcquireLastForegroundCaptureSharedBuffer"},
-        {25, &IDisplayController::ReleaseLastForegroundCaptureSharedBuffer, "ReleaseLastForegroundCaptureSharedBuffer"},
+        {24, nullptr, "AcquireLastForegroundCaptureSharedBuffer"},
+        {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
        {26, &IDisplayController::AcquireCallerAppletCaptureSharedBuffer, "AcquireCallerAppletCaptureSharedBuffer"},
        {27, &IDisplayController::ReleaseCallerAppletCaptureSharedBuffer, "ReleaseCallerAppletCaptureSharedBuffer"},
        {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
@@ -239,22 +239,6 @@ void IDisplayController::TakeScreenShotOfOwnLayer(HLERequestContext& ctx) {
    rb.Push(ResultSuccess);
 }

-void IDisplayController::AcquireLastForegroundCaptureSharedBuffer(HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push(1U);
-    rb.Push(0);
-}
-
-void IDisplayController::ReleaseLastForegroundCaptureSharedBuffer(HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void IDisplayController::AcquireCallerAppletCaptureSharedBuffer(HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");

@@ -1573,7 +1557,7 @@ ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
        {100, nullptr, "CreateGameMovieTrimmer"},
        {101, nullptr, "ReserveResourceForMovieOperation"},
        {102, nullptr, "UnreserveResourceForMovieOperation"},
-        {110, &ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers, "GetMainAppletAvailableUsers"},
+        {110, nullptr, "GetMainAppletAvailableUsers"},
        {120, nullptr, "GetLaunchStorageInfoForDebug"},
        {130, nullptr, "GetGpuErrorDetectedSystemEvent"},
        {140, nullptr, "SetApplicationMemoryReservation"},
@@ -1668,25 +1652,6 @@ void ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(HLERequestContext&
    rb.PushRaw(applet_info);
 }

-void ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers(HLERequestContext& ctx) {
-    const Service::Account::ProfileManager manager{};
-    bool is_empty{true};
-    s32 user_count{-1};
-
-    LOG_INFO(Service_AM, "called");
-
-    if (manager.GetUserCount() > 0) {
-        is_empty = false;
-        user_count = static_cast<s32>(manager.GetUserCount());
-        ctx.WriteBuffer(manager.GetAllUsers());
-    }
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push<u8>(is_empty);
-    rb.Push(user_count);
-}
-
 void ILibraryAppletSelfAccessor::PushInShowAlbum() {
    const Applets::CommonArguments arguments{
        .arguments_version = Applets::CommonArgumentVersion::Version3,
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@@ -124,8 +124,6 @@ public:
 private:
    void GetCallerAppletCaptureImageEx(HLERequestContext& ctx);
    void TakeScreenShotOfOwnLayer(HLERequestContext& ctx);
-    void AcquireLastForegroundCaptureSharedBuffer(HLERequestContext& ctx);
-    void ReleaseLastForegroundCaptureSharedBuffer(HLERequestContext& ctx);
    void AcquireCallerAppletCaptureSharedBuffer(HLERequestContext& ctx);
    void ReleaseCallerAppletCaptureSharedBuffer(HLERequestContext& ctx);
 };
@@ -347,7 +345,6 @@ private:
    void GetLibraryAppletInfo(HLERequestContext& ctx);
    void ExitProcessAndReturn(HLERequestContext& ctx);
    void GetCallerAppletIdentityInfo(HLERequestContext& ctx);
-    void GetMainAppletAvailableUsers(HLERequestContext& ctx);

    void PushInShowAlbum();
    void PushInShowCabinetData();
--- a/src/core/hle/service/caps/caps.cpp
+++ b/src/core/hle/service/caps/caps.cpp
@@ -25,12 +25,11 @@ void LoopProcess(Core::System& system) {
    server_manager->RegisterNamedService(
        "caps:u", std::make_shared<IAlbumApplicationService>(system, album_manager));

-    server_manager->RegisterNamedService(
-        "caps:ss", std::make_shared<IScreenShotService>(system, album_manager));
+    server_manager->RegisterNamedService("caps:ss", std::make_shared<IScreenShotService>(system));
    server_manager->RegisterNamedService("caps:sc",
                                         std::make_shared<IScreenShotControlService>(system));
-    server_manager->RegisterNamedService(
-        "caps:su", std::make_shared<IScreenShotApplicationService>(system, album_manager));
+    server_manager->RegisterNamedService("caps:su",
+                                         std::make_shared<IScreenShotApplicationService>(system));

    ServerManager::RunServer(std::move(server_manager));
 }
--- a/src/core/hle/service/caps/caps_manager.cpp
+++ b/src/core/hle/service/caps/caps_manager.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <sstream>
+#include <stb_image.h>
+#include <stb_image_resize.h>

 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
-#include "common/stb.h"
 #include "core/core.h"
 #include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_result.h"
@@ -226,49 +227,6 @@ Result AlbumManager::LoadAlbumScreenShotThumbnail(
                     +static_cast<int>(out_image_output.height), decoder_options.flags);
 }

-Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
-                                    const ScreenShotAttribute& attribute,
-                                    std::span<const u8> image_data, u64 aruid) {
-    return SaveScreenShot(out_entry, attribute, {}, image_data, aruid);
-}
-
-Result AlbumManager::SaveScreenShot(ApplicationAlbumEntry& out_entry,
-                                    const ScreenShotAttribute& attribute,
-                                    const ApplicationData& app_data, std::span<const u8> image_data,
-                                    u64 aruid) {
-    const u64 title_id = system.GetApplicationProcessProgramID();
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
-
-    s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
-
-    if (result.IsError()) {
-        return result;
-    }
-
-    const auto date = ConvertToAlbumDateTime(posix_time);
-
-    return SaveImage(out_entry, image_data, title_id, date);
-}
-
-Result AlbumManager::SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
-                                          const ScreenShotAttribute& attribute,
-                                          const AlbumFileId& file_id,
-                                          std::span<const u8> image_data) {
-    const auto& user_clock = system.GetTimeManager().GetStandardUserSystemClockCore();
-
-    s64 posix_time{};
-    Result result = user_clock.GetCurrentTime(system, posix_time);
-
-    if (result.IsError()) {
-        return result;
-    }
-
-    const auto date = ConvertToAlbumDateTime(posix_time);
-
-    return SaveImage(out_entry, image_data, file_id.application_id, date);
-}
-
 Result AlbumManager::GetFile(std::filesystem::path& out_path, const AlbumFileId& file_id) const {
    const auto file = album_files.find(file_id);

@@ -407,47 +365,6 @@ Result AlbumManager::LoadImage(std::span<u8> out_image, const std::filesystem::p
    return ResultSuccess;
 }

-static void PNGToMemory(void* context, void* png, int len) {
-    std::vector<u8>* png_image = static_cast<std::vector<u8>*>(context);
-    png_image->reserve(len);
-    std::memcpy(png_image->data(), png, len);
-}
-
-Result AlbumManager::SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image,
-                               u64 title_id, const AlbumFileDateTime& date) const {
-    const auto screenshot_path =
-        Common::FS::GetYuzuPathString(Common::FS::YuzuPath::ScreenshotsDir);
-    const std::string formatted_date =
-        fmt::format("{:04}-{:02}-{:02}_{:02}-{:02}-{:02}-{:03}", date.year, date.month, date.day,
-                    date.hour, date.minute, date.second, 0);
-    const std::string file_path =
-        fmt::format("{}/{:016x}_{}.png", screenshot_path, title_id, formatted_date);
-
-    const Common::FS::IOFile db_file{file_path, Common::FS::FileAccessMode::Write,
-                                     Common::FS::FileType::BinaryFile};
-
-    std::vector<u8> png_image;
-    if (!stbi_write_png_to_func(PNGToMemory, &png_image, 1280, 720, STBI_rgb_alpha, image.data(),
-                                0)) {
-        return ResultFileCountLimit;
-    }
-
-    if (db_file.Write(png_image) != png_image.size()) {
-        return ResultFileCountLimit;
-    }
-
-    out_entry = {
-        .size = png_image.size(),
-        .hash = {},
-        .datetime = date,
-        .storage = AlbumStorage::Sd,
-        .content = ContentType::Screenshot,
-        .unknown = 1,
-    };
-
-    return ResultSuccess;
-}
-
 AlbumFileDateTime AlbumManager::ConvertToAlbumDateTime(u64 posix_time) const {
    Time::TimeZone::CalendarInfo calendar_date{};
    const auto& time_zone_manager =
--- a/src/core/hle/service/caps/caps_manager.h
+++ b/src/core/hle/service/caps/caps_manager.h
@@ -58,15 +58,6 @@ public:
                                        std::vector<u8>& out_image, const AlbumFileId& file_id,
                                        const ScreenShotDecodeOption& decoder_options) const;

-    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
-                          std::span<const u8> image_data, u64 aruid);
-    Result SaveScreenShot(ApplicationAlbumEntry& out_entry, const ScreenShotAttribute& attribute,
-                          const ApplicationData& app_data, std::span<const u8> image_data,
-                          u64 aruid);
-    Result SaveEditedScreenShot(ApplicationAlbumEntry& out_entry,
-                                const ScreenShotAttribute& attribute, const AlbumFileId& file_id,
-                                std::span<const u8> image_data);
-
 private:
    static constexpr std::size_t NandAlbumFileLimit = 1000;
    static constexpr std::size_t SdAlbumFileLimit = 10000;
@@ -76,8 +67,6 @@ private:
    Result GetAlbumEntry(AlbumEntry& out_entry, const std::filesystem::path& path) const;
    Result LoadImage(std::span<u8> out_image, const std::filesystem::path& path, int width,
                     int height, ScreenShotDecoderFlag flag) const;
-    Result SaveImage(ApplicationAlbumEntry& out_entry, std::span<const u8> image, u64 title_id,
-                     const AlbumFileDateTime& date) const;

    AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;

--- a/src/core/hle/service/caps/caps_ss.cpp
+++ b/src/core/hle/service/caps/caps_ss.cpp
@@ -1,25 +1,19 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include "common/logging/log.h"
-#include "core/hle/service/caps/caps_manager.h"
-#include "core/hle/service/caps/caps_types.h"
-#include "core/hle/service/ipc_helpers.h"
-
 #include "core/hle/service/caps/caps_ss.h"

 namespace Service::Capture {

-IScreenShotService::IScreenShotService(Core::System& system_,
-                                       std::shared_ptr<AlbumManager> album_manager)
-    : ServiceFramework{system_, "caps:ss"}, manager{album_manager} {
+IScreenShotService::IScreenShotService(Core::System& system_)
+    : ServiceFramework{system_, "caps:ss"} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {201, nullptr, "SaveScreenShot"},
        {202, nullptr, "SaveEditedScreenShot"},
-        {203, &IScreenShotService::SaveScreenShotEx0, "SaveScreenShotEx0"},
+        {203, nullptr, "SaveScreenShotEx0"},
        {204, nullptr, "SaveEditedScreenShotEx0"},
-        {206, &IScreenShotService::SaveEditedScreenShotEx1, "SaveEditedScreenShotEx1"},
+        {206, nullptr, "Unknown206"},
        {208, nullptr, "SaveScreenShotOfMovieEx1"},
        {1000, nullptr, "Unknown1000"},
    };
@@ -30,65 +24,4 @@ IScreenShotService::IScreenShotService(Core::System& system_,

 IScreenShotService::~IScreenShotService() = default;

-void IScreenShotService::SaveScreenShotEx0(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        u32 report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto image_data_buffer = ctx.ReadBuffer();
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
-                                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-void IScreenShotService::SaveEditedScreenShotEx1(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute;
-        u64 width;
-        u64 height;
-        u64 thumbnail_width;
-        u64 thumbnail_height;
-        AlbumFileId file_id;
-    };
-    static_assert(sizeof(Parameters) == 0x78, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto application_data_buffer = ctx.ReadBuffer(0);
-    const auto image_data_buffer = ctx.ReadBuffer(1);
-    const auto thumbnail_image_data_buffer = ctx.ReadBuffer(2);
-
-    LOG_INFO(Service_Capture,
-             "called, width={}, height={}, thumbnail_width={}, thumbnail_height={}, "
-             "application_id={:016x},  storage={},  type={}, app_data_buffer_size={}, "
-             "image_data_buffer_size={}, thumbnail_image_buffer_size={}",
-             parameters.width, parameters.height, parameters.thumbnail_width,
-             parameters.thumbnail_height, parameters.file_id.application_id,
-             parameters.file_id.storage, parameters.file_id.type, application_data_buffer.size(),
-             image_data_buffer.size(), thumbnail_image_data_buffer.size());
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveEditedScreenShot(entry, parameters.attribute,
-                                                      parameters.file_id, image_data_buffer);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
 } // namespace Service::Capture
--- a/src/core/hle/service/caps/caps_ss.h
+++ b/src/core/hle/service/caps/caps_ss.h
@@ -13,14 +13,8 @@ namespace Service::Capture {

 class IScreenShotService final : public ServiceFramework<IScreenShotService> {
 public:
-    explicit IScreenShotService(Core::System& system_, std::shared_ptr<AlbumManager> album_manager);
+    explicit IScreenShotService(Core::System& system_);
    ~IScreenShotService() override;
-
-private:
-    void SaveScreenShotEx0(HLERequestContext& ctx);
-    void SaveEditedScreenShotEx1(HLERequestContext& ctx);
-
-    std::shared_ptr<AlbumManager> manager;
 };

 } // namespace Service::Capture
--- a/src/core/hle/service/caps/caps_su.cpp
+++ b/src/core/hle/service/caps/caps_su.cpp
@@ -2,22 +2,19 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/logging/log.h"
-#include "core/hle/service/caps/caps_manager.h"
 #include "core/hle/service/caps/caps_su.h"
-#include "core/hle/service/caps/caps_types.h"
 #include "core/hle/service/ipc_helpers.h"

 namespace Service::Capture {

-IScreenShotApplicationService::IScreenShotApplicationService(
-    Core::System& system_, std::shared_ptr<AlbumManager> album_manager)
-    : ServiceFramework{system_, "caps:su"}, manager{album_manager} {
+IScreenShotApplicationService::IScreenShotApplicationService(Core::System& system_)
+    : ServiceFramework{system_, "caps:su"} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {32, &IScreenShotApplicationService::SetShimLibraryVersion, "SetShimLibraryVersion"},
        {201, nullptr, "SaveScreenShot"},
-        {203, &IScreenShotApplicationService::SaveScreenShotEx0, "SaveScreenShotEx0"},
-        {205, &IScreenShotApplicationService::SaveScreenShotEx1, "SaveScreenShotEx1"},
+        {203, nullptr, "SaveScreenShotEx0"},
+        {205, nullptr, "SaveScreenShotEx1"},
        {210, nullptr, "SaveScreenShotEx2"},
    };
    // clang-format on
@@ -39,62 +36,4 @@ void IScreenShotApplicationService::SetShimLibraryVersion(HLERequestContext& ctx
    rb.Push(ResultSuccess);
 }

-void IScreenShotApplicationService::SaveScreenShotEx0(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        AlbumReportOption report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto image_data_buffer = ctx.ReadBuffer();
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    const auto result = manager->SaveScreenShot(entry, parameters.attribute, image_data_buffer,
-                                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
-void IScreenShotApplicationService::SaveScreenShotEx1(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        ScreenShotAttribute attribute{};
-        AlbumReportOption report_option{};
-        INSERT_PADDING_BYTES(0x4);
-        u64 applet_resource_user_id{};
-    };
-    static_assert(sizeof(Parameters) == 0x50, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-    const auto app_data_buffer = ctx.ReadBuffer(0);
-    const auto image_data_buffer = ctx.ReadBuffer(1);
-
-    LOG_INFO(Service_Capture,
-             "called, report_option={}, image_data_buffer_size={}, applet_resource_user_id={}",
-             parameters.report_option, image_data_buffer.size(),
-             parameters.applet_resource_user_id);
-
-    ApplicationAlbumEntry entry{};
-    ApplicationData app_data{};
-    std::memcpy(&app_data, app_data_buffer.data(), sizeof(ApplicationData));
-    const auto result =
-        manager->SaveScreenShot(entry, parameters.attribute, app_data, image_data_buffer,
-                                parameters.applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 10};
-    rb.Push(result);
-    rb.PushRaw(entry);
-}
-
 } // namespace Service::Capture
--- a/src/core/hle/service/caps/caps_su.h
+++ b/src/core/hle/service/caps/caps_su.h
@@ -10,20 +10,14 @@ class System;
 }

 namespace Service::Capture {
-class AlbumManager;

 class IScreenShotApplicationService final : public ServiceFramework<IScreenShotApplicationService> {
 public:
-    explicit IScreenShotApplicationService(Core::System& system_,
-                                           std::shared_ptr<AlbumManager> album_manager);
+    explicit IScreenShotApplicationService(Core::System& system_);
    ~IScreenShotApplicationService() override;

 private:
    void SetShimLibraryVersion(HLERequestContext& ctx);
-    void SaveScreenShotEx0(HLERequestContext& ctx);
-    void SaveScreenShotEx1(HLERequestContext& ctx);
-
-    std::shared_ptr<AlbumManager> manager;
 };

 } // namespace Service::Capture
--- a/src/core/hle/service/caps/caps_types.h
+++ b/src/core/hle/service/caps/caps_types.h
@@ -20,8 +20,6 @@ enum class AlbumImageOrientation {
 enum class AlbumReportOption : s32 {
    Disable,
    Enable,
-    Unknown2,
-    Unknown3,
 };

 enum class ContentType : u8 {
--- a/src/core/hle/service/hle_ipc.cpp
+++ b/src/core/hle/service/hle_ipc.cpp
@@ -23,19 +23,6 @@
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"

-namespace {
-static thread_local std::array read_buffer_data_a{
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-};
-static thread_local std::array read_buffer_data_x{
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-    Common::ScratchBuffer<u8>(),
-};
-} // Anonymous namespace
-
 namespace Service {

 SessionRequestHandler::SessionRequestHandler(Kernel::KernelCore& kernel_, const char* service_name_)
@@ -341,61 +328,26 @@ std::vector<u8> HLERequestContext::ReadBufferCopy(std::size_t buffer_index) cons
    }
 }

-std::span<const u8> HLERequestContext::ReadBufferA(std::size_t buffer_index) const {
-    static thread_local std::array read_buffer_a{
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
-
-    ASSERT_OR_EXECUTE_MSG(
-        BufferDescriptorA().size() > buffer_index, { return {}; },
-        "BufferDescriptorA invalid buffer_index {}", buffer_index);
-    auto& read_buffer = read_buffer_a[buffer_index];
-    return read_buffer.Read(BufferDescriptorA()[buffer_index].Address(),
-                            BufferDescriptorA()[buffer_index].Size(),
-                            &read_buffer_data_a[buffer_index]);
-}
-
-std::span<const u8> HLERequestContext::ReadBufferX(std::size_t buffer_index) const {
-    static thread_local std::array read_buffer_x{
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-    };
-
-    ASSERT_OR_EXECUTE_MSG(
-        BufferDescriptorX().size() > buffer_index, { return {}; },
-        "BufferDescriptorX invalid buffer_index {}", buffer_index);
-    auto& read_buffer = read_buffer_x[buffer_index];
-    return read_buffer.Read(BufferDescriptorX()[buffer_index].Address(),
-                            BufferDescriptorX()[buffer_index].Size(),
-                            &read_buffer_data_x[buffer_index]);
-}
-
 std::span<const u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
    static thread_local std::array read_buffer_a{
        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
+    };
+    static thread_local std::array read_buffer_data_a{
+        Common::ScratchBuffer<u8>(),
+        Common::ScratchBuffer<u8>(),
    };
    static thread_local std::array read_buffer_x{
        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
-        Core::Memory::CpuGuestMemory<u8, Core::Memory::GuestMemoryFlags::SafeRead>(memory, 0, 0),
+    };
+    static thread_local std::array read_buffer_data_x{
+        Common::ScratchBuffer<u8>(),
+        Common::ScratchBuffer<u8>(),
    };

    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
-    const bool is_buffer_x{BufferDescriptorX().size() > buffer_index &&
-                           BufferDescriptorX()[buffer_index].Size()};
-
-    if (is_buffer_a && is_buffer_x) {
-        LOG_WARNING(Input, "Both buffer descriptors are available a.size={}, x.size={}",
-                    BufferDescriptorA()[buffer_index].Size(),
-                    BufferDescriptorX()[buffer_index].Size());
-    }
-
    if (is_buffer_a) {
        ASSERT_OR_EXECUTE_MSG(
            BufferDescriptorA().size() > buffer_index, { return {}; },
--- a/src/core/hle/service/hle_ipc.h
+++ b/src/core/hle/service/hle_ipc.h
@@ -253,12 +253,6 @@ public:
        return domain_message_header.has_value();
    }

-    /// Helper function to get a span of a buffer using the buffer descriptor A
-    [[nodiscard]] std::span<const u8> ReadBufferA(std::size_t buffer_index = 0) const;
-
-    /// Helper function to get a span of a buffer using the buffer descriptor X
-    [[nodiscard]] std::span<const u8> ReadBufferX(std::size_t buffer_index = 0) const;
-
    /// Helper function to get a span of a buffer using the appropriate buffer descriptor
    [[nodiscard]] std::span<const u8> ReadBuffer(std::size_t buffer_index = 0) const;

--- a/src/core/hle/service/mii/types/core_data.cpp
+++ b/src/core/hle/service/mii/types/core_data.cpp
@@ -41,7 +41,6 @@ void CoreData::BuildRandom(Age age, Gender gender, Race race) {
        }
    }

-    SetDefault();
    SetGender(gender);
    SetFavoriteColor(MiiUtil::GetRandomValue(FavoriteColor::Max));
    SetRegionMove(0);
--- a/src/core/hle/service/nvnflinger/buffer_queue_core.cpp
+++ b/src/core/hle/service/nvnflinger/buffer_queue_core.cpp
@@ -41,7 +41,7 @@ bool BufferQueueCore::WaitForDequeueCondition(std::unique_lock<std::mutex>& lk)
 s32 BufferQueueCore::GetMinUndequeuedBufferCountLocked(bool async) const {
    // If DequeueBuffer is allowed to error out, we don't have to add an extra buffer.
    if (!use_async_buffer) {
-        return 0;
+        return max_acquired_buffer_count;
    }

    if (dequeue_buffer_cannot_block || async) {
@@ -52,7 +52,7 @@ s32 BufferQueueCore::GetMinUndequeuedBufferCountLocked(bool async) const {
 }

 s32 BufferQueueCore::GetMinMaxBufferCountLocked(bool async) const {
-    return GetMinUndequeuedBufferCountLocked(async);
+    return GetMinUndequeuedBufferCountLocked(async) + 1;
 }

 s32 BufferQueueCore::GetMaxBufferCountLocked(bool async) const {
@@ -61,7 +61,7 @@ s32 BufferQueueCore::GetMaxBufferCountLocked(bool async) const {

    if (override_max_buffer_count != 0) {
        ASSERT(override_max_buffer_count >= min_buffer_count);
-        return override_max_buffer_count;
+        max_buffer_count = override_max_buffer_count;
    }

    // Any buffers that are dequeued by the producer or sitting in the queue waiting to be consumed
--- a/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
+++ b/src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
@@ -134,7 +134,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
        const s32 max_buffer_count = core->GetMaxBufferCountLocked(async);
        if (async && core->override_max_buffer_count) {
            if (core->override_max_buffer_count < max_buffer_count) {
-                *found = BufferQueueCore::INVALID_BUFFER_SLOT;
+                LOG_ERROR(Service_Nvnflinger, "async mode is invalid with buffer count override");
                return Status::BadValue;
            }
        }
@@ -142,8 +142,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
        // Free up any buffers that are in slots beyond the max buffer count
        for (s32 s = max_buffer_count; s < BufferQueueDefs::NUM_BUFFER_SLOTS; ++s) {
            ASSERT(slots[s].buffer_state == BufferState::Free);
-            if (slots[s].graphic_buffer != nullptr && slots[s].buffer_state == BufferState::Free &&
-                !slots[s].is_preallocated) {
+            if (slots[s].graphic_buffer != nullptr) {
                core->FreeBufferLocked(s);
                *return_flags |= Status::ReleaseAllBuffers;
            }
--- a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp
+++ b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp
@@ -46,7 +46,7 @@ Result AllocateIoForProcessAddressSpace(Common::ProcessAddress* out_map_address,
    // Get bounds of where mapping is possible.
    const VAddr alias_code_begin = GetInteger(page_table.GetAliasCodeRegionStart());
    const VAddr alias_code_size = page_table.GetAliasCodeRegionSize() / YUZU_PAGESIZE;
-    const auto state = Kernel::KMemoryState::IoMemory;
+    const auto state = Kernel::KMemoryState::Io;
    const auto perm = Kernel::KMemoryPermission::UserReadWrite;
    std::mt19937_64 rng{process->GetRandomEntropy(0)};

--- a/src/core/hle/service/prepo/prepo.cpp
+++ b/src/core/hle/service/prepo/prepo.cpp
@@ -58,8 +58,14 @@ private:
        IPC::RequestParser rp{ctx};
        const auto process_id = rp.PopRaw<u64>();

-        const auto data1 = ctx.ReadBufferA(0);
-        const auto data2 = ctx.ReadBufferX(0);
+        const auto data1 = ctx.ReadBuffer(0);
+        const auto data2 = [&ctx] {
+            if (ctx.CanReadBuffer(1)) {
+                return ctx.ReadBuffer(1);
+            }
+
+            return std::span<const u8>{};
+        }();

        LOG_DEBUG(Service_PREPO,
                  "called, type={:02X}, process_id={:016X}, data1_size={:016X}, data2_size={:016X}",
@@ -79,8 +85,14 @@ private:
        const auto user_id = rp.PopRaw<u128>();
        const auto process_id = rp.PopRaw<u64>();

-        const auto data1 = ctx.ReadBufferA(0);
-        const auto data2 = ctx.ReadBufferX(0);
+        const auto data1 = ctx.ReadBuffer(0);
+        const auto data2 = [&ctx] {
+            if (ctx.CanReadBuffer(1)) {
+                return ctx.ReadBuffer(1);
+            }
+
+            return std::span<const u8>{};
+        }();

        LOG_DEBUG(Service_PREPO,
                  "called, type={:02X}, user_id={:016X}{:016X}, process_id={:016X}, "
@@ -125,8 +137,14 @@ private:
        IPC::RequestParser rp{ctx};
        const auto title_id = rp.PopRaw<u64>();

-        const auto data1 = ctx.ReadBufferA(0);
-        const auto data2 = ctx.ReadBufferX(0);
+        const auto data1 = ctx.ReadBuffer(0);
+        const auto data2 = [&ctx] {
+            if (ctx.CanReadBuffer(1)) {
+                return ctx.ReadBuffer(1);
+            }
+
+            return std::span<const u8>{};
+        }();

        LOG_DEBUG(Service_PREPO, "called, title_id={:016X}, data1_size={:016X}, data2_size={:016X}",
                  title_id, data1.size(), data2.size());
@@ -143,8 +161,14 @@ private:
        const auto user_id = rp.PopRaw<u128>();
        const auto title_id = rp.PopRaw<u64>();

-        const auto data1 = ctx.ReadBufferA(0);
-        const auto data2 = ctx.ReadBufferX(0);
+        const auto data1 = ctx.ReadBuffer(0);
+        const auto data2 = [&ctx] {
+            if (ctx.CanReadBuffer(1)) {
+                return ctx.ReadBuffer(1);
+            }
+
+            return std::span<const u8>{};
+        }();

        LOG_DEBUG(Service_PREPO,
                  "called, user_id={:016X}{:016X}, title_id={:016X}, data1_size={:016X}, "
--- a/src/core/hle/service/ptm/ts.cpp
+++ b/src/core/hle/service/ptm/ts.cpp
@@ -9,35 +9,6 @@

 namespace Service::PTM {

-enum class Location : u8 {
-    Internal,
-    External,
-};
-
-class ISession : public ServiceFramework<ISession> {
-public:
-    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetTemperatureRange"},
-            {2, nullptr, "SetMeasurementMode"},
-            {4, &ISession::GetTemperature, "GetTemperature"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetTemperature(HLERequestContext& ctx) {
-        constexpr f32 temperature = 35;
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(temperature);
-    }
-};
-
 TS::TS(Core::System& system_) : ServiceFramework{system_, "ts"} {
    // clang-format off
    static const FunctionInfo functions[] = {
@@ -45,7 +16,7 @@ TS::TS(Core::System& system_) : ServiceFramework{system_, "ts"} {
        {1, &TS::GetTemperature, "GetTemperature"},
        {2, nullptr, "SetMeasurementMode"},
        {3, &TS::GetTemperatureMilliC, "GetTemperatureMilliC"},
-        {4, &TS::OpenSession, "OpenSession"},
+        {4, nullptr, "OpenSession"},
    };
    // clang-format on

@@ -76,13 +47,4 @@ void TS::GetTemperatureMilliC(HLERequestContext& ctx) {
    rb.Push(temperature);
 }

-void TS::OpenSession(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    [[maybe_unused]] const u32 device_code = rp.Pop<u32>();
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISession>(system);
-}
-
 } // namespace Service::PTM
--- a/src/core/hle/service/ptm/ts.h
+++ b/src/core/hle/service/ptm/ts.h
@@ -14,9 +14,13 @@ public:
    ~TS() override;

 private:
+    enum class Location : u8 {
+        Internal,
+        External,
+    };
+
    void GetTemperature(HLERequestContext& ctx);
    void GetTemperatureMilliC(HLERequestContext& ctx);
-    void OpenSession(HLERequestContext& ctx);
 };

 } // namespace Service::PTM
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -5,13 +5,8 @@
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "common/string_util.h"
-#include "core/core.h"
-#include "core/file_sys/content_archive.h"
 #include "core/file_sys/errors.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/system_archive/system_archive.h"
+#include "core/file_sys/system_archive/system_version.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/set/set.h"
@@ -27,30 +22,18 @@ enum class GetFirmwareVersionType {
    Version2,
 };

-void GetFirmwareVersionImpl(Core::System& system, HLERequestContext& ctx,
-                            GetFirmwareVersionType type) {
+void GetFirmwareVersionImpl(HLERequestContext& ctx, GetFirmwareVersionType type) {
+    LOG_WARNING(Service_SET, "called - Using hardcoded firmware version '{}'",
+                FileSys::SystemArchive::GetLongDisplayVersion());
+
    ASSERT_MSG(ctx.GetWriteBufferSize() == 0x100,
               "FirmwareVersion output buffer must be 0x100 bytes in size!");

-    constexpr u64 FirmwareVersionSystemDataId = 0x0100000000000809;
-    auto& fsc = system.GetFileSystemController();
-
-    // Attempt to load version data from disk
-    const FileSys::RegisteredCache* bis_system{};
-    std::unique_ptr<FileSys::NCA> nca{};
-    FileSys::VirtualDir romfs{};
-
-    bis_system = fsc.GetSystemNANDContents();
-    if (bis_system) {
-        nca = bis_system->GetEntry(FirmwareVersionSystemDataId, FileSys::ContentRecordType::Data);
-    }
-    if (nca) {
-        romfs = FileSys::ExtractRomFS(nca->GetRomFS());
-    }
-    if (!romfs) {
-        romfs = FileSys::ExtractRomFS(
-            FileSys::SystemArchive::SynthesizeSystemArchive(FirmwareVersionSystemDataId));
-    }
+    // Instead of using the normal procedure of checking for the real system archive and if it
+    // doesn't exist, synthesizing one, I feel that that would lead to strange bugs because a
+    // used is using a really old or really new SystemVersion title. The synthesized one ensures
+    // consistence (currently reports as 5.1.0-0.0)
+    const auto archive = FileSys::SystemArchive::SystemVersion();

    const auto early_exit_failure = [&ctx](std::string_view desc, Result code) {
        LOG_ERROR(Service_SET, "General failure while attempting to resolve firmware version ({}).",
@@ -59,7 +42,13 @@ void GetFirmwareVersionImpl(Core::System& system, HLERequestContext& ctx,
        rb.Push(code);
    };

-    const auto ver_file = romfs->GetFile("file");
+    if (archive == nullptr) {
+        early_exit_failure("The system version archive couldn't be synthesized.",
+                           FileSys::ERROR_FAILED_MOUNT_ARCHIVE);
+        return;
+    }
+
+    const auto ver_file = archive->GetFile("file");
    if (ver_file == nullptr) {
        early_exit_failure("The system version archive didn't contain the file 'file'.",
                           FileSys::ERROR_INVALID_ARGUMENT);
@@ -98,12 +87,12 @@ void SET_SYS::SetLanguageCode(HLERequestContext& ctx) {

 void SET_SYS::GetFirmwareVersion(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SET, "called");
-    GetFirmwareVersionImpl(system, ctx, GetFirmwareVersionType::Version1);
+    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version1);
 }

 void SET_SYS::GetFirmwareVersion2(HLERequestContext& ctx) {
    LOG_DEBUG(Service_SET, "called");
-    GetFirmwareVersionImpl(system, ctx, GetFirmwareVersionType::Version2);
+    GetFirmwareVersionImpl(ctx, GetFirmwareVersionType::Version2);
 }

 void SET_SYS::GetAccountSettings(HLERequestContext& ctx) {
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@@ -19,23 +19,16 @@ namespace Core::Memory {
 namespace {
 constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};

-std::string_view ExtractName(std::size_t& out_name_size, std::string_view data,
-                             std::size_t start_index, char match) {
+std::string_view ExtractName(std::string_view data, std::size_t start_index, char match) {
    auto end_index = start_index;
    while (data[end_index] != match) {
        ++end_index;
-        if (end_index > data.size()) {
+        if (end_index > data.size() ||
+            (end_index - start_index - 1) > sizeof(CheatDefinition::readable_name)) {
            return {};
        }
    }

-    out_name_size = end_index - start_index;
-
-    // Clamp name if it's too big
-    if (out_name_size > sizeof(CheatDefinition::readable_name)) {
-        end_index = start_index + sizeof(CheatDefinition::readable_name);
-    }
-
    return data.substr(start_index, end_index - start_index);
 }
 } // Anonymous namespace
@@ -120,8 +113,7 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                return {};
            }

-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, '}');
+            const auto name = ExtractName(data, i + 1, '}');
            if (name.empty()) {
                return {};
            }
@@ -133,13 +125,12 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
                '\0';

-            i += name_size + 1;
+            i += name.length() + 1;
        } else if (data[i] == '[') {
            current_entry = out.size();
            out.emplace_back();

-            std::size_t name_size{};
-            const auto name = ExtractName(name_size, data, i + 1, ']');
+            const auto name = ExtractName(data, i + 1, ']');
            if (name.empty()) {
                return {};
            }
@@ -151,7 +142,7 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                .definition.readable_name[out[*current_entry].definition.readable_name.size() - 1] =
                '\0';

-            i += name_size + 1;
+            i += name.length() + 1;
        } else if (::isxdigit(data[i])) {
            if (!current_entry || out[*current_entry].definition.num_opcodes >=
                                      out[*current_entry].definition.opcodes.size()) {
--- a/src/input_common/drivers/udp_client.cpp
+++ b/src/input_common/drivers/udp_client.cpp
@@ -338,7 +338,6 @@ void UDPClient::StartCommunication(std::size_t client, const std::string& host,
    for (std::size_t index = 0; index < PADS_PER_CLIENT; ++index) {
        const PadIdentifier identifier = GetPadIdentifier(client * PADS_PER_CLIENT + index);
        PreSetController(identifier);
-        PreSetMotion(identifier, 0);
    }
 }

--- a/src/shader_recompiler/backend/glsl/emit_glsl.cpp
+++ b/src/shader_recompiler/backend/glsl/emit_glsl.cpp
@@ -242,7 +242,6 @@ std::string EmitGLSL(const Profile& profile, const RuntimeInfo& runtime_info, IR
    }
    if (program.info.uses_subgroup_shuffles) {
        ctx.header += "bool shfl_in_bounds;";
-        ctx.header += "uint shfl_result;";
    }
    ctx.code.insert(0, ctx.header);
    ctx.code += '}';
--- a/src/shader_recompiler/backend/glsl/emit_glsl_warp.cpp
+++ b/src/shader_recompiler/backend/glsl/emit_glsl_warp.cpp
@@ -141,8 +141,7 @@ void EmitShuffleIndex(EmitContext& ctx, IR::Inst& inst, std::string_view value,
    const auto src_thread_id{fmt::format("({})|({})", lhs, min_thread_id)};
    ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
    SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }

 void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, std::string_view value, std::string_view index,
@@ -159,8 +158,7 @@ void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, std::string_view value, std
    const auto src_thread_id{fmt::format("({}-{})", THREAD_ID, index)};
    ctx.Add("shfl_in_bounds=int({})>=int({});", src_thread_id, max_thread_id);
    SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }

 void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
@@ -177,8 +175,7 @@ void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, std::string_view value,
    const auto src_thread_id{fmt::format("({}+{})", THREAD_ID, index)};
    ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
    SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }

 void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view value,
@@ -196,8 +193,7 @@ void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, std::string_view val
    const auto src_thread_id{fmt::format("({}^{})", THREAD_ID, index)};
    ctx.Add("shfl_in_bounds=int({})<=int({});", src_thread_id, max_thread_id);
    SetInBoundsFlag(ctx, inst);
-    ctx.Add("shfl_result=readInvocationARB({},{});", value, src_thread_id);
-    ctx.AddU32("{}=shfl_in_bounds?shfl_result:{};", inst, value);
+    ctx.AddU32("{}=shfl_in_bounds?readInvocationARB({},{}):{};", inst, value, src_thread_id, value);
 }

 void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, std::string_view op_a, std::string_view op_b,
--- a/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp
@@ -111,33 +111,16 @@ Id GetCbuf(EmitContext& ctx, Id result_type, Id UniformDefinitions::*member_ptr,
    } else if (element_size > 1) {
        const u32 log2_element_size{static_cast<u32>(std::countr_zero(element_size))};
        const Id shift{ctx.Const(log2_element_size)};
-        buffer_offset = ctx.OpShiftRightLogical(ctx.U32[1], ctx.Def(offset), shift);
+        buffer_offset = ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.Def(offset), shift);
    } else {
        buffer_offset = ctx.Def(offset);
    }
    if (!binding.IsImmediate()) {
        return ctx.OpFunctionCall(result_type, indirect_func, ctx.Def(binding), buffer_offset);
    }
-
    const Id cbuf{ctx.cbufs[binding.U32()].*member_ptr};
    const Id access_chain{ctx.OpAccessChain(uniform_type, cbuf, ctx.u32_zero_value, buffer_offset)};
-    const Id val = ctx.OpLoad(result_type, access_chain);
-
-    if (offset.IsImmediate() || !ctx.profile.has_broken_robust) {
-        return val;
-    }
-
-    const auto is_float = UniformDefinitions::IsFloat(member_ptr);
-    const auto num_elements = UniformDefinitions::NumElements(member_ptr);
-    const std::array zero_vec{
-        is_float ? ctx.Const(0.0f) : ctx.Const(0u),
-        is_float ? ctx.Const(0.0f) : ctx.Const(0u),
-        is_float ? ctx.Const(0.0f) : ctx.Const(0u),
-        is_float ? ctx.Const(0.0f) : ctx.Const(0u),
-    };
-    const Id cond = ctx.OpULessThanEqual(ctx.TypeBool(), buffer_offset, ctx.Const(0xFFFFu));
-    const Id zero = ctx.OpCompositeConstruct(result_type, std::span(zero_vec.data(), num_elements));
-    return ctx.OpSelect(result_type, cond, val, zero);
+    return ctx.OpLoad(result_type, access_chain);
 }

 Id GetCbufU32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset) {
@@ -155,7 +138,7 @@ Id GetCbufElement(EmitContext& ctx, Id vector, const IR::Value& offset, u32 inde
        const u32 element{(offset.U32() / 4) % 4 + index_offset};
        return ctx.OpCompositeExtract(ctx.U32[1], vector, element);
    }
-    const Id shift{ctx.OpShiftRightLogical(ctx.U32[1], ctx.Def(offset), ctx.Const(2u))};
+    const Id shift{ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.Def(offset), ctx.Const(2u))};
    Id element{ctx.OpBitwiseAnd(ctx.U32[1], shift, ctx.Const(3u))};
    if (index_offset > 0) {
        element = ctx.OpIAdd(ctx.U32[1], element, ctx.Const(index_offset));
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.h
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.h
@@ -64,42 +64,6 @@ struct UniformDefinitions {
    Id F32{};
    Id U32x2{};
    Id U32x4{};
-
-    constexpr static size_t NumElements(Id UniformDefinitions::*member_ptr) {
-        if (member_ptr == &UniformDefinitions::U8) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::S8) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::U16) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::S16) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::U32) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::F32) {
-            return 1;
-        }
-        if (member_ptr == &UniformDefinitions::U32x2) {
-            return 2;
-        }
-        if (member_ptr == &UniformDefinitions::U32x4) {
-            return 4;
-        }
-        ASSERT(false);
-        return 1;
-    }
-
-    constexpr static bool IsFloat(Id UniformDefinitions::*member_ptr) {
-        if (member_ptr == &UniformDefinitions::F32) {
-            return true;
-        }
-        return false;
-    }
 };

 struct StorageTypeDefinition {
--- a/src/shader_recompiler/profile.h
+++ b/src/shader_recompiler/profile.h
@@ -9,6 +9,7 @@ namespace Shader {

 struct Profile {
    u32 supported_spirv{0x00010000};
+
    bool unified_descriptor_binding{};
    bool support_descriptor_aliasing{};
    bool support_int8{};
@@ -81,9 +82,6 @@ struct Profile {
    bool has_broken_spirv_subgroup_mask_vector_extract_dynamic{};

    u32 gl_max_compute_smem_size{};
-
-    /// Maxwell and earlier nVidia architectures have broken robust support
-    bool has_broken_robust{};
 };

 } // namespace Shader
--- a/src/tests/common/unique_function.cpp
+++ b/src/tests/common/unique_function.cpp
@@ -46,8 +46,8 @@ TEST_CASE("UniqueFunction", "[common]") {
        Noisy noisy;
        REQUIRE(noisy.state == "Default constructed");

-        Common::UniqueFunction<void> func = [noisy_inner = std::move(noisy)] {
-            REQUIRE(noisy_inner.state == "Move constructed");
+        Common::UniqueFunction<void> func = [noisy = std::move(noisy)] {
+            REQUIRE(noisy.state == "Move constructed");
        };
        REQUIRE(noisy.state == "Moved away");
        func();
@@ -101,7 +101,7 @@ TEST_CASE("UniqueFunction", "[common]") {
        };
        Foo object{&num_destroyed};
        {
-            Common::UniqueFunction<void> func = [object_inner = std::move(object)] {};
+            Common::UniqueFunction<void> func = [object = std::move(object)] {};
            REQUIRE(num_destroyed == 0);
        }
        REQUIRE(num_destroyed == 1);
--- a/src/video_core/buffer_cache/buffer_cache_base.h
+++ b/src/video_core/buffer_cache/buffer_cache_base.h
@@ -62,11 +62,7 @@ using BufferId = SlotId;
 using VideoCore::Surface::PixelFormat;
 using namespace Common::Literals;

-#ifdef __APPLE__
-constexpr u32 NUM_VERTEX_BUFFERS = 16;
-#else
 constexpr u32 NUM_VERTEX_BUFFERS = 32;
-#endif
 constexpr u32 NUM_TRANSFORM_FEEDBACK_BUFFERS = 4;
 constexpr u32 NUM_GRAPHICS_UNIFORM_BUFFERS = 18;
 constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
--- a/src/video_core/engines/draw_manager.cpp
+++ b/src/video_core/engines/draw_manager.cpp
@@ -48,14 +48,8 @@ void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
        SetInlineIndexBuffer(regs.inline_index_4x8.index3);
        break;
    case MAXWELL3D_REG_INDEX(vertex_array_instance_first):
-        DrawArrayInstanced(regs.vertex_array_instance_first.topology.Value(),
-                           regs.vertex_array_instance_first.start.Value(),
-                           regs.vertex_array_instance_first.count.Value(), false);
-        break;
    case MAXWELL3D_REG_INDEX(vertex_array_instance_subsequent): {
-        DrawArrayInstanced(regs.vertex_array_instance_subsequent.topology.Value(),
-                           regs.vertex_array_instance_subsequent.start.Value(),
-                           regs.vertex_array_instance_subsequent.count.Value(), true);
+        LOG_WARNING(HW_GPU, "(STUBBED) called");
        break;
    }
    case MAXWELL3D_REG_INDEX(draw_texture.src_y0): {
@@ -90,22 +84,6 @@ void DrawManager::DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 ve
    ProcessDraw(false, num_instances);
 }

-void DrawManager::DrawArrayInstanced(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
-                                     bool subsequent) {
-    draw_state.topology = topology;
-    draw_state.vertex_buffer.first = vertex_first;
-    draw_state.vertex_buffer.count = vertex_count;
-
-    if (!subsequent) {
-        draw_state.instance_count = 1;
-    }
-
-    draw_state.base_instance = draw_state.instance_count - 1;
-    draw_state.draw_mode = DrawMode::Instance;
-    draw_state.instance_count++;
-    ProcessDraw(false, 1);
-}
-
 void DrawManager::DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count,
                            u32 base_index, u32 base_instance, u32 num_instances) {
    const auto& regs{maxwell3d->regs};
--- a/src/video_core/engines/draw_manager.h
+++ b/src/video_core/engines/draw_manager.h
@@ -66,8 +66,6 @@ public:

    void DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
                   u32 base_instance, u32 num_instances);
-    void DrawArrayInstanced(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
-                            bool subsequent);

    void DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index,
                   u32 base_instance, u32 num_instances);
--- a/src/video_core/fence_manager.h
+++ b/src/video_core/fence_manager.h
@@ -86,10 +86,7 @@ public:
            uncommitted_operations.emplace_back(std::move(func));
        }
        pending_operations.emplace_back(std::move(uncommitted_operations));
-        {
-            std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
-            QueueFence(new_fence);
-        }
+        QueueFence(new_fence);
        if (!delay_fence) {
            func();
        }
--- a/src/video_core/host1x/codecs/codec.cpp
+++ b/src/video_core/host1x/codecs/codec.cpp
@@ -137,6 +137,16 @@ bool Codec::CreateGpuAvDevice() {
                break;
            }
            if ((config->methods & HW_CONFIG_METHOD) != 0 && config->device_type == type) {
+#if defined(__unix__)
+                // Some linux decoding backends are reported to crash with this config method
+                // TODO(ameerj): Properly support this method
+                if ((config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) != 0) {
+                    // skip zero-copy decoders, we don't currently support them
+                    LOG_DEBUG(Service_NVDRV, "Skipping decoder {} with unsupported capability {}.",
+                              av_hwdevice_get_type_name(type), config->methods);
+                    continue;
+                }
+#endif
                LOG_INFO(Service_NVDRV, "Using {} GPU decoder", av_hwdevice_get_type_name(type));
                av_codec_ctx->pix_fmt = config->pix_fmt;
                return true;
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -19,7 +19,6 @@ set(SHADER_FILES
    block_linear_unswizzle_2d.comp
    block_linear_unswizzle_3d.comp
    convert_abgr8_to_d24s8.frag
-    convert_abgr8_to_d32f.frag
    convert_d32f_to_abgr8.frag
    convert_d24s8_to_abgr8.frag
    convert_depth_to_float.frag
--- a/src/video_core/host_shaders/convert_abgr8_to_d32f.frag
+++ b/src/video_core/host_shaders/convert_abgr8_to_d32f.frag
@@ -1,15 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#version 450
-
-layout(binding = 0) uniform sampler2D color_texture;
-
-void main() {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    vec4 color = texelFetch(color_texture, coord, 0).abgr;
-
-    float value = color.a * (color.r + color.g + color.b) / 3.0f;
-
-    gl_FragDepth = value;
-}
--- a/src/video_core/host_shaders/convert_d24s8_to_abgr8.frag
+++ b/src/video_core/host_shaders/convert_d24s8_to_abgr8.frag
@@ -3,16 +3,16 @@

 #version 450

-precision mediump int;
-precision highp float;
-
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform usampler2D stencil_tex;
+layout(binding = 1) uniform isampler2D stencil_tex;

 layout(location = 0) out vec4 color;

 void main() {
    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
+    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
+
    highp uint depth_val =
        uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
    lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;
--- a/src/video_core/host_shaders/convert_d32f_to_abgr8.frag
+++ b/src/video_core/host_shaders/convert_d32f_to_abgr8.frag
@@ -9,6 +9,6 @@ layout(location = 0) out vec4 color;

 void main() {
    ivec2 coord = ivec2(gl_FragCoord.xy);
-    float depth = texelFetch(depth_tex, coord, 0).r;
+    float depth = textureLod(depth_tex, coord, 0).r;
    color = vec4(depth, depth, depth, 1.0);
 }
--- a/src/video_core/host_shaders/convert_s8d24_to_abgr8.frag
+++ b/src/video_core/host_shaders/convert_s8d24_to_abgr8.frag
@@ -3,16 +3,16 @@

 #version 450

-precision mediump int;
-precision highp float;
-
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform usampler2D stencil_tex;
+layout(binding = 1) uniform isampler2D stencil_tex;

 layout(location = 0) out vec4 color;

 void main() {
    ivec2 coord = ivec2(gl_FragCoord.xy);
+    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
+    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
+
    highp uint depth_val =
        uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
    lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;
--- a/src/video_core/renderer_vulkan/blit_image.cpp
+++ b/src/video_core/renderer_vulkan/blit_image.cpp
@@ -8,7 +8,6 @@
 #include "common/settings.h"
 #include "video_core/host_shaders/blit_color_float_frag_spv.h"
 #include "video_core/host_shaders/convert_abgr8_to_d24s8_frag_spv.h"
-#include "video_core/host_shaders/convert_abgr8_to_d32f_frag_spv.h"
 #include "video_core/host_shaders/convert_d24s8_to_abgr8_frag_spv.h"
 #include "video_core/host_shaders/convert_d32f_to_abgr8_frag_spv.h"
 #include "video_core/host_shaders/convert_depth_to_float_frag_spv.h"
@@ -435,7 +434,6 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
      convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
      convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
      convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
-      convert_abgr8_to_d32f_frag(BuildShader(device, CONVERT_ABGR8_TO_D32F_FRAG_SPV)),
      convert_d32f_to_abgr8_frag(BuildShader(device, CONVERT_D32F_TO_ABGR8_FRAG_SPV)),
      convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
      convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),
@@ -561,13 +559,6 @@ void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
    Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view);
 }

-void BlitImageHelper::ConvertABGR8ToD32F(const Framebuffer* dst_framebuffer,
-                                         const ImageView& src_image_view) {
-    ConvertPipelineDepthTargetEx(convert_abgr8_to_d32f_pipeline, dst_framebuffer->RenderPass(),
-                                 convert_abgr8_to_d32f_frag);
-    Convert(*convert_abgr8_to_d32f_pipeline, dst_framebuffer, src_image_view);
-}
-
 void BlitImageHelper::ConvertD32FToABGR8(const Framebuffer* dst_framebuffer,
                                         ImageView& src_image_view) {
    ConvertPipelineColorTargetEx(convert_d32f_to_abgr8_pipeline, dst_framebuffer->RenderPass(),
--- a/src/video_core/renderer_vulkan/blit_image.h
+++ b/src/video_core/renderer_vulkan/blit_image.h
@@ -67,8 +67,6 @@ public:

    void ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);

-    void ConvertABGR8ToD32F(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);
-
    void ConvertD32FToABGR8(const Framebuffer* dst_framebuffer, ImageView& src_image_view);

    void ConvertD24S8ToABGR8(const Framebuffer* dst_framebuffer, ImageView& src_image_view);
@@ -132,7 +130,6 @@ private:
    vk::ShaderModule convert_depth_to_float_frag;
    vk::ShaderModule convert_float_to_depth_frag;
    vk::ShaderModule convert_abgr8_to_d24s8_frag;
-    vk::ShaderModule convert_abgr8_to_d32f_frag;
    vk::ShaderModule convert_d32f_to_abgr8_frag;
    vk::ShaderModule convert_d24s8_to_abgr8_frag;
    vk::ShaderModule convert_s8d24_to_abgr8_frag;
@@ -152,7 +149,6 @@ private:
    vk::Pipeline convert_d16_to_r16_pipeline;
    vk::Pipeline convert_r16_to_d16_pipeline;
    vk::Pipeline convert_abgr8_to_d24s8_pipeline;
-    vk::Pipeline convert_abgr8_to_d32f_pipeline;
    vk::Pipeline convert_d32f_to_abgr8_pipeline;
    vk::Pipeline convert_d24s8_to_abgr8_pipeline;
    vk::Pipeline convert_s8d24_to_abgr8_pipeline;
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -132,16 +132,12 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
    const bool use_accelerated =
        rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
    const bool is_srgb = use_accelerated && screen_info.is_srgb;
+    RenderScreenshot(*framebuffer, use_accelerated);

-    {
-        std::scoped_lock lock{rasterizer.LockCaches()};
-        RenderScreenshot(*framebuffer, use_accelerated);
-
-        Frame* frame = present_manager.GetRenderFrame();
-        blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
-        scheduler.Flush(*frame->render_ready);
-        present_manager.Present(frame);
-    }
+    Frame* frame = present_manager.GetRenderFrame();
+    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
+    scheduler.Flush(*frame->render_ready);
+    present_manager.Present(frame);

    gpu.RendererFrameEndNotify();
    rasterizer.TickFrame();
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -356,11 +356,7 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
        .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic =
-            driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
-        .has_broken_robust =
-            device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Maxwell,
-    };
-
+            driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY};
    host_info = Shader::HostTranslateInfo{
        .support_float64 = device.IsFloat64Supported(),
        .support_float16 = device.IsFloat16Supported(),
--- a/src/video_core/renderer_vulkan/vk_query_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_query_cache.cpp
@@ -1436,7 +1436,6 @@ void QueryCacheRuntime::Barriers(bool is_prebarrier) {
        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
    };
-    impl->scheduler.RequestOutsideRenderPassOperationContext();
    if (is_prebarrier) {
        impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -198,7 +198,7 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
    if (!pipeline) {
        return;
    }
-    std::scoped_lock lock{LockCaches()};
+    std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
    // update engine as channel may be different.
    pipeline->SetEngine(maxwell3d, gpu_memory);
    pipeline->Configure(is_indexed);
@@ -708,7 +708,6 @@ void RasterizerVulkan::TiledCacheBarrier() {
 }

 void RasterizerVulkan::FlushCommands() {
-    std::scoped_lock lock{LockCaches()};
    if (draw_counter == 0) {
        return;
    }
@@ -806,7 +805,6 @@ void RasterizerVulkan::FlushWork() {
    if ((++draw_counter & 7) != 7) {
        return;
    }
-    std::scoped_lock lock{LockCaches()};
    if (draw_counter < DRAWS_TO_DISPATCH) {
        // Send recorded tasks to the worker thread
        scheduler.DispatchWork();
@@ -977,19 +975,6 @@ void RasterizerVulkan::UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs
    if (!state_tracker.TouchScissors()) {
        return;
    }
-    if (!regs.viewport_scale_offset_enabled) {
-        const auto x = static_cast<float>(regs.surface_clip.x);
-        const auto y = static_cast<float>(regs.surface_clip.y);
-        const auto width = static_cast<float>(regs.surface_clip.width);
-        const auto height = static_cast<float>(regs.surface_clip.height);
-        VkRect2D scissor;
-        scissor.offset.x = static_cast<u32>(x);
-        scissor.offset.y = static_cast<u32>(y);
-        scissor.extent.width = static_cast<u32>(width != 0.0f ? width : 1.0f);
-        scissor.extent.height = static_cast<u32>(height != 0.0f ? height : 1.0f);
-        scheduler.Record([scissor](vk::CommandBuffer cmdbuf) { cmdbuf.SetScissor(0, scissor); });
-        return;
-    }
    u32 up_scale = 1;
    u32 down_shift = 0;
    if (texture_cache.IsRescaling()) {
@@ -1501,7 +1486,7 @@ void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs)
 void RasterizerVulkan::InitializeChannel(Tegra::Control::ChannelState& channel) {
    CreateChannel(channel);
    {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
        texture_cache.CreateChannel(channel);
        buffer_cache.CreateChannel(channel);
    }
@@ -1514,7 +1499,7 @@ void RasterizerVulkan::BindChannel(Tegra::Control::ChannelState& channel) {
    const s32 channel_id = channel.bind_id;
    BindToChannel(channel_id);
    {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
        texture_cache.BindToChannel(channel_id);
        buffer_cache.BindToChannel(channel_id);
    }
@@ -1527,7 +1512,7 @@ void RasterizerVulkan::BindChannel(Tegra::Control::ChannelState& channel) {
 void RasterizerVulkan::ReleaseChannel(s32 channel_id) {
    EraseChannel(channel_id);
    {
-        std::scoped_lock lock{LockCaches()};
+        std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
        texture_cache.EraseChannel(channel_id);
        buffer_cache.EraseChannel(channel_id);
    }
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -133,10 +133,6 @@ public:

    void ReleaseChannel(s32 channel_id) override;

-    std::scoped_lock<std::recursive_mutex, std::recursive_mutex> LockCaches() {
-        return std::scoped_lock{buffer_cache.mutex, texture_cache.mutex};
-    }
-
 private:
    static constexpr size_t MAX_TEXTURES = 192;
    static constexpr size_t MAX_IMAGES = 48;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
yuzubot	5b95f66146	Android #99	2023-10-13 00:57:52 +00:00
yuzubot	019d648d4e	Merge PR 11649	2023-10-13 00:57:52 +00:00