externals: Update dynarmic to 28714ee7

Reduces compilation times on MSVC.

src/core/frontend/applets/controller.cpp

@@ -45,26 +45,26 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
         if (parameters.allow_pro_controller) {
             controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-            controller->Connect(true);
+            controller->Connect();
         } else if (parameters.allow_dual_joycons) {
             controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconDual);
-            controller->Connect(true);
+            controller->Connect();
         } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
             // Assign left joycons to even player indices and right joycons to odd player indices.
             // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
             // a right Joycon for Player 2 in 2 Player Assist mode.
             if (index % 2 == 0) {
                 controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconLeft);
-                controller->Connect(true);
+                controller->Connect();
             } else {
                 controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconRight);
-                controller->Connect(true);
+                controller->Connect();
             }
         } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
                    !Settings::values.use_docked_mode.GetValue()) {
             // We should *never* reach here under any normal circumstances.
             controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-            controller->Connect(true);
+            controller->Connect();
         } else {
             UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");
         }

src/core/hid/emulated_controller.cpp

@@ -886,9 +886,8 @@ void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles)
     }
 }
 
-bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
-    const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
-    switch (type) {
+bool EmulatedController::IsControllerSupported() const {
+    switch (npad_type) {
     case NpadStyleIndex::ProController:
         return supported_style_tag.fullkey;
     case NpadStyleIndex::Handheld:
@@ -916,10 +915,9 @@ bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
     }
 }
 
-void EmulatedController::Connect(bool use_temporary_value) {
-    if (!IsControllerSupported(use_temporary_value)) {
-        const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
-        LOG_ERROR(Service_HID, "Controller type {} is not supported", type);
+void EmulatedController::Connect() {
+    if (!IsControllerSupported()) {
+        LOG_ERROR(Service_HID, "Controller type {} is not supported", npad_type);
         return;
     }
     {

src/core/hid/emulated_controller.h

@@ -167,11 +167,8 @@ public:
      */
     void SetSupportedNpadStyleTag(NpadStyleTag supported_styles);
 
-    /**
-     * Sets the connected status to true
-     * @param use_temporary_value If true tmp_npad_type will be used
-     */
-    void Connect(bool use_temporary_value = false);
+    /// Sets the connected status to true
+    void Connect();
 
     /// Sets the connected status to false
     void Disconnect();
@@ -322,10 +319,9 @@ private:
 
     /**
      * Checks the current controller type against the supported_style_tag
-     * @param use_temporary_value If true tmp_npad_type will be used
      * @return true if the controller is supported
      */
-    bool IsControllerSupported(bool use_temporary_value = false) const;
+    bool IsControllerSupported() const;
 
     /**
      * Updates the button status of the controller

src/core/hle/kernel/k_memory_block.h

@@ -120,7 +120,7 @@ static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x00402015);
 
 enum class KMemoryPermission : u8 {
     None = 0,
-    All = static_cast<u8>(~None),
+    Mask = static_cast<u8>(~None),
 
     Read = 1 << 0,
     Write = 1 << 1,

src/core/hle/kernel/k_page_table.cpp

@@ -264,9 +264,9 @@ ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_
     ASSERT(heap_last < stack_start || stack_last < heap_start);
     ASSERT(heap_last < kmap_start || kmap_last < heap_start);
 
-    current_heap_end = heap_region_start;
-    max_heap_size = 0;
-    mapped_physical_memory_size = 0;
+    current_heap_addr = heap_region_start;
+    heap_capacity = 0;
+    physical_memory_usage = 0;
     memory_pool = pool;
 
     page_table_impl.Resize(address_space_width, PageBits);
@@ -306,7 +306,7 @@ ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std:
     KMemoryState state{};
     KMemoryPermission perm{};
     CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, src_addr, size, KMemoryState::All,
-                                  KMemoryState::Normal, KMemoryPermission::All,
+                                  KMemoryState::Normal, KMemoryPermission::Mask,
                                   KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask,
                                   KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -465,7 +465,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
 
     MapPhysicalMemory(page_linked_list, addr, end_addr);
 
-    mapped_physical_memory_size += remaining_size;
+    physical_memory_usage += remaining_size;
 
     const std::size_t num_pages{size / PageSize};
     block_manager->Update(addr, num_pages, KMemoryState::Free, KMemoryPermission::None,
@@ -507,7 +507,7 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
 
     auto process{system.Kernel().CurrentProcess()};
     process->GetResourceLimit()->Release(LimitableResource::PhysicalMemory, mapped_size);
-    mapped_physical_memory_size -= mapped_size;
+    physical_memory_usage -= mapped_size;
 
     return ResultSuccess;
 }
@@ -554,7 +554,7 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     KMemoryState src_state{};
     CASCADE_CODE(CheckMemoryState(
         &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
-        KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::ReadAndWrite,
+        KMemoryState::FlagCanAlias, KMemoryPermission::Mask, KMemoryPermission::ReadAndWrite,
         KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
     if (IsRegionMapped(dst_addr, size)) {
@@ -593,7 +593,7 @@ ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     KMemoryState src_state{};
     CASCADE_CODE(CheckMemoryState(
         &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias,
-        KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::None,
+        KMemoryState::FlagCanAlias, KMemoryPermission::Mask, KMemoryPermission::None,
         KMemoryAttribute::Mask, KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped));
 
     KMemoryPermission dst_perm{};
@@ -784,7 +784,7 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo
     CASCADE_CODE(CheckMemoryState(
         &state, nullptr, &attribute, addr, size,
         KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted,
-        KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryPermission::All,
+        KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryPermission::Mask,
         KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask, KMemoryAttribute::None,
         KMemoryAttribute::IpcAndDeviceMapped));
 
@@ -859,125 +859,61 @@ ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryA
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetMaxHeapSize(std::size_t size) {
-    // Lock the table.
+ResultCode KPageTable::SetHeapCapacity(std::size_t new_heap_capacity) {
     std::lock_guard lock{page_table_lock};
-
-    // Only process page tables are allowed to set heap size.
-    ASSERT(!this->IsKernel());
-
-    max_heap_size = size;
-
+    heap_capacity = new_heap_capacity;
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
-    // Try to perform a reduction in heap, instead of an extension.
-    VAddr cur_address{};
-    std::size_t allocation_size{};
-    {
-        // Lock the table.
-        std::lock_guard lk(page_table_lock);
+ResultVal<VAddr> KPageTable::SetHeapSize(std::size_t size) {
 
-        // Validate that setting heap size is possible at all.
-        R_UNLESS(!is_kernel, ResultOutOfMemory);
-        R_UNLESS(size <= static_cast<std::size_t>(heap_region_end - heap_region_start),
-                 ResultOutOfMemory);
-        R_UNLESS(size <= max_heap_size, ResultOutOfMemory);
-
-        if (size < GetHeapSize()) {
-            // The size being requested is less than the current size, so we need to free the end of
-            // the heap.
-
-            // Validate memory state.
-            std::size_t num_allocator_blocks;
-            R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks),
-                                         heap_region_start + size, GetHeapSize() - size,
-                                         KMemoryState::All, KMemoryState::Normal,
-                                         KMemoryPermission::All, KMemoryPermission::ReadAndWrite,
-                                         KMemoryAttribute::All, KMemoryAttribute::None));
-
-            // Unmap the end of the heap.
-            const auto num_pages = (GetHeapSize() - size) / PageSize;
-            R_TRY(Operate(heap_region_start + size, num_pages, KMemoryPermission::None,
-                          OperationType::Unmap));
-
-            // Release the memory from the resource limit.
-            system.Kernel().CurrentProcess()->GetResourceLimit()->Release(
-                LimitableResource::PhysicalMemory, num_pages * PageSize);
-
-            // Apply the memory block update.
-            block_manager->Update(heap_region_start + size, num_pages, KMemoryState::Free,
-                                  KMemoryPermission::None, KMemoryAttribute::None);
-
-            // Update the current heap end.
-            current_heap_end = heap_region_start + size;
-
-            // Set the output.
-            *out = heap_region_start;
-            return ResultSuccess;
-        } else if (size == GetHeapSize()) {
-            // The size requested is exactly the current size.
-            *out = heap_region_start;
-            return ResultSuccess;
-        } else {
-            // We have to allocate memory. Determine how much to allocate and where while the table
-            // is locked.
-            cur_address = current_heap_end;
-            allocation_size = size - GetHeapSize();
-        }
+    if (size > heap_region_end - heap_region_start) {
+        return ResultOutOfMemory;
     }
 
-    // Reserve memory for the heap extension.
-    KScopedResourceReservation memory_reservation(
-        system.Kernel().CurrentProcess()->GetResourceLimit(), LimitableResource::PhysicalMemory,
-        allocation_size);
-    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
+    const u64 previous_heap_size{GetHeapSize()};
 
-    // Allocate pages for the heap extension.
-    KPageLinkedList page_linked_list;
-    R_TRY(system.Kernel().MemoryManager().Allocate(page_linked_list, allocation_size / PageSize,
-                                                   memory_pool));
+    UNIMPLEMENTED_IF_MSG(previous_heap_size > size, "Heap shrink is unimplemented");
 
-    // Map the pages.
+    // Increase the heap size
     {
-        // Lock the table.
-        std::lock_guard lk(page_table_lock);
+        std::lock_guard lock{page_table_lock};
 
-        // Ensure that the heap hasn't changed since we began executing.
-        ASSERT(cur_address == current_heap_end);
+        const u64 delta{size - previous_heap_size};
 
-        // Check the memory state.
-        std::size_t num_allocator_blocks{};
-        R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), current_heap_end,
-                                     allocation_size, KMemoryState::All, KMemoryState::Free,
-                                     KMemoryPermission::None, KMemoryPermission::None,
-                                     KMemoryAttribute::None, KMemoryAttribute::None));
+        // Reserve memory for the heap extension.
+        KScopedResourceReservation memory_reservation(
+            system.Kernel().CurrentProcess()->GetResourceLimit(), LimitableResource::PhysicalMemory,
+            delta);
 
-        // Map the pages.
-        const auto num_pages = allocation_size / PageSize;
-        R_TRY(Operate(current_heap_end, num_pages, page_linked_list, OperationType::MapGroup));
-
-        // Clear all the newly allocated pages.
-        for (std::size_t cur_page = 0; cur_page < num_pages; ++cur_page) {
-            std::memset(system.Memory().GetPointer(current_heap_end + (cur_page * PageSize)), 0,
-                        PageSize);
+        if (!memory_reservation.Succeeded()) {
+            LOG_ERROR(Kernel, "Could not reserve heap extension of size {:X} bytes", delta);
+            return ResultLimitReached;
         }
 
-        // We succeeded, so commit our memory reservation.
+        KPageLinkedList page_linked_list;
+        const std::size_t num_pages{delta / PageSize};
+
+        CASCADE_CODE(
+            system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
+
+        if (IsRegionMapped(current_heap_addr, delta)) {
+            return ResultInvalidCurrentMemory;
+        }
+
+        CASCADE_CODE(
+            Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup));
+
+        // Succeeded in allocation, commit the resource reservation
         memory_reservation.Commit();
 
-        // Apply the memory block update.
-        block_manager->Update(current_heap_end, num_pages, KMemoryState::Normal,
-                              KMemoryPermission::ReadAndWrite, KMemoryAttribute::None);
+        block_manager->Update(current_heap_addr, num_pages, KMemoryState::Normal,
+                              KMemoryPermission::ReadAndWrite);
 
-        // Update the current heap end.
-        current_heap_end = heap_region_start + size;
-
-        // Set the output.
-        *out = heap_region_start;
-        return ResultSuccess;
+        current_heap_addr = heap_region_start + size;
     }
+
+    return heap_region_start;
 }
 
 ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
@@ -1069,7 +1005,7 @@ ResultCode KPageTable::LockForCodeMemory(VAddr addr, std::size_t size) {
 
     if (const ResultCode result{CheckMemoryState(
             nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
-            KMemoryState::FlagCanCodeMemory, KMemoryPermission::All,
+            KMemoryState::FlagCanCodeMemory, KMemoryPermission::Mask,
             KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::None)};
         result.IsError()) {
         return result;
@@ -1122,8 +1058,9 @@ ResultCode KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
 
 bool KPageTable::IsRegionMapped(VAddr address, u64 size) {
     return CheckMemoryState(address, size, KMemoryState::All, KMemoryState::Free,
-                            KMemoryPermission::All, KMemoryPermission::None, KMemoryAttribute::Mask,
-                            KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)
+                            KMemoryPermission::Mask, KMemoryPermission::None,
+                            KMemoryAttribute::Mask, KMemoryAttribute::None,
+                            KMemoryAttribute::IpcAndDeviceMapped)
         .IsError();
 }
 

src/core/hle/kernel/k_page_table.h

@@ -50,8 +50,8 @@ public:
     ResultCode SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm);
     ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
                                   KMemoryAttribute value);
-    ResultCode SetMaxHeapSize(std::size_t size);
-    ResultCode SetHeapSize(VAddr* out, std::size_t size);
+    ResultCode SetHeapCapacity(std::size_t new_heap_capacity);
+    ResultVal<VAddr> SetHeapSize(std::size_t size);
     ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
                                           bool is_map_only, VAddr region_start,
                                           std::size_t region_num_pages, KMemoryState state,
@@ -183,15 +183,14 @@ public:
     constexpr VAddr GetAliasCodeRegionSize() const {
         return alias_code_region_end - alias_code_region_start;
     }
-    size_t GetNormalMemorySize() {
-        std::lock_guard lk(page_table_lock);
-        return GetHeapSize() + mapped_physical_memory_size;
-    }
     constexpr std::size_t GetAddressSpaceWidth() const {
         return address_space_width;
     }
-    constexpr std::size_t GetHeapSize() const {
-        return current_heap_end - heap_region_start;
+    constexpr std::size_t GetHeapSize() {
+        return current_heap_addr - heap_region_start;
+    }
+    constexpr std::size_t GetTotalHeapSize() {
+        return GetHeapSize() + physical_memory_usage;
     }
     constexpr bool IsInsideAddressSpace(VAddr address, std::size_t size) const {
         return address_space_start <= address && address + size - 1 <= address_space_end - 1;
@@ -271,8 +270,10 @@ private:
     VAddr code_region_end{};
     VAddr alias_code_region_start{};
     VAddr alias_code_region_end{};
+    VAddr current_heap_addr{};
 
-    std::size_t mapped_physical_memory_size{};
+    std::size_t heap_capacity{};
+    std::size_t physical_memory_usage{};
     std::size_t max_heap_size{};
     std::size_t max_physical_memory_size{};
     std::size_t address_space_width{};

src/core/hle/kernel/k_process.cpp

@@ -172,7 +172,7 @@ void KProcess::DecrementThreadCount() {
 
 u64 KProcess::GetTotalPhysicalMemoryAvailable() const {
     const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemory) +
-                       page_table->GetNormalMemorySize() + GetSystemResourceSize() + image_size +
+                       page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
                        main_thread_stack_size};
     if (const auto pool_size = kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);
         capacity != pool_size) {
@@ -189,7 +189,7 @@ u64 KProcess::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
 }
 
 u64 KProcess::GetTotalPhysicalMemoryUsed() const {
-    return image_size + main_thread_stack_size + page_table->GetNormalMemorySize() +
+    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize() +
            GetSystemResourceSize();
 }
 
@@ -410,8 +410,8 @@ void KProcess::Run(s32 main_thread_priority, u64 stack_size) {
     resource_limit->Reserve(LimitableResource::Threads, 1);
     resource_limit->Reserve(LimitableResource::PhysicalMemory, main_thread_stack_size);
 
-    const std::size_t heap_capacity{memory_usage_capacity - (main_thread_stack_size + image_size)};
-    ASSERT(!page_table->SetMaxHeapSize(heap_capacity).IsError());
+    const std::size_t heap_capacity{memory_usage_capacity - main_thread_stack_size - image_size};
+    ASSERT(!page_table->SetHeapCapacity(heap_capacity).IsError());
 
     ChangeStatus(ProcessStatus::Running);
 

src/core/hle/kernel/svc.cpp

@@ -135,15 +135,24 @@ enum class ResourceLimitValueType {
 } // Anonymous namespace
 
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
-static ResultCode SetHeapSize(Core::System& system, VAddr* out_address, u64 size) {
-    LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", size);
+static ResultCode SetHeapSize(Core::System& system, VAddr* heap_addr, u64 heap_size) {
+    LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", heap_size);
 
-    // Validate size.
-    R_UNLESS(Common::IsAligned(size, HeapSizeAlignment), ResultInvalidSize);
-    R_UNLESS(size < MainMemorySizeMax, ResultInvalidSize);
+    // Size must be a multiple of 0x200000 (2MB) and be equal to or less than 8GB.
+    if ((heap_size % 0x200000) != 0) {
+        LOG_ERROR(Kernel_SVC, "The heap size is not a multiple of 2MB, heap_size=0x{:016X}",
+                  heap_size);
+        return ResultInvalidSize;
+    }
 
-    // Set the heap size.
-    R_TRY(system.Kernel().CurrentProcess()->PageTable().SetHeapSize(out_address, size));
+    if (heap_size >= 0x200000000) {
+        LOG_ERROR(Kernel_SVC, "The heap size is not less than 8GB, heap_size=0x{:016X}", heap_size);
+        return ResultInvalidSize;
+    }
+
+    auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
+
+    CASCADE_RESULT(*heap_addr, page_table.SetHeapSize(heap_size));
 
     return ResultSuccess;
 }

src/core/hle/kernel/svc_common.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "common/literals.h"
 
 namespace Kernel {
 using Handle = u32;
@@ -13,13 +12,9 @@ using Handle = u32;
 
 namespace Kernel::Svc {
 
-using namespace Common::Literals;
-
 constexpr s32 ArgumentHandleCountMax = 0x40;
 constexpr u32 HandleWaitMask{1u << 30};
 
-constexpr inline std::size_t HeapSizeAlignment = 2_MiB;
-
 constexpr inline Handle InvalidHandle = Handle(0);
 
 enum PseudoHandle : Handle {

src/video_core/memory_manager.cpp

@@ -73,12 +73,12 @@ void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
     }
     const auto submapped_ranges = GetSubmappedRange(gpu_addr, size);
 
-    for (const auto& [map_addr, map_size] : submapped_ranges) {
+    for (const auto& map : submapped_ranges) {
         // Flush and invalidate through the GPU interface, to be asynchronous if possible.
-        const std::optional<VAddr> cpu_addr = GpuToCpuAddress(map_addr);
+        const std::optional<VAddr> cpu_addr = GpuToCpuAddress(map.first);
         ASSERT(cpu_addr);
 
-        rasterizer->UnmapMemory(*cpu_addr, map_size);
+        rasterizer->UnmapMemory(*cpu_addr, map.second);
     }
 
     UpdateRange(gpu_addr, PageEntry::State::Unmapped, size);
@@ -265,8 +265,7 @@ size_t MemoryManager::BytesToMapEnd(GPUVAddr gpu_addr) const noexcept {
     return it->second - (gpu_addr - it->first);
 }
 
-void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
-                                  bool is_safe) const {
+void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const {
     std::size_t remaining_size{size};
     std::size_t page_index{gpu_src_addr >> page_bits};
     std::size_t page_offset{gpu_src_addr & page_mask};
@@ -274,15 +273,35 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
     while (remaining_size > 0) {
         const std::size_t copy_amount{
             std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
-        if (page_addr && *page_addr != 0) {
+
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
+            const auto src_addr{*page_addr + page_offset};
+
+            // Flush must happen on the rasterizer interface, such that memory is always synchronous
+            // when it is read (even when in asynchronous GPU mode). Fixes Dead Cells title menu.
+            rasterizer->FlushRegion(src_addr, copy_amount);
+            system.Memory().ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
+        }
+
+        page_index++;
+        page_offset = 0;
+        dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
+        remaining_size -= copy_amount;
+    }
+}
+
+void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
+                                    const std::size_t size) const {
+    std::size_t remaining_size{size};
+    std::size_t page_index{gpu_src_addr >> page_bits};
+    std::size_t page_offset{gpu_src_addr & page_mask};
+
+    while (remaining_size > 0) {
+        const std::size_t copy_amount{
+            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
+
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
             const auto src_addr{*page_addr + page_offset};
-            if (is_safe) {
-                // Flush must happen on the rasterizer interface, such that memory is always
-                // synchronous when it is read (even when in asynchronous GPU mode).
-                // Fixes Dead Cells title menu.
-                rasterizer->FlushRegion(src_addr, copy_amount);
-            }
             system.Memory().ReadBlockUnsafe(src_addr, dest_buffer, copy_amount);
         } else {
             std::memset(dest_buffer, 0, copy_amount);
@@ -295,17 +314,7 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
     }
 }
 
-void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const {
-    ReadBlockImpl(gpu_src_addr, dest_buffer, size, true);
-}
-
-void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
-                                    const std::size_t size) const {
-    ReadBlockImpl(gpu_src_addr, dest_buffer, size, false);
-}
-
-void MemoryManager::WriteBlockImpl(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size,
-                                   bool is_safe) {
+void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size) {
     std::size_t remaining_size{size};
     std::size_t page_index{gpu_dest_addr >> page_bits};
     std::size_t page_offset{gpu_dest_addr & page_mask};
@@ -313,15 +322,13 @@ void MemoryManager::WriteBlockImpl(GPUVAddr gpu_dest_addr, const void* src_buffe
     while (remaining_size > 0) {
         const std::size_t copy_amount{
             std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
-        const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
-        if (page_addr && *page_addr != 0) {
+
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
             const auto dest_addr{*page_addr + page_offset};
 
-            if (is_safe) {
-                // Invalidate must happen on the rasterizer interface, such that memory is always
-                // synchronous when it is written (even when in asynchronous GPU mode).
-                rasterizer->InvalidateRegion(dest_addr, copy_amount);
-            }
+            // Invalidate must happen on the rasterizer interface, such that memory is always
+            // synchronous when it is written (even when in asynchronous GPU mode).
+            rasterizer->InvalidateRegion(dest_addr, copy_amount);
             system.Memory().WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
         }
 
@@ -332,13 +339,26 @@ void MemoryManager::WriteBlockImpl(GPUVAddr gpu_dest_addr, const void* src_buffe
     }
 }
 
-void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size) {
-    WriteBlockImpl(gpu_dest_addr, src_buffer, size, true);
-}
-
 void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer,
                                      std::size_t size) {
-    WriteBlockImpl(gpu_dest_addr, src_buffer, size, false);
+    std::size_t remaining_size{size};
+    std::size_t page_index{gpu_dest_addr >> page_bits};
+    std::size_t page_offset{gpu_dest_addr & page_mask};
+
+    while (remaining_size > 0) {
+        const std::size_t copy_amount{
+            std::min(static_cast<std::size_t>(page_size) - page_offset, remaining_size)};
+
+        if (const auto page_addr{GpuToCpuAddress(page_index << page_bits)}; page_addr) {
+            const auto dest_addr{*page_addr + page_offset};
+            system.Memory().WriteBlockUnsafe(dest_addr, src_buffer, copy_amount);
+        }
+
+        page_index++;
+        page_offset = 0;
+        src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
+        remaining_size -= copy_amount;
+    }
 }
 
 void MemoryManager::FlushRegion(GPUVAddr gpu_addr, size_t size) const {
@@ -415,15 +435,15 @@ std::vector<std::pair<GPUVAddr, std::size_t>> MemoryManager::GetSubmappedRange(
     size_t page_offset{gpu_addr & page_mask};
     std::optional<std::pair<GPUVAddr, std::size_t>> last_segment{};
     std::optional<VAddr> old_page_addr{};
-    const auto extend_size = [&last_segment, &page_index, &page_offset](std::size_t bytes) {
+    const auto extend_size = [this, &last_segment, &page_index](std::size_t bytes) {
         if (!last_segment) {
-            const GPUVAddr new_base_addr = (page_index << page_bits) + page_offset;
+            GPUVAddr new_base_addr = page_index << page_bits;
             last_segment = {new_base_addr, bytes};
         } else {
             last_segment->second += bytes;
         }
     };
-    const auto split = [&last_segment, &result] {
+    const auto split = [this, &last_segment, &result] {
         if (last_segment) {
             result.push_back(*last_segment);
             last_segment = std::nullopt;
@@ -432,7 +452,7 @@ std::vector<std::pair<GPUVAddr, std::size_t>> MemoryManager::GetSubmappedRange(
     while (remaining_size > 0) {
         const size_t num_bytes{std::min(page_size - page_offset, remaining_size)};
         const auto page_addr{GpuToCpuAddress(page_index << page_bits)};
-        if (!page_addr || *page_addr == 0) {
+        if (!page_addr) {
             split();
         } else if (old_page_addr) {
             if (*old_page_addr + page_size != *page_addr) {

src/video_core/memory_manager.h

@@ -155,11 +155,6 @@ private:
 
     void FlushRegion(GPUVAddr gpu_addr, size_t size) const;
 
-    void ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
-                       bool is_safe) const;
-    void WriteBlockImpl(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size,
-                        bool is_safe);
-
     [[nodiscard]] static constexpr std::size_t PageEntryIndex(GPUVAddr gpu_addr) {
         return (gpu_addr >> page_bits) & page_table_mask;
     }

src/video_core/texture_cache/texture_cache.h

@@ -1376,7 +1376,9 @@ void TextureCache<P>::ForEachSparseSegment(ImageBase& image, Func&& func) {
     using FuncReturn = typename std::invoke_result<Func, GPUVAddr, VAddr, size_t>::type;
     static constexpr bool RETURNS_BOOL = std::is_same_v<FuncReturn, bool>;
     const auto segments = gpu_memory.GetSubmappedRange(image.gpu_addr, image.guest_size_bytes);
-    for (const auto& [gpu_addr, size] : segments) {
+    for (auto& segment : segments) {
+        const auto gpu_addr = segment.first;
+        const auto size = segment.second;
         std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
         ASSERT(cpu_addr);
         if constexpr (RETURNS_BOOL) {

src/yuzu/applets/qt_controller.cpp

@@ -33,7 +33,7 @@ void UpdateController(Core::HID::EmulatedController* controller,
     }
     controller->SetNpadStyleIndex(controller_type);
     if (connected) {
-        controller->Connect(true);
+        controller->Connect();
     }
 }
 

src/yuzu/configuration/configure_input_player.cpp

@@ -599,11 +599,11 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
                     if (is_connected) {
                         if (type == Core::HID::NpadStyleIndex::Handheld) {
                             emulated_controller_p1->Disconnect();
-                            emulated_controller_handheld->Connect(true);
+                            emulated_controller_handheld->Connect();
                             emulated_controller = emulated_controller_handheld;
                         } else {
                             emulated_controller_handheld->Disconnect();
-                            emulated_controller_p1->Connect(true);
+                            emulated_controller_p1->Connect();
                             emulated_controller = emulated_controller_p1;
                         }
                     }
@@ -718,7 +718,7 @@ void ConfigureInputPlayer::LoadConfiguration() {
 void ConfigureInputPlayer::ConnectPlayer(bool connected) {
     ui->groupConnectedController->setChecked(connected);
     if (connected) {
-        emulated_controller->Connect(true);
+        emulated_controller->Connect();
     } else {
         emulated_controller->Disconnect();
     }