texture_pass: Refactor texture handle retrieval

glasm, glsl: Implement multisampled Image Fetch

src/common/polyfill_thread.h

@@ -11,6 +11,8 @@
 
 #ifdef __cpp_lib_jthread
 
+#include <chrono>
+#include <condition_variable>
 #include <stop_token>
 #include <thread>
 
@@ -21,11 +23,23 @@ void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred&& pred) {
     cv.wait(lock, token, std::move(pred));
 }
 
+template <typename Rep, typename Period>
+bool StoppableTimedWait(std::stop_token token, const std::chrono::duration<Rep, Period>& rel_time) {
+    std::condition_variable_any cv;
+    std::mutex m;
+
+    // Perform the timed wait.
+    std::unique_lock lk{m};
+    return !cv.wait_for(lk, token, rel_time, [&] { return token.stop_requested(); });
+}
+
 } // namespace Common
 
 #else
 
 #include <atomic>
+#include <chrono>
+#include <condition_variable>
 #include <functional>
 #include <list>
 #include <memory>
@@ -318,6 +332,28 @@ void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred pred) {
     cv.wait(lock, [&] { return pred() || token.stop_requested(); });
 }
 
+template <typename Rep, typename Period>
+bool StoppableTimedWait(std::stop_token token, const std::chrono::duration<Rep, Period>& rel_time) {
+    if (token.stop_requested()) {
+        return false;
+    }
+
+    bool stop_requested = false;
+    std::condition_variable cv;
+    std::mutex m;
+
+    std::stop_callback cb(token, [&] {
+        // Wake up the waiting thread.
+        std::unique_lock lk{m};
+        stop_requested = true;
+        cv.notify_one();
+    });
+
+    // Perform the timed wait.
+    std::unique_lock lk{m};
+    return !cv.wait_for(lk, rel_time, [&] { return stop_requested; });
+}
+
 } // namespace Common
 
 #endif

src/core/hle/kernel/k_code_memory.cpp

@@ -74,7 +74,7 @@ Result KCodeMemory::Map(VAddr address, size_t size) {
     R_UNLESS(!m_is_mapped, ResultInvalidState);
 
     // Map the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().MapPages(
+    R_TRY(kernel.CurrentProcess()->PageTable().MapPageGroup(
         address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
 
     // Mark ourselves as mapped.
@@ -91,8 +91,8 @@ Result KCodeMemory::Unmap(VAddr address, size_t size) {
     KScopedLightLock lk(m_lock);
 
     // Unmap the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, *m_page_group,
-                                                          KMemoryState::CodeOut));
+    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPageGroup(address, *m_page_group,
+                                                              KMemoryState::CodeOut));
 
     // Mark ourselves as unmapped.
     m_is_mapped = false;
@@ -125,8 +125,8 @@ Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission
     }
 
     // Map the memory.
-    R_TRY(
-        m_owner->PageTable().MapPages(address, *m_page_group, KMemoryState::GeneratedCode, k_perm));
+    R_TRY(m_owner->PageTable().MapPageGroup(address, *m_page_group, KMemoryState::GeneratedCode,
+                                            k_perm));
 
     // Mark ourselves as mapped.
     m_is_owner_mapped = true;
@@ -142,7 +142,7 @@ Result KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
     KScopedLightLock lk(m_lock);
 
     // Unmap the memory.
-    R_TRY(m_owner->PageTable().UnmapPages(address, *m_page_group, KMemoryState::GeneratedCode));
+    R_TRY(m_owner->PageTable().UnmapPageGroup(address, *m_page_group, KMemoryState::GeneratedCode));
 
     // Mark ourselves as unmapped.
     m_is_owner_mapped = false;

src/core/hle/kernel/k_condition_variable.cpp

@@ -171,7 +171,7 @@ Result KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value)
         R_UNLESS(owner_thread != nullptr, ResultInvalidHandle);
 
         // Update the lock.
-        cur_thread->SetAddressKey(addr, value);
+        cur_thread->SetUserAddressKey(addr, value);
         owner_thread->AddWaiter(cur_thread);
 
         // Begin waiting.

src/core/hle/kernel/k_light_lock.cpp

@@ -68,7 +68,7 @@ bool KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
 
         // Add the current thread as a waiter on the owner.
         KThread* owner_thread = reinterpret_cast<KThread*>(_owner & ~1ULL);
-        cur_thread->SetAddressKey(reinterpret_cast<uintptr_t>(std::addressof(tag)));
+        cur_thread->SetKernelAddressKey(reinterpret_cast<uintptr_t>(std::addressof(tag)));
         owner_thread->AddWaiter(cur_thread);
 
         // Begin waiting to hold the lock.

src/core/hle/kernel/k_memory_layout.h

@@ -67,9 +67,9 @@ constexpr size_t KernelPageBufferAdditionalSize = 0x33C000;
 constexpr std::size_t KernelResourceSize = KernelPageTableHeapSize + KernelInitialPageHeapSize +
                                            KernelSlabHeapSize + KernelPageBufferHeapSize;
 
-constexpr bool IsKernelAddressKey(VAddr key) {
-    return KernelVirtualAddressSpaceBase <= key && key <= KernelVirtualAddressSpaceLast;
-}
+//! NB: Use KThread::GetAddressKeyIsKernel().
+//! See explanation for deviation of GetAddressKey.
+bool IsKernelAddressKey(VAddr key) = delete;
 
 constexpr bool IsKernelAddress(VAddr address) {
     return KernelVirtualAddressSpaceBase <= address && address < KernelVirtualAddressSpaceEnd;

src/core/hle/kernel/k_page_table.cpp

@@ -435,6 +435,9 @@ Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, size_t si
         KPageGroup pg{m_kernel, m_block_info_manager};
         AddRegionToPages(src_address, num_pages, pg);
 
+        // We're going to perform an update, so create a helper.
+        KScopedPageTableUpdater updater(this);
+
         // Reprotect the source as kernel-read/not mapped.
         const auto new_perm = static_cast<KMemoryPermission>(KMemoryPermission::KernelRead |
                                                              KMemoryPermission::NotMapped);
@@ -447,7 +450,10 @@ Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, size_t si
         });
 
         // Map the alias pages.
-        R_TRY(MapPages(dst_address, pg, new_perm));
+        const KPageProperties dst_properties = {new_perm, false, false,
+                                                DisableMergeAttribute::DisableHead};
+        R_TRY(
+            this->MapPageGroupImpl(updater.GetPageList(), dst_address, pg, dst_properties, false));
 
         // We successfully mapped the alias pages, so we don't need to unprotect the src pages on
         // failure.
@@ -1881,7 +1887,8 @@ Result KPageTable::UnmapPhysicalMemory(VAddr address, size_t size) {
     R_SUCCEED();
 }
 
-Result KPageTable::MapMemory(VAddr dst_address, VAddr src_address, size_t size) {
+Result KPageTable::MapMemory(KProcessAddress dst_address, KProcessAddress src_address,
+                             size_t size) {
     // Lock the table.
     KScopedLightLock lk(m_general_lock);
 
@@ -1902,53 +1909,73 @@ Result KPageTable::MapMemory(VAddr dst_address, VAddr src_address, size_t size)
                                  KMemoryAttribute::None));
 
     // Create an update allocator for the source.
-    Result src_allocator_result{ResultSuccess};
+    Result src_allocator_result;
     KMemoryBlockManagerUpdateAllocator src_allocator(std::addressof(src_allocator_result),
                                                      m_memory_block_slab_manager,
                                                      num_src_allocator_blocks);
     R_TRY(src_allocator_result);
 
     // Create an update allocator for the destination.
-    Result dst_allocator_result{ResultSuccess};
+    Result dst_allocator_result;
     KMemoryBlockManagerUpdateAllocator dst_allocator(std::addressof(dst_allocator_result),
                                                      m_memory_block_slab_manager,
                                                      num_dst_allocator_blocks);
     R_TRY(dst_allocator_result);
 
     // Map the memory.
-    KPageGroup page_linked_list{m_kernel, m_block_info_manager};
-    const size_t num_pages{size / PageSize};
-    const KMemoryPermission new_src_perm = static_cast<KMemoryPermission>(
-        KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
-    const KMemoryAttribute new_src_attr = KMemoryAttribute::Locked;
-
-    AddRegionToPages(src_address, num_pages, page_linked_list);
     {
+        // Determine the number of pages being operated on.
+        const size_t num_pages = size / PageSize;
+
+        // Create page groups for the memory being unmapped.
+        KPageGroup pg{m_kernel, m_block_info_manager};
+
+        // Create the page group representing the source.
+        R_TRY(this->MakePageGroup(pg, src_address, num_pages));
+
+        // We're going to perform an update, so create a helper.
+        KScopedPageTableUpdater updater(this);
+
         // Reprotect the source as kernel-read/not mapped.
-        auto block_guard = detail::ScopeExit([&] {
-            Operate(src_address, num_pages, KMemoryPermission::UserReadWrite,
-                    OperationType::ChangePermissions);
-        });
-        R_TRY(Operate(src_address, num_pages, new_src_perm, OperationType::ChangePermissions));
-        R_TRY(MapPages(dst_address, page_linked_list, KMemoryPermission::UserReadWrite));
+        const KMemoryPermission new_src_perm = static_cast<KMemoryPermission>(
+            KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
+        const KMemoryAttribute new_src_attr = KMemoryAttribute::Locked;
+        const KPageProperties src_properties = {new_src_perm, false, false,
+                                                DisableMergeAttribute::DisableHeadBodyTail};
+        R_TRY(this->Operate(src_address, num_pages, src_properties.perm,
+                            OperationType::ChangePermissions));
 
-        block_guard.Cancel();
+        // Ensure that we unprotect the source pages on failure.
+        ON_RESULT_FAILURE {
+            const KPageProperties unprotect_properties = {
+                KMemoryPermission::UserReadWrite, false, false,
+                DisableMergeAttribute::EnableHeadBodyTail};
+            ASSERT(this->Operate(src_address, num_pages, unprotect_properties.perm,
+                                 OperationType::ChangePermissions) == ResultSuccess);
+        };
+
+        // Map the alias pages.
+        const KPageProperties dst_map_properties = {KMemoryPermission::UserReadWrite, false, false,
+                                                    DisableMergeAttribute::DisableHead};
+        R_TRY(this->MapPageGroupImpl(updater.GetPageList(), dst_address, pg, dst_map_properties,
+                                     false));
+
+        // Apply the memory block updates.
+        m_memory_block_manager.Update(std::addressof(src_allocator), src_address, num_pages,
+                                      src_state, new_src_perm, new_src_attr,
+                                      KMemoryBlockDisableMergeAttribute::Locked,
+                                      KMemoryBlockDisableMergeAttribute::None);
+        m_memory_block_manager.Update(
+            std::addressof(dst_allocator), dst_address, num_pages, KMemoryState::Stack,
+            KMemoryPermission::UserReadWrite, KMemoryAttribute::None,
+            KMemoryBlockDisableMergeAttribute::Normal, KMemoryBlockDisableMergeAttribute::None);
     }
 
-    // Apply the memory block updates.
-    m_memory_block_manager.Update(std::addressof(src_allocator), src_address, num_pages, src_state,
-                                  new_src_perm, new_src_attr,
-                                  KMemoryBlockDisableMergeAttribute::Locked,
-                                  KMemoryBlockDisableMergeAttribute::None);
-    m_memory_block_manager.Update(std::addressof(dst_allocator), dst_address, num_pages,
-                                  KMemoryState::Stack, KMemoryPermission::UserReadWrite,
-                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
-                                  KMemoryBlockDisableMergeAttribute::None);
-
     R_SUCCEED();
 }
 
-Result KPageTable::UnmapMemory(VAddr dst_address, VAddr src_address, size_t size) {
+Result KPageTable::UnmapMemory(KProcessAddress dst_address, KProcessAddress src_address,
+                               size_t size) {
     // Lock the table.
     KScopedLightLock lk(m_general_lock);
 
@@ -1970,108 +1997,208 @@ Result KPageTable::UnmapMemory(VAddr dst_address, VAddr src_address, size_t size
         KMemoryPermission::None, KMemoryAttribute::All, KMemoryAttribute::None));
 
     // Create an update allocator for the source.
-    Result src_allocator_result{ResultSuccess};
+    Result src_allocator_result;
     KMemoryBlockManagerUpdateAllocator src_allocator(std::addressof(src_allocator_result),
                                                      m_memory_block_slab_manager,
                                                      num_src_allocator_blocks);
     R_TRY(src_allocator_result);
 
     // Create an update allocator for the destination.
-    Result dst_allocator_result{ResultSuccess};
+    Result dst_allocator_result;
     KMemoryBlockManagerUpdateAllocator dst_allocator(std::addressof(dst_allocator_result),
                                                      m_memory_block_slab_manager,
                                                      num_dst_allocator_blocks);
     R_TRY(dst_allocator_result);
 
-    KPageGroup src_pages{m_kernel, m_block_info_manager};
-    KPageGroup dst_pages{m_kernel, m_block_info_manager};
-    const size_t num_pages{size / PageSize};
-
-    AddRegionToPages(src_address, num_pages, src_pages);
-    AddRegionToPages(dst_address, num_pages, dst_pages);
-
-    R_UNLESS(dst_pages.IsEquivalentTo(src_pages), ResultInvalidMemoryRegion);
-
+    // Unmap the memory.
     {
-        auto block_guard = detail::ScopeExit([&] { MapPages(dst_address, dst_pages, dst_perm); });
+        // Determine the number of pages being operated on.
+        const size_t num_pages = size / PageSize;
 
-        R_TRY(Operate(dst_address, num_pages, KMemoryPermission::None, OperationType::Unmap));
-        R_TRY(Operate(src_address, num_pages, KMemoryPermission::UserReadWrite,
-                      OperationType::ChangePermissions));
+        // Create page groups for the memory being unmapped.
+        KPageGroup pg{m_kernel, m_block_info_manager};
 
-        block_guard.Cancel();
+        // Create the page group representing the destination.
+        R_TRY(this->MakePageGroup(pg, dst_address, num_pages));
+
+        // Ensure the page group is the valid for the source.
+        R_UNLESS(this->IsValidPageGroup(pg, src_address, num_pages), ResultInvalidMemoryRegion);
+
+        // We're going to perform an update, so create a helper.
+        KScopedPageTableUpdater updater(this);
+
+        // Unmap the aliased copy of the pages.
+        const KPageProperties dst_unmap_properties = {KMemoryPermission::None, false, false,
+                                                      DisableMergeAttribute::None};
+        R_TRY(
+            this->Operate(dst_address, num_pages, dst_unmap_properties.perm, OperationType::Unmap));
+
+        // Ensure that we re-map the aliased pages on failure.
+        ON_RESULT_FAILURE {
+            this->RemapPageGroup(updater.GetPageList(), dst_address, size, pg);
+        };
+
+        // Try to set the permissions for the source pages back to what they should be.
+        const KPageProperties src_properties = {KMemoryPermission::UserReadWrite, false, false,
+                                                DisableMergeAttribute::EnableAndMergeHeadBodyTail};
+        R_TRY(this->Operate(src_address, num_pages, src_properties.perm,
+                            OperationType::ChangePermissions));
+
+        // Apply the memory block updates.
+        m_memory_block_manager.Update(
+            std::addressof(src_allocator), src_address, num_pages, src_state,
+            KMemoryPermission::UserReadWrite, KMemoryAttribute::None,
+            KMemoryBlockDisableMergeAttribute::None, KMemoryBlockDisableMergeAttribute::Locked);
+        m_memory_block_manager.Update(
+            std::addressof(dst_allocator), dst_address, num_pages, KMemoryState::None,
+            KMemoryPermission::None, KMemoryAttribute::None,
+            KMemoryBlockDisableMergeAttribute::None, KMemoryBlockDisableMergeAttribute::Normal);
     }
 
-    // Apply the memory block updates.
-    m_memory_block_manager.Update(std::addressof(src_allocator), src_address, num_pages, src_state,
-                                  KMemoryPermission::UserReadWrite, KMemoryAttribute::None,
-                                  KMemoryBlockDisableMergeAttribute::None,
-                                  KMemoryBlockDisableMergeAttribute::Locked);
-    m_memory_block_manager.Update(std::addressof(dst_allocator), dst_address, num_pages,
-                                  KMemoryState::None, KMemoryPermission::None,
-                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::None,
-                                  KMemoryBlockDisableMergeAttribute::Normal);
-
     R_SUCCEED();
 }
 
-Result KPageTable::MapPages(VAddr addr, const KPageGroup& page_linked_list,
-                            KMemoryPermission perm) {
+Result KPageTable::AllocateAndMapPagesImpl(PageLinkedList* page_list, KProcessAddress address,
+                                           size_t num_pages, KMemoryPermission perm) {
     ASSERT(this->IsLockedByCurrentThread());
 
-    VAddr cur_addr{addr};
+    // Create a page group to hold the pages we allocate.
+    KPageGroup pg{m_kernel, m_block_info_manager};
 
-    for (const auto& node : page_linked_list) {
-        if (const auto result{
-                Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
-            result.IsError()) {
-            const size_t num_pages{(addr - cur_addr) / PageSize};
+    // Allocate the pages.
+    R_TRY(
+        m_kernel.MemoryManager().AllocateAndOpen(std::addressof(pg), num_pages, m_allocate_option));
 
-            ASSERT(Operate(addr, num_pages, KMemoryPermission::None, OperationType::Unmap)
-                       .IsSuccess());
+    // Ensure that the page group is closed when we're done working with it.
+    SCOPE_EXIT({ pg.Close(); });
 
-            R_RETURN(result);
-        }
-
-        cur_addr += node.GetNumPages() * PageSize;
+    // Clear all pages.
+    for (const auto& it : pg) {
+        std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()), m_heap_fill_value,
+                    it.GetSize());
     }
 
-    R_SUCCEED();
-}
-
-Result KPageTable::MapPages(VAddr address, KPageGroup& page_linked_list, KMemoryState state,
-                            KMemoryPermission perm) {
-    // Check that the map is in range.
-    const size_t num_pages{page_linked_list.GetNumPages()};
-    const size_t size{num_pages * PageSize};
-    R_UNLESS(this->CanContain(address, size, state), ResultInvalidCurrentMemory);
-
-    // Lock the table.
-    KScopedLightLock lk(m_general_lock);
-
-    // Check the memory state.
-    R_TRY(this->CheckMemoryState(address, size, KMemoryState::All, KMemoryState::Free,
-                                 KMemoryPermission::None, KMemoryPermission::None,
-                                 KMemoryAttribute::None, KMemoryAttribute::None));
-
-    // Create an update allocator.
-    Result allocator_result{ResultSuccess};
-    KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
-                                                 m_memory_block_slab_manager);
-
     // Map the pages.
-    R_TRY(MapPages(address, page_linked_list, perm));
+    R_RETURN(this->Operate(address, num_pages, pg, OperationType::MapGroup));
+}
 
-    // Update the blocks.
-    m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, state, perm,
-                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
-                                  KMemoryBlockDisableMergeAttribute::None);
+Result KPageTable::MapPageGroupImpl(PageLinkedList* page_list, KProcessAddress address,
+                                    const KPageGroup& pg, const KPageProperties properties,
+                                    bool reuse_ll) {
+    ASSERT(this->IsLockedByCurrentThread());
 
+    // Note the current address, so that we can iterate.
+    const KProcessAddress start_address = address;
+    KProcessAddress cur_address = address;
+
+    // Ensure that we clean up on failure.
+    ON_RESULT_FAILURE {
+        ASSERT(!reuse_ll);
+        if (cur_address != start_address) {
+            const KPageProperties unmap_properties = {KMemoryPermission::None, false, false,
+                                                      DisableMergeAttribute::None};
+            ASSERT(this->Operate(start_address, (cur_address - start_address) / PageSize,
+                                 unmap_properties.perm, OperationType::Unmap) == ResultSuccess);
+        }
+    };
+
+    // Iterate, mapping all pages in the group.
+    for (const auto& block : pg) {
+        // Map and advance.
+        const KPageProperties cur_properties =
+            (cur_address == start_address)
+                ? properties
+                : KPageProperties{properties.perm, properties.io, properties.uncached,
+                                  DisableMergeAttribute::None};
+        this->Operate(cur_address, block.GetNumPages(), cur_properties.perm, OperationType::Map,
+                      block.GetAddress());
+        cur_address += block.GetSize();
+    }
+
+    // We succeeded!
     R_SUCCEED();
 }
 
-Result KPageTable::MapPages(VAddr* out_addr, size_t num_pages, size_t alignment, PAddr phys_addr,
-                            bool is_pa_valid, VAddr region_start, size_t region_num_pages,
+void KPageTable::RemapPageGroup(PageLinkedList* page_list, KProcessAddress address, size_t size,
+                                const KPageGroup& pg) {
+    ASSERT(this->IsLockedByCurrentThread());
+
+    // Note the current address, so that we can iterate.
+    const KProcessAddress start_address = address;
+    const KProcessAddress last_address = start_address + size - 1;
+    const KProcessAddress end_address = last_address + 1;
+
+    // Iterate over the memory.
+    auto pg_it = pg.begin();
+    ASSERT(pg_it != pg.end());
+
+    KPhysicalAddress pg_phys_addr = pg_it->GetAddress();
+    size_t pg_pages = pg_it->GetNumPages();
+
+    auto it = m_memory_block_manager.FindIterator(start_address);
+    while (true) {
+        // Check that the iterator is valid.
+        ASSERT(it != m_memory_block_manager.end());
+
+        // Get the memory info.
+        const KMemoryInfo info = it->GetMemoryInfo();
+
+        // Determine the range to map.
+        KProcessAddress map_address = std::max<VAddr>(info.GetAddress(), start_address);
+        const KProcessAddress map_end_address = std::min<VAddr>(info.GetEndAddress(), end_address);
+        ASSERT(map_end_address != map_address);
+
+        // Determine if we should disable head merge.
+        const bool disable_head_merge =
+            info.GetAddress() >= start_address &&
+            True(info.GetDisableMergeAttribute() & KMemoryBlockDisableMergeAttribute::Normal);
+        const KPageProperties map_properties = {
+            info.GetPermission(), false, false,
+            disable_head_merge ? DisableMergeAttribute::DisableHead : DisableMergeAttribute::None};
+
+        // While we have pages to map, map them.
+        size_t map_pages = (map_end_address - map_address) / PageSize;
+        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());
+
+                // Advance our physical block.
+                ++pg_it;
+                pg_phys_addr = pg_it->GetAddress();
+                pg_pages = pg_it->GetNumPages();
+            }
+
+            // Map whatever we can.
+            const size_t cur_pages = std::min(pg_pages, map_pages);
+            ASSERT(this->Operate(map_address, map_pages, map_properties.perm, OperationType::Map,
+                                 pg_phys_addr) == ResultSuccess);
+
+            // Advance.
+            map_address += cur_pages * PageSize;
+            map_pages -= cur_pages;
+
+            pg_phys_addr += cur_pages * PageSize;
+            pg_pages -= cur_pages;
+        }
+
+        // Check if we're done.
+        if (last_address <= info.GetLastAddress()) {
+            break;
+        }
+
+        // Advance.
+        ++it;
+    }
+
+    // Check that we re-mapped precisely the page group.
+    ASSERT((++pg_it) == pg.end());
+}
+
+Result KPageTable::MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                            KPhysicalAddress phys_addr, bool is_pa_valid,
+                            KProcessAddress region_start, size_t region_num_pages,
                             KMemoryState state, KMemoryPermission perm) {
     ASSERT(Common::IsAligned(alignment, PageSize) && alignment >= PageSize);
 
@@ -2084,26 +2211,30 @@ Result KPageTable::MapPages(VAddr* out_addr, size_t num_pages, size_t alignment,
     KScopedLightLock lk(m_general_lock);
 
     // Find a random address to map at.
-    VAddr addr = this->FindFreeArea(region_start, region_num_pages, num_pages, alignment, 0,
-                                    this->GetNumGuardPages());
+    KProcessAddress addr = this->FindFreeArea(region_start, region_num_pages, num_pages, alignment,
+                                              0, this->GetNumGuardPages());
     R_UNLESS(addr != 0, ResultOutOfMemory);
     ASSERT(Common::IsAligned(addr, alignment));
     ASSERT(this->CanContain(addr, num_pages * PageSize, state));
     ASSERT(this->CheckMemoryState(addr, num_pages * PageSize, KMemoryState::All, KMemoryState::Free,
                                   KMemoryPermission::None, KMemoryPermission::None,
-                                  KMemoryAttribute::None, KMemoryAttribute::None)
-               .IsSuccess());
+                                  KMemoryAttribute::None, KMemoryAttribute::None) == ResultSuccess);
 
     // Create an update allocator.
-    Result allocator_result{ResultSuccess};
+    Result allocator_result;
     KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
                                                  m_memory_block_slab_manager);
+    R_TRY(allocator_result);
+
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
 
     // Perform mapping operation.
     if (is_pa_valid) {
-        R_TRY(this->Operate(addr, num_pages, perm, OperationType::Map, phys_addr));
+        const KPageProperties properties = {perm, false, false, DisableMergeAttribute::DisableHead};
+        R_TRY(this->Operate(addr, num_pages, properties.perm, OperationType::Map, phys_addr));
     } else {
-        UNIMPLEMENTED();
+        R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), addr, num_pages, perm));
     }
 
     // Update the blocks.
@@ -2116,28 +2247,45 @@ Result KPageTable::MapPages(VAddr* out_addr, size_t num_pages, size_t alignment,
     R_SUCCEED();
 }
 
-Result KPageTable::UnmapPages(VAddr addr, const KPageGroup& page_linked_list) {
-    ASSERT(this->IsLockedByCurrentThread());
+Result KPageTable::MapPages(KProcessAddress address, size_t num_pages, KMemoryState state,
+                            KMemoryPermission perm) {
+    // Check that the map is in range.
+    const size_t size = num_pages * PageSize;
+    R_UNLESS(this->CanContain(address, size, state), ResultInvalidCurrentMemory);
 
-    VAddr cur_addr{addr};
+    // Lock the table.
+    KScopedLightLock lk(m_general_lock);
 
-    for (const auto& node : page_linked_list) {
-        if (const auto result{Operate(cur_addr, node.GetNumPages(), KMemoryPermission::None,
-                                      OperationType::Unmap)};
-            result.IsError()) {
-            R_RETURN(result);
-        }
+    // Check the memory state.
+    size_t num_allocator_blocks;
+    R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), address, size,
+                                 KMemoryState::All, KMemoryState::Free, KMemoryPermission::None,
+                                 KMemoryPermission::None, KMemoryAttribute::None,
+                                 KMemoryAttribute::None));
 
-        cur_addr += node.GetNumPages() * PageSize;
-    }
+    // Create an update allocator.
+    Result allocator_result;
+    KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
+                                                 m_memory_block_slab_manager, num_allocator_blocks);
+    R_TRY(allocator_result);
+
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
+
+    // Map the pages.
+    R_TRY(this->AllocateAndMapPagesImpl(updater.GetPageList(), address, num_pages, perm));
+
+    // Update the blocks.
+    m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, state, perm,
+                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
+                                  KMemoryBlockDisableMergeAttribute::None);
 
     R_SUCCEED();
 }
 
-Result KPageTable::UnmapPages(VAddr address, KPageGroup& page_linked_list, KMemoryState state) {
+Result KPageTable::UnmapPages(KProcessAddress address, size_t num_pages, KMemoryState state) {
     // Check that the unmap is in range.
-    const size_t num_pages{page_linked_list.GetNumPages()};
-    const size_t size{num_pages * PageSize};
+    const size_t size = num_pages * PageSize;
     R_UNLESS(this->Contains(address, size), ResultInvalidCurrentMemory);
 
     // Lock the table.
@@ -2151,13 +2299,18 @@ Result KPageTable::UnmapPages(VAddr address, KPageGroup& page_linked_list, KMemo
                                  KMemoryAttribute::None));
 
     // Create an update allocator.
-    Result allocator_result{ResultSuccess};
+    Result allocator_result;
     KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
                                                  m_memory_block_slab_manager, num_allocator_blocks);
     R_TRY(allocator_result);
 
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
+
     // Perform the unmap.
-    R_TRY(UnmapPages(address, page_linked_list));
+    const KPageProperties unmap_properties = {KMemoryPermission::None, false, false,
+                                              DisableMergeAttribute::None};
+    R_TRY(this->Operate(address, num_pages, unmap_properties.perm, OperationType::Unmap));
 
     // Update the blocks.
     m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, KMemoryState::Free,
@@ -2168,29 +2321,130 @@ Result KPageTable::UnmapPages(VAddr address, KPageGroup& page_linked_list, KMemo
     R_SUCCEED();
 }
 
-Result KPageTable::UnmapPages(VAddr address, size_t num_pages, KMemoryState state) {
-    // Check that the unmap is in range.
-    const size_t size = num_pages * PageSize;
-    R_UNLESS(this->Contains(address, size), ResultInvalidCurrentMemory);
+Result KPageTable::MapPageGroup(KProcessAddress* out_addr, const KPageGroup& pg,
+                                KProcessAddress region_start, size_t region_num_pages,
+                                KMemoryState state, KMemoryPermission perm) {
+    ASSERT(!this->IsLockedByCurrentThread());
+
+    // Ensure this is a valid map request.
+    const size_t num_pages = pg.GetNumPages();
+    R_UNLESS(this->CanContain(region_start, region_num_pages * PageSize, state),
+             ResultInvalidCurrentMemory);
+    R_UNLESS(num_pages < region_num_pages, ResultOutOfMemory);
 
     // Lock the table.
     KScopedLightLock lk(m_general_lock);
 
-    // Check the memory state.
-    size_t num_allocator_blocks{};
+    // Find a random address to map at.
+    KProcessAddress addr = this->FindFreeArea(region_start, region_num_pages, num_pages, PageSize,
+                                              0, this->GetNumGuardPages());
+    R_UNLESS(addr != 0, ResultOutOfMemory);
+    ASSERT(this->CanContain(addr, num_pages * PageSize, state));
+    ASSERT(this->CheckMemoryState(addr, num_pages * PageSize, KMemoryState::All, KMemoryState::Free,
+                                  KMemoryPermission::None, KMemoryPermission::None,
+                                  KMemoryAttribute::None, KMemoryAttribute::None) == ResultSuccess);
+
+    // Create an update allocator.
+    Result allocator_result;
+    KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
+                                                 m_memory_block_slab_manager);
+    R_TRY(allocator_result);
+
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
+
+    // Perform mapping operation.
+    const KPageProperties properties = {perm, state == KMemoryState::Io, false,
+                                        DisableMergeAttribute::DisableHead};
+    R_TRY(this->MapPageGroupImpl(updater.GetPageList(), addr, pg, properties, false));
+
+    // Update the blocks.
+    m_memory_block_manager.Update(std::addressof(allocator), addr, num_pages, state, perm,
+                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
+                                  KMemoryBlockDisableMergeAttribute::None);
+
+    // We successfully mapped the pages.
+    *out_addr = addr;
+    R_SUCCEED();
+}
+
+Result KPageTable::MapPageGroup(KProcessAddress addr, const KPageGroup& pg, KMemoryState state,
+                                KMemoryPermission perm) {
+    ASSERT(!this->IsLockedByCurrentThread());
+
+    // Ensure this is a valid map request.
+    const size_t num_pages = pg.GetNumPages();
+    const size_t size = num_pages * PageSize;
+    R_UNLESS(this->CanContain(addr, size, state), ResultInvalidCurrentMemory);
+
+    // Lock the table.
+    KScopedLightLock lk(m_general_lock);
+
+    // Check if state allows us to map.
+    size_t num_allocator_blocks;
+    R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), addr, size,
+                                 KMemoryState::All, KMemoryState::Free, KMemoryPermission::None,
+                                 KMemoryPermission::None, KMemoryAttribute::None,
+                                 KMemoryAttribute::None));
+
+    // Create an update allocator.
+    Result allocator_result;
+    KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
+                                                 m_memory_block_slab_manager, num_allocator_blocks);
+    R_TRY(allocator_result);
+
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
+
+    // Perform mapping operation.
+    const KPageProperties properties = {perm, state == KMemoryState::Io, false,
+                                        DisableMergeAttribute::DisableHead};
+    R_TRY(this->MapPageGroupImpl(updater.GetPageList(), addr, pg, properties, false));
+
+    // Update the blocks.
+    m_memory_block_manager.Update(std::addressof(allocator), addr, num_pages, state, perm,
+                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
+                                  KMemoryBlockDisableMergeAttribute::None);
+
+    // We successfully mapped the pages.
+    R_SUCCEED();
+}
+
+Result KPageTable::UnmapPageGroup(KProcessAddress address, const KPageGroup& pg,
+                                  KMemoryState state) {
+    ASSERT(!this->IsLockedByCurrentThread());
+
+    // Ensure this is a valid unmap request.
+    const size_t num_pages = pg.GetNumPages();
+    const size_t size = num_pages * PageSize;
+    R_UNLESS(this->CanContain(address, size, state), ResultInvalidCurrentMemory);
+
+    // Lock the table.
+    KScopedLightLock lk(m_general_lock);
+
+    // Check if state allows us to unmap.
+    size_t num_allocator_blocks;
     R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), address, size,
                                  KMemoryState::All, state, KMemoryPermission::None,
                                  KMemoryPermission::None, KMemoryAttribute::All,
                                  KMemoryAttribute::None));
 
+    // Check that the page group is valid.
+    R_UNLESS(this->IsValidPageGroup(pg, address, num_pages), ResultInvalidCurrentMemory);
+
     // Create an update allocator.
-    Result allocator_result{ResultSuccess};
+    Result allocator_result;
     KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
                                                  m_memory_block_slab_manager, num_allocator_blocks);
     R_TRY(allocator_result);
 
-    // Perform the unmap.
-    R_TRY(Operate(address, num_pages, KMemoryPermission::None, OperationType::Unmap));
+    // We're going to perform an update, so create a helper.
+    KScopedPageTableUpdater updater(this);
+
+    // Perform unmapping operation.
+    const KPageProperties properties = {KMemoryPermission::None, false, false,
+                                        DisableMergeAttribute::None};
+    R_TRY(this->Operate(address, num_pages, properties.perm, OperationType::Unmap));
 
     // Update the blocks.
     m_memory_block_manager.Update(std::addressof(allocator), address, num_pages, KMemoryState::Free,
@@ -2550,54 +2804,6 @@ Result KPageTable::SetHeapSize(VAddr* out, size_t size) {
     }
 }
 
-ResultVal<VAddr> KPageTable::AllocateAndMapMemory(size_t needed_num_pages, size_t align,
-                                                  bool is_map_only, VAddr region_start,
-                                                  size_t region_num_pages, KMemoryState state,
-                                                  KMemoryPermission perm, PAddr map_addr) {
-    KScopedLightLock lk(m_general_lock);
-
-    R_UNLESS(CanContain(region_start, region_num_pages * PageSize, state),
-             ResultInvalidCurrentMemory);
-    R_UNLESS(region_num_pages > needed_num_pages, ResultOutOfMemory);
-    const VAddr addr{
-        AllocateVirtualMemory(region_start, region_num_pages, needed_num_pages, align)};
-    R_UNLESS(addr, ResultOutOfMemory);
-
-    // Create an update allocator.
-    Result allocator_result{ResultSuccess};
-    KMemoryBlockManagerUpdateAllocator allocator(std::addressof(allocator_result),
-                                                 m_memory_block_slab_manager);
-
-    if (is_map_only) {
-        R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
-    } else {
-        // Create a page group tohold the pages we allocate.
-        KPageGroup pg{m_kernel, m_block_info_manager};
-
-        R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
-            &pg, needed_num_pages,
-            KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option)));
-
-        // Ensure that the page group is closed when we're done working with it.
-        SCOPE_EXIT({ pg.Close(); });
-
-        // Clear all pages.
-        for (const auto& it : pg) {
-            std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()),
-                        m_heap_fill_value, it.GetSize());
-        }
-
-        R_TRY(Operate(addr, needed_num_pages, pg, OperationType::MapGroup));
-    }
-
-    // Update the blocks.
-    m_memory_block_manager.Update(std::addressof(allocator), addr, needed_num_pages, state, perm,
-                                  KMemoryAttribute::None, KMemoryBlockDisableMergeAttribute::Normal,
-                                  KMemoryBlockDisableMergeAttribute::None);
-
-    return addr;
-}
-
 Result KPageTable::LockForMapDeviceAddressSpace(bool* out_is_io, VAddr address, size_t size,
                                                 KMemoryPermission perm, bool is_aligned,
                                                 bool check_heap) {

src/core/hle/kernel/k_page_table.h

@@ -24,12 +24,36 @@ class System;
 
 namespace Kernel {
 
+enum class DisableMergeAttribute : u8 {
+    None = (0U << 0),
+    DisableHead = (1U << 0),
+    DisableHeadAndBody = (1U << 1),
+    EnableHeadAndBody = (1U << 2),
+    DisableTail = (1U << 3),
+    EnableTail = (1U << 4),
+    EnableAndMergeHeadBodyTail = (1U << 5),
+    EnableHeadBodyTail = EnableHeadAndBody | EnableTail,
+    DisableHeadBodyTail = DisableHeadAndBody | DisableTail,
+};
+
+struct KPageProperties {
+    KMemoryPermission perm;
+    bool io;
+    bool uncached;
+    DisableMergeAttribute disable_merge_attributes;
+};
+static_assert(std::is_trivial_v<KPageProperties>);
+static_assert(sizeof(KPageProperties) == sizeof(u32));
+
 class KBlockInfoManager;
 class KMemoryBlockManager;
 class KResourceLimit;
 class KSystemResource;
 
 class KPageTable final {
+protected:
+    struct PageLinkedList;
+
 public:
     enum class ICacheInvalidationStrategy : u32 { InvalidateRange, InvalidateAll };
 
@@ -57,27 +81,12 @@ public:
     Result UnmapPhysicalMemory(VAddr addr, size_t size);
     Result MapMemory(VAddr dst_addr, VAddr src_addr, size_t size);
     Result UnmapMemory(VAddr dst_addr, VAddr src_addr, size_t size);
-    Result MapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state,
-                    KMemoryPermission perm);
-    Result MapPages(VAddr* out_addr, size_t num_pages, size_t alignment, PAddr phys_addr,
-                    KMemoryState state, KMemoryPermission perm) {
-        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
-                                this->GetRegionAddress(state),
-                                this->GetRegionSize(state) / PageSize, state, perm));
-    }
-    Result UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state);
-    Result UnmapPages(VAddr address, size_t num_pages, KMemoryState state);
     Result SetProcessMemoryPermission(VAddr addr, size_t size, Svc::MemoryPermission svc_perm);
     KMemoryInfo QueryInfo(VAddr addr);
     Result SetMemoryPermission(VAddr addr, size_t size, Svc::MemoryPermission perm);
     Result SetMemoryAttribute(VAddr addr, size_t size, u32 mask, u32 attr);
     Result SetMaxHeapSize(size_t size);
     Result SetHeapSize(VAddr* out, size_t size);
-    ResultVal<VAddr> AllocateAndMapMemory(size_t needed_num_pages, size_t align, bool is_map_only,
-                                          VAddr region_start, size_t region_num_pages,
-                                          KMemoryState state, KMemoryPermission perm,
-                                          PAddr map_addr = 0);
-
     Result LockForMapDeviceAddressSpace(bool* out_is_io, VAddr address, size_t size,
                                         KMemoryPermission perm, bool is_aligned, bool check_heap);
     Result LockForUnmapDeviceAddressSpace(VAddr address, size_t size, bool check_heap);
@@ -113,6 +122,40 @@ public:
 
     bool CanContain(VAddr 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) {
+        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true, region_start,
+                                region_num_pages, state, perm));
+    }
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                    KPhysicalAddress phys_addr, KMemoryState state, KMemoryPermission perm) {
+        R_RETURN(this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
+                                this->GetRegionAddress(state),
+                                this->GetRegionSize(state) / PageSize, state, perm));
+    }
+
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, KMemoryState state,
+                    KMemoryPermission perm) {
+        R_RETURN(this->MapPages(out_addr, num_pages, PageSize, 0, false,
+                                this->GetRegionAddress(state),
+                                this->GetRegionSize(state) / PageSize, state, perm));
+    }
+
+    Result MapPages(KProcessAddress address, size_t num_pages, KMemoryState state,
+                    KMemoryPermission perm);
+    Result UnmapPages(KProcessAddress address, size_t num_pages, KMemoryState state);
+
+    Result MapPageGroup(KProcessAddress* out_addr, const KPageGroup& pg,
+                        KProcessAddress region_start, size_t region_num_pages, KMemoryState state,
+                        KMemoryPermission perm);
+    Result MapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state,
+                        KMemoryPermission perm);
+    Result UnmapPageGroup(KProcessAddress address, const KPageGroup& pg, KMemoryState state);
+    void RemapPageGroup(PageLinkedList* page_list, KProcessAddress address, size_t size,
+                        const KPageGroup& pg);
+
 protected:
     struct PageLinkedList {
     private:
@@ -166,11 +209,9 @@ private:
     static constexpr KMemoryAttribute DefaultMemoryIgnoreAttr =
         KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
 
-    Result MapPages(VAddr addr, const KPageGroup& page_linked_list, KMemoryPermission perm);
-    Result MapPages(VAddr* out_addr, size_t num_pages, size_t alignment, PAddr phys_addr,
-                    bool is_pa_valid, VAddr region_start, size_t region_num_pages,
-                    KMemoryState state, KMemoryPermission perm);
-    Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list);
+    Result MapPages(KProcessAddress* out_addr, size_t num_pages, size_t alignment,
+                    KPhysicalAddress phys_addr, bool is_pa_valid, KProcessAddress region_start,
+                    size_t region_num_pages, KMemoryState state, KMemoryPermission perm);
     bool IsRegionContiguous(VAddr addr, u64 size) const;
     void AddRegionToPages(VAddr start, size_t num_pages, KPageGroup& page_linked_list);
     KMemoryInfo QueryInfoImpl(VAddr addr);
@@ -265,6 +306,11 @@ private:
     void CleanupForIpcClientOnServerSetupFailure(PageLinkedList* page_list, VAddr address,
                                                  size_t size, KMemoryPermission prot_perm);
 
+    Result AllocateAndMapPagesImpl(PageLinkedList* page_list, KProcessAddress address,
+                                   size_t num_pages, KMemoryPermission perm);
+    Result MapPageGroupImpl(PageLinkedList* page_list, KProcessAddress address,
+                            const KPageGroup& pg, const KPageProperties properties, bool reuse_ll);
+
     mutable KLightLock m_general_lock;
     mutable KLightLock m_map_physical_memory_lock;
 

src/core/hle/kernel/k_process.cpp

@@ -417,9 +417,8 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
 }
 
 void KProcess::Run(s32 main_thread_priority, u64 stack_size) {
-    AllocateMainThreadStack(stack_size);
+    ASSERT(AllocateMainThreadStack(stack_size) == ResultSuccess);
     resource_limit->Reserve(LimitableResource::ThreadCountMax, 1);
-    resource_limit->Reserve(LimitableResource::PhysicalMemoryMax, 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());
@@ -675,20 +674,31 @@ void KProcess::ChangeState(State new_state) {
 }
 
 Result KProcess::AllocateMainThreadStack(std::size_t stack_size) {
-    ASSERT(stack_size);
+    // Ensure that we haven't already allocated stack.
+    ASSERT(main_thread_stack_size == 0);
 
-    // The kernel always ensures that the given stack size is page aligned.
-    main_thread_stack_size = Common::AlignUp(stack_size, PageSize);
+    // Ensure that we're allocating a valid stack.
+    stack_size = Common::AlignUp(stack_size, PageSize);
+    // R_UNLESS(stack_size + image_size <= m_max_process_memory, ResultOutOfMemory);
+    R_UNLESS(stack_size + image_size >= image_size, ResultOutOfMemory);
 
-    const VAddr start{page_table.GetStackRegionStart()};
-    const std::size_t size{page_table.GetStackRegionEnd() - start};
+    // Place a tentative reservation of memory for our new stack.
+    KScopedResourceReservation mem_reservation(this, Svc::LimitableResource::PhysicalMemoryMax,
+                                               stack_size);
+    R_UNLESS(mem_reservation.Succeeded(), ResultLimitReached);
 
-    CASCADE_RESULT(main_thread_stack_top,
-                   page_table.AllocateAndMapMemory(
-                       main_thread_stack_size / PageSize, PageSize, false, start, size / PageSize,
-                       KMemoryState::Stack, KMemoryPermission::UserReadWrite));
+    // Allocate and map our stack.
+    if (stack_size) {
+        KProcessAddress stack_bottom;
+        R_TRY(page_table.MapPages(std::addressof(stack_bottom), stack_size / PageSize,
+                                  KMemoryState::Stack, KMemoryPermission::UserReadWrite));
 
-    main_thread_stack_top += main_thread_stack_size;
+        main_thread_stack_top = stack_bottom + stack_size;
+        main_thread_stack_size = stack_size;
+    }
+
+    // We succeeded! Commit our memory reservation.
+    mem_reservation.Commit();
 
     R_SUCCEED();
 }

src/core/hle/kernel/k_shared_memory.cpp

@@ -94,15 +94,15 @@ Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t m
         R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
     }
 
-    return target_process.PageTable().MapPages(address, *page_group, KMemoryState::Shared,
-                                               ConvertToKMemoryPermission(map_perm));
+    return target_process.PageTable().MapPageGroup(address, *page_group, KMemoryState::Shared,
+                                                   ConvertToKMemoryPermission(map_perm));
 }
 
 Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
     // Validate the size.
     R_UNLESS(size == unmap_size, ResultInvalidSize);
 
-    return target_process.PageTable().UnmapPages(address, *page_group, KMemoryState::Shared);
+    return target_process.PageTable().UnmapPageGroup(address, *page_group, KMemoryState::Shared);
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_thread.cpp

@@ -330,7 +330,7 @@ void KThread::Finalize() {
             KThread* const waiter = std::addressof(*it);
 
             // The thread shouldn't be a kernel waiter.
-            ASSERT(!IsKernelAddressKey(waiter->GetAddressKey()));
+            ASSERT(!waiter->GetAddressKeyIsKernel());
 
             // Clear the lock owner.
             waiter->SetLockOwner(nullptr);
@@ -763,19 +763,6 @@ void KThread::Continue() {
     KScheduler::OnThreadStateChanged(kernel, this, old_state);
 }
 
-void KThread::WaitUntilSuspended() {
-    // Make sure we have a suspend requested.
-    ASSERT(IsSuspendRequested());
-
-    // Loop until the thread is not executing on any core.
-    for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) {
-        KThread* core_thread{};
-        do {
-            core_thread = kernel.Scheduler(i).GetSchedulerCurrentThread();
-        } while (core_thread == this);
-    }
-}
-
 Result KThread::SetActivity(Svc::ThreadActivity activity) {
     // Lock ourselves.
     KScopedLightLock lk(activity_pause_lock);
@@ -897,7 +884,7 @@ void KThread::AddWaiterImpl(KThread* thread) {
     }
 
     // Keep track of how many kernel waiters we have.
-    if (IsKernelAddressKey(thread->GetAddressKey())) {
+    if (thread->GetAddressKeyIsKernel()) {
         ASSERT((num_kernel_waiters++) >= 0);
         KScheduler::SetSchedulerUpdateNeeded(kernel);
     }
@@ -911,7 +898,7 @@ void KThread::RemoveWaiterImpl(KThread* thread) {
     ASSERT(kernel.GlobalSchedulerContext().IsLocked());
 
     // Keep track of how many kernel waiters we have.
-    if (IsKernelAddressKey(thread->GetAddressKey())) {
+    if (thread->GetAddressKeyIsKernel()) {
         ASSERT((num_kernel_waiters--) > 0);
         KScheduler::SetSchedulerUpdateNeeded(kernel);
     }
@@ -987,7 +974,7 @@ KThread* KThread::RemoveWaiterByKey(s32* out_num_waiters, VAddr key) {
             KThread* thread = std::addressof(*it);
 
             // Keep track of how many kernel waiters we have.
-            if (IsKernelAddressKey(thread->GetAddressKey())) {
+            if (thread->GetAddressKeyIsKernel()) {
                 ASSERT((num_kernel_waiters--) > 0);
                 KScheduler::SetSchedulerUpdateNeeded(kernel);
             }

src/core/hle/kernel/k_thread.h

@@ -214,8 +214,6 @@ public:
 
     void Continue();
 
-    void WaitUntilSuspended();
-
     constexpr void SetSyncedIndex(s32 index) {
         synced_index = index;
     }
@@ -607,13 +605,30 @@ public:
         return address_key_value;
     }
 
-    void SetAddressKey(VAddr key) {
-        address_key = key;
+    [[nodiscard]] bool GetAddressKeyIsKernel() const {
+        return address_key_is_kernel;
     }
 
-    void SetAddressKey(VAddr key, u32 val) {
+    //! NB: intentional deviation from official kernel.
+    //
+    // Separate SetAddressKey into user and kernel versions
+    // to cope with arbitrary host pointers making their way
+    // into things.
+
+    void SetUserAddressKey(VAddr key) {
+        address_key = key;
+        address_key_is_kernel = false;
+    }
+
+    void SetUserAddressKey(VAddr key, u32 val) {
         address_key = key;
         address_key_value = val;
+        address_key_is_kernel = false;
+    }
+
+    void SetKernelAddressKey(VAddr key) {
+        address_key = key;
+        address_key_is_kernel = true;
     }
 
     void ClearWaitQueue() {
@@ -772,6 +787,7 @@ private:
     bool debug_attached{};
     s8 priority_inheritance_count{};
     bool resource_limit_release_hint{};
+    bool address_key_is_kernel{};
     StackParameters stack_parameters{};
     Common::SpinLock context_guard{};
 

src/core/hle/kernel/kernel.cpp

@@ -1198,27 +1198,34 @@ void KernelCore::Suspend(bool suspended) {
     const bool should_suspend{exception_exited || suspended};
     const auto activity = should_suspend ? ProcessActivity::Paused : ProcessActivity::Runnable;
 
-    std::vector<KScopedAutoObject<KThread>> process_threads;
-    {
-        KScopedSchedulerLock sl{*this};
-
-        if (auto* process = CurrentProcess(); process != nullptr) {
-            process->SetActivity(activity);
-
-            if (!should_suspend) {
-                // Runnable now; no need to wait.
-                return;
-            }
-
-            for (auto* thread : process->GetThreadList()) {
-                process_threads.emplace_back(thread);
-            }
-        }
+    //! This refers to the application process, not the current process.
+    KScopedAutoObject<KProcess> process = CurrentProcess();
+    if (process.IsNull()) {
+        return;
     }
 
-    // Wait for execution to stop.
-    for (auto& thread : process_threads) {
-        thread->WaitUntilSuspended();
+    // Set the new activity.
+    process->SetActivity(activity);
+
+    // Wait for process execution to stop.
+    bool must_wait{should_suspend};
+
+    // KernelCore::Suspend must be called from locked context, or we
+    // could race another call to SetActivity, interfering with waiting.
+    while (must_wait) {
+        KScopedSchedulerLock sl{*this};
+
+        // Assume that all threads have finished running.
+        must_wait = false;
+
+        for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {
+            if (Scheduler(i).GetSchedulerCurrentThread()->GetOwnerProcess() ==
+                process.GetPointerUnsafe()) {
+                // A thread has not finished running yet.
+                // Continue waiting.
+                must_wait = true;
+            }
+        }
     }
 }
 

src/core/hle/kernel/svc.cpp

@@ -1492,8 +1492,8 @@ static Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle p
         KMemoryAttribute::All, KMemoryAttribute::None));
 
     // Map the group.
-    R_TRY(dst_pt.MapPages(dst_address, pg, KMemoryState::SharedCode,
-                          KMemoryPermission::UserReadWrite));
+    R_TRY(dst_pt.MapPageGroup(dst_address, pg, KMemoryState::SharedCode,
+                              KMemoryPermission::UserReadWrite));
 
     return ResultSuccess;
 }

src/core/memory.cpp

@@ -440,7 +440,7 @@ struct Memory::Impl {
         }
 
         if (Settings::IsFastmemEnabled()) {
-            const bool is_read_enable = !Settings::IsGPULevelExtreme() || !cached;
+            const bool is_read_enable = Settings::IsGPULevelHigh() || !cached;
             system.DeviceMemory().buffer.Protect(vaddr, size, is_read_enable, !cached);
         }
 

src/input_common/drivers/gc_adapter.cpp

@@ -6,6 +6,7 @@
 
 #include "common/logging/log.h"
 #include "common/param_package.h"
+#include "common/polyfill_thread.h"
 #include "common/settings_input.h"
 #include "common/thread.h"
 #include "input_common/drivers/gc_adapter.h"
@@ -217,8 +218,7 @@ void GCAdapter::AdapterScanThread(std::stop_token stop_token) {
     Common::SetCurrentThreadName("ScanGCAdapter");
     usb_adapter_handle = nullptr;
     pads = {};
-    while (!stop_token.stop_requested() && !Setup()) {
-        std::this_thread::sleep_for(std::chrono::seconds(2));
+    while (!Setup() && Common::StoppableTimedWait(stop_token, std::chrono::seconds{2})) {
     }
 }
 

src/input_common/drivers/joycon.cpp

@@ -4,6 +4,8 @@
 #include <fmt/format.h>
 
 #include "common/param_package.h"
+#include "common/polyfill_ranges.h"
+#include "common/polyfill_thread.h"
 #include "common/settings.h"
 #include "common/thread.h"
 #include "input_common/drivers/joycon.h"
@@ -66,7 +68,8 @@ void Joycons::Setup() {
 void Joycons::ScanThread(std::stop_token stop_token) {
     constexpr u16 nintendo_vendor_id = 0x057e;
     Common::SetCurrentThreadName("JoyconScanThread");
-    while (!stop_token.stop_requested()) {
+
+    do {
         SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
         SDL_hid_device_info* cur_dev = devs;
 
@@ -80,8 +83,7 @@ void Joycons::ScanThread(std::stop_token stop_token) {
         }
 
         SDL_hid_free_enumeration(devs);
-        std::this_thread::sleep_for(std::chrono::seconds(5));
-    }
+    } while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
 }
 
 bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {

src/input_common/helpers/joycon_driver.cpp

@@ -86,6 +86,7 @@ DriverResult JoyconDriver::InitializeDevice() {
 
     // Get fixed joycon info
     generic_protocol->GetVersionNumber(version);
+    generic_protocol->SetLowPowerMode(false);
     generic_protocol->GetColor(color);
     if (handle_device_type == ControllerType::Pro) {
         // Some 3rd party controllers aren't pro controllers
@@ -324,6 +325,8 @@ DriverResult JoyconDriver::SetPollingMode() {
     if (result != DriverResult::Success) {
         LOG_ERROR(Input, "Error enabling active mode");
     }
+    // Switch calls this function after enabling active mode
+    generic_protocol->TriggersElapsed();
 
     disable_input_thread = false;
     return result;

src/input_common/helpers/joycon_protocol/generic_functions.cpp

@@ -19,6 +19,17 @@ DriverResult GenericProtocol::EnableActiveMode() {
     return SetReportMode(ReportMode::STANDARD_FULL_60HZ);
 }
 
+DriverResult GenericProtocol::SetLowPowerMode(bool enable) {
+    ScopedSetBlocking sb(this);
+    const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)};
+    return SendSubCommand(SubCommand::LOW_POWER_MODE, buffer);
+}
+
+DriverResult GenericProtocol::TriggersElapsed() {
+    ScopedSetBlocking sb(this);
+    return SendSubCommand(SubCommand::TRIGGERS_ELAPSED, {});
+}
+
 DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) {
     ScopedSetBlocking sb(this);
     std::vector<u8> output;

src/input_common/helpers/joycon_protocol/generic_functions.h

@@ -25,6 +25,12 @@ public:
     /// Enables active mode. This mode will return the current status every 5-15ms
     DriverResult EnableActiveMode();
 
+    /// Enables or disables the low power mode
+    DriverResult SetLowPowerMode(bool enable);
+
+    /// Unknown function used by the switch
+    DriverResult TriggersElapsed();
+
     /**
      * Sends a request to obtain the joycon firmware and mac from handle
      * @returns controller device info

src/input_common/helpers/joycon_protocol/joycon_types.h

@@ -129,6 +129,7 @@ enum class SubCommand : u8 {
     LOW_POWER_MODE = 0x08,
     SPI_FLASH_READ = 0x10,
     SPI_FLASH_WRITE = 0x11,
+    SPI_SECTOR_ERASE = 0x12,
     RESET_MCU = 0x20,
     SET_MCU_CONFIG = 0x21,
     SET_MCU_STATE = 0x22,

src/shader_recompiler/backend/glasm/emit_glasm.cpp

@@ -279,6 +279,8 @@ void SetupOptions(const IR::Program& program, const Profile& profile,
     header += "OPTION NV_internal;"
               "OPTION NV_shader_storage_buffer;"
               "OPTION NV_gpu_program_fp64;";
+    // TODO: Enable only when MS is used
+    header += "OPTION NV_texture_multisample;";
     if (info.uses_int64_bit_atomics) {
         header += "OPTION NV_shader_atomic_int64;";
     }

src/shader_recompiler/backend/glasm/emit_glasm_bitwise_conversion.cpp

@@ -43,10 +43,6 @@ void EmitBitCastU64F64(EmitContext&, IR::Inst& inst, const IR::Value& value) {
     Alias(inst, value);
 }
 
-void EmitBitCastS32F32(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
 void EmitBitCastF16U16(EmitContext&, IR::Inst& inst, const IR::Value& value) {
     Alias(inst, value);
 }

src/shader_recompiler/backend/glasm/emit_glasm_image.cpp

@@ -59,7 +59,7 @@ std::string Image(EmitContext& ctx, IR::TextureInstInfo info,
     }
 }
 
-std::string_view TextureType(IR::TextureInstInfo info) {
+std::string_view TextureType(IR::TextureInstInfo info, bool is_ms = false) {
     if (info.is_depth) {
         switch (info.type) {
         case TextureType::Color1D:
@@ -88,9 +88,9 @@ std::string_view TextureType(IR::TextureInstInfo info) {
             return "ARRAY1D";
         case TextureType::Color2D:
         case TextureType::Color2DRect:
-            return "2D";
+            return is_ms ? "2DMS" : "2D";
         case TextureType::ColorArray2D:
-            return "ARRAY2D";
+            return is_ms ? "ARRAY2DMS" : "ARRAY2D";
         case TextureType::Color3D:
             return "3D";
         case TextureType::ColorCube:
@@ -510,15 +510,16 @@ void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
                     const IR::Value& coord, const IR::Value& offset, ScalarS32 lod, ScalarS32 ms) {
     const auto info{inst.Flags<IR::TextureInstInfo>()};
     const auto sparse_inst{PrepareSparse(inst)};
+    const bool is_multisample{ms.type != Type::Void};
     const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
+    const std::string_view type{TextureType(info, is_multisample)};
     const std::string texture{Texture(ctx, info, index)};
     const std::string offset_vec{Offset(ctx, offset)};
     const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
     const Register ret{ctx.reg_alloc.Define(inst)};
     if (info.type == TextureType::Buffer) {
         ctx.Add("TXF.F{} {},{},{},{}{};", sparse_mod, ret, coord_vec, texture, type, offset_vec);
-    } else if (ms.type != Type::Void) {
+    } else if (is_multisample) {
         ctx.Add("MOV.S {}.w,{};"
                 "TXFMS.F{} {},{},{},{}{};",
                 coord_vec, ms, sparse_mod, ret, coord_vec, texture, type, offset_vec);

src/shader_recompiler/backend/glasm/emit_glasm_instructions.h

@@ -197,7 +197,6 @@ void EmitSelectF64(EmitContext& ctx, ScalarS32 cond, Register true_value, Regist
 void EmitBitCastU16F16(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
 void EmitBitCastU32F32(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
 void EmitBitCastU64F64(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastS32F32(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
 void EmitBitCastF16U16(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
 void EmitBitCastF32U32(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
 void EmitBitCastF64U64(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);

src/shader_recompiler/backend/glsl/emit_glsl_bitwise_conversion.cpp

@@ -48,10 +48,6 @@ void EmitBitCastU64F64(EmitContext& ctx, IR::Inst& inst, std::string_view value)
     ctx.AddU64("{}=doubleBitsToUint64({});", inst, value);
 }
 
-void EmitBitCastS32F32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
-    ctx.AddF32("{}=ftoi({});", inst, value);
-}
-
 void EmitBitCastF16U16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst) {
     NotImplemented();
 }

src/shader_recompiler/backend/glsl/emit_glsl_image.cpp

@@ -414,7 +414,7 @@ void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& inde
 
 void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
                     std::string_view coords, std::string_view offset, std::string_view lod,
-                    [[maybe_unused]] std::string_view ms) {
+                    std::string_view ms) {
     const auto info{inst.Flags<IR::TextureInstInfo>()};
     if (info.has_bias) {
         throw NotImplementedException("EmitImageFetch Bias texture samples");
@@ -431,19 +431,24 @@ void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
         ctx.AddU1("{}=true;", *sparse_inst);
     }
     if (!sparse_inst || !supports_sparse) {
-        if (!offset.empty()) {
-            ctx.Add("{}=texelFetchOffset({},{},int({}),{});", texel, texture,
-                    CoordsCastToInt(coords, info), lod, CoordsCastToInt(offset, info));
+        const auto int_coords{CoordsCastToInt(coords, info)};
+        if (!ms.empty()) {
+            ctx.Add("{}=texelFetch({},{},int({}));", texel, texture, int_coords, ms);
+        } else if (!offset.empty()) {
+            ctx.Add("{}=texelFetchOffset({},{},int({}),{});", texel, texture, int_coords, lod,
+                    CoordsCastToInt(offset, info));
         } else {
             if (info.type == TextureType::Buffer) {
                 ctx.Add("{}=texelFetch({},int({}));", texel, texture, coords);
             } else {
-                ctx.Add("{}=texelFetch({},{},int({}));", texel, texture,
-                        CoordsCastToInt(coords, info), lod);
+                ctx.Add("{}=texelFetch({},{},int({}));", texel, texture, int_coords, lod);
             }
         }
         return;
     }
+    if (!ms.empty()) {
+        throw NotImplementedException("EmitImageFetch Sparse MSAA samples");
+    }
     if (!offset.empty()) {
         ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchOffsetARB({},{},int({}),{},{}));",
                   *sparse_inst, texture, CastToIntVec(coords, info), lod,

src/shader_recompiler/backend/glsl/emit_glsl_instructions.h

@@ -231,7 +231,6 @@ void EmitSelectF64(EmitContext& ctx, IR::Inst& inst, std::string_view cond,
 void EmitBitCastU16F16(EmitContext& ctx, IR::Inst& inst);
 void EmitBitCastU32F32(EmitContext& ctx, IR::Inst& inst, std::string_view value);
 void EmitBitCastU64F64(EmitContext& ctx, IR::Inst& inst, std::string_view value);
-void EmitBitCastS32F32(EmitContext& ctx, IR::Inst& inst, std::string_view value);
 void EmitBitCastF16U16(EmitContext& ctx, IR::Inst& inst);
 void EmitBitCastF32U32(EmitContext& ctx, IR::Inst& inst, std::string_view value);
 void EmitBitCastF64U64(EmitContext& ctx, IR::Inst& inst, std::string_view value);

src/shader_recompiler/backend/glsl/glsl_emit_context.cpp

@@ -61,24 +61,28 @@ std::string OutputDecorator(Stage stage, u32 size) {
     }
 }
 
-std::string_view SamplerType(TextureType type, bool is_depth) {
-    if (is_depth) {
-        switch (type) {
-        case TextureType::Color1D:
-            return "sampler1DShadow";
-        case TextureType::ColorArray1D:
-            return "sampler1DArrayShadow";
-        case TextureType::Color2D:
-            return "sampler2DShadow";
-        case TextureType::ColorArray2D:
-            return "sampler2DArrayShadow";
-        case TextureType::ColorCube:
-            return "samplerCubeShadow";
-        case TextureType::ColorArrayCube:
-            return "samplerCubeArrayShadow";
-        default:
-            throw NotImplementedException("Texture type: {}", type);
-        }
+std::string_view DepthSamplerType(TextureType type) {
+    switch (type) {
+    case TextureType::Color1D:
+        return "sampler1DShadow";
+    case TextureType::ColorArray1D:
+        return "sampler1DArrayShadow";
+    case TextureType::Color2D:
+        return "sampler2DShadow";
+    case TextureType::ColorArray2D:
+        return "sampler2DArrayShadow";
+    case TextureType::ColorCube:
+        return "samplerCubeShadow";
+    case TextureType::ColorArrayCube:
+        return "samplerCubeArrayShadow";
+    default:
+        throw NotImplementedException("Texture type: {}", type);
+    }
+}
+
+std::string_view ColorSamplerType(TextureType type, bool is_multisample = false) {
+    if (is_multisample) {
+        ASSERT(type == TextureType::Color2D || type == TextureType::ColorArray2D);
     }
     switch (type) {
     case TextureType::Color1D:
@@ -87,9 +91,9 @@ std::string_view SamplerType(TextureType type, bool is_depth) {
         return "sampler1DArray";
     case TextureType::Color2D:
     case TextureType::Color2DRect:
-        return "sampler2D";
+        return is_multisample ? "sampler2DMS" : "sampler2D";
     case TextureType::ColorArray2D:
-        return "sampler2DArray";
+        return is_multisample ? "sampler2DMSArray" : "sampler2DArray";
     case TextureType::Color3D:
         return "sampler3D";
     case TextureType::ColorCube:
@@ -677,7 +681,7 @@ void EmitContext::SetupTextures(Bindings& bindings) {
     texture_buffers.reserve(info.texture_buffer_descriptors.size());
     for (const auto& desc : info.texture_buffer_descriptors) {
         texture_buffers.push_back({bindings.texture, desc.count});
-        const auto sampler_type{SamplerType(TextureType::Buffer, false)};
+        const auto sampler_type{ColorSamplerType(TextureType::Buffer)};
         const auto array_decorator{desc.count > 1 ? fmt::format("[{}]", desc.count) : ""};
         header += fmt::format("layout(binding={}) uniform {} tex{}{};", bindings.texture,
                               sampler_type, bindings.texture, array_decorator);
@@ -686,7 +690,8 @@ void EmitContext::SetupTextures(Bindings& bindings) {
     textures.reserve(info.texture_descriptors.size());
     for (const auto& desc : info.texture_descriptors) {
         textures.push_back({bindings.texture, desc.count});
-        const auto sampler_type{SamplerType(desc.type, desc.is_depth)};
+        const auto sampler_type{desc.is_depth ? DepthSamplerType(desc.type)
+                                              : ColorSamplerType(desc.type, desc.is_multisample)};
         const auto array_decorator{desc.count > 1 ? fmt::format("[{}]", desc.count) : ""};
         header += fmt::format("layout(binding={}) uniform {} tex{}{};", bindings.texture,
                               sampler_type, bindings.texture, array_decorator);

src/shader_recompiler/backend/spirv/emit_spirv_bitwise_conversion.cpp

@@ -18,10 +18,6 @@ void EmitBitCastU64F64(EmitContext&) {
     throw NotImplementedException("SPIR-V Instruction");
 }
 
-void EmitBitCastS32F32(EmitContext&) {
-    throw NotImplementedException("SPIR-V Instruction");
-}
-
 void EmitBitCastF16U16(EmitContext&) {
     throw NotImplementedException("SPIR-V Instruction");
 }

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -436,6 +436,10 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
     if (info.type == TextureType::Buffer) {
         lod = Id{};
     }
+    if (Sirit::ValidId(ms)) {
+        // This image is multisampled, lod must be implicit
+        lod = Id{};
+    }
     const ImageOperands operands(offset, lod, ms);
     return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
                 TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());

src/shader_recompiler/backend/spirv/emit_spirv_instructions.h

@@ -179,7 +179,6 @@ Id EmitSelectF64(EmitContext& ctx, Id cond, Id true_value, Id false_value);
 void EmitBitCastU16F16(EmitContext& ctx);
 Id EmitBitCastU32F32(EmitContext& ctx, Id value);
 void EmitBitCastU64F64(EmitContext& ctx);
-void EmitBitCastS32F32(EmitContext& ctx);
 void EmitBitCastF16U16(EmitContext&);
 Id EmitBitCastF32U32(EmitContext& ctx, Id value);
 void EmitBitCastF64U64(EmitContext& ctx);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -35,6 +35,7 @@ Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
     const spv::ImageFormat format{spv::ImageFormat::Unknown};
     const Id type{ctx.F32[1]};
     const bool depth{desc.is_depth};
+    const bool ms{desc.is_multisample};
     switch (desc.type) {
     case TextureType::Color1D:
         return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
@@ -42,9 +43,9 @@ Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
         return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
     case TextureType::Color2D:
     case TextureType::Color2DRect:
-        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
     case TextureType::ColorArray2D:
-        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, ms, 1, format);
     case TextureType::Color3D:
         return ctx.TypeImage(type, spv::Dim::Dim3D, depth, false, false, 1, format);
     case TextureType::ColorCube:

src/shader_recompiler/frontend/ir/ir_emitter.cpp

@@ -703,11 +703,6 @@ IR::U32 IREmitter::BitCast<IR::U32, IR::F32>(const IR::F32& value) {
     return Inst<IR::U32>(Opcode::BitCastU32F32, value);
 }
 
-template <>
-IR::S32 IREmitter::BitCast<IR::S32, IR::F32>(const IR::F32& value) {
-    return Inst<IR::S32>(Opcode::BitCastS32F32, value);
-}
-
 template <>
 IR::F32 IREmitter::BitCast<IR::F32, IR::U32>(const IR::U32& value) {
     return Inst<IR::F32>(Opcode::BitCastF32U32, value);

src/shader_recompiler/frontend/ir/opcodes.h

@@ -38,7 +38,6 @@ constexpr Type U8{Type::U8};
 constexpr Type U16{Type::U16};
 constexpr Type U32{Type::U32};
 constexpr Type U64{Type::U64};
-constexpr Type S32{Type::S32};
 constexpr Type F16{Type::F16};
 constexpr Type F32{Type::F32};
 constexpr Type F64{Type::F64};

src/shader_recompiler/frontend/ir/opcodes.inc

@@ -175,7 +175,6 @@ OPCODE(SelectF64,                                           F64,            U1,
 OPCODE(BitCastU16F16,                                       U16,            F16,                                                                            )
 OPCODE(BitCastU32F32,                                       U32,            F32,                                                                            )
 OPCODE(BitCastU64F64,                                       U64,            F64,                                                                            )
-OPCODE(BitCastS32F32,                                       S32,            F32,                                                                            )
 OPCODE(BitCastF16U16,                                       F16,            U16,                                                                            )
 OPCODE(BitCastF32U32,                                       F32,            U32,                                                                            )
 OPCODE(BitCastF64U64,                                       F64,            U64,                                                                            )

src/shader_recompiler/frontend/ir/type.h

@@ -24,22 +24,21 @@ enum class Type {
     U16 = 1 << 7,
     U32 = 1 << 8,
     U64 = 1 << 9,
-    S32 = 1 << 10,
-    F16 = 1 << 11,
-    F32 = 1 << 12,
-    F64 = 1 << 13,
-    U32x2 = 1 << 14,
-    U32x3 = 1 << 15,
-    U32x4 = 1 << 16,
-    F16x2 = 1 << 17,
-    F16x3 = 1 << 18,
-    F16x4 = 1 << 19,
-    F32x2 = 1 << 20,
-    F32x3 = 1 << 21,
-    F32x4 = 1 << 22,
-    F64x2 = 1 << 23,
-    F64x3 = 1 << 24,
-    F64x4 = 1 << 25,
+    F16 = 1 << 10,
+    F32 = 1 << 11,
+    F64 = 1 << 12,
+    U32x2 = 1 << 13,
+    U32x3 = 1 << 14,
+    U32x4 = 1 << 15,
+    F16x2 = 1 << 16,
+    F16x3 = 1 << 17,
+    F16x4 = 1 << 18,
+    F32x2 = 1 << 19,
+    F32x3 = 1 << 20,
+    F32x4 = 1 << 21,
+    F64x2 = 1 << 22,
+    F64x3 = 1 << 23,
+    F64x4 = 1 << 24,
 };
 DECLARE_ENUM_FLAG_OPERATORS(Type)
 

src/shader_recompiler/frontend/ir/value.cpp

@@ -23,8 +23,6 @@ Value::Value(u16 value) noexcept : type{Type::U16}, imm_u16{value} {}
 
 Value::Value(u32 value) noexcept : type{Type::U32}, imm_u32{value} {}
 
-Value::Value(s32 value) noexcept : type{Type::S32}, imm_s32{value} {}
-
 Value::Value(f32 value) noexcept : type{Type::F32}, imm_f32{value} {}
 
 Value::Value(u64 value) noexcept : type{Type::U64}, imm_u64{value} {}
@@ -71,7 +69,6 @@ bool Value::operator==(const Value& other) const {
         return imm_u16 == other.imm_u16;
     case Type::U32:
     case Type::F32:
-    case Type::S32:
         return imm_u32 == other.imm_u32;
     case Type::U64:
     case Type::F64:

src/shader_recompiler/frontend/ir/value.h

@@ -268,7 +268,6 @@ using U8 = TypedValue<Type::U8>;
 using U16 = TypedValue<Type::U16>;
 using U32 = TypedValue<Type::U32>;
 using U64 = TypedValue<Type::U64>;
-using S32 = TypedValue<Type::S32>;
 using F16 = TypedValue<Type::F16>;
 using F32 = TypedValue<Type::F32>;
 using F64 = TypedValue<Type::F64>;

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -355,21 +355,21 @@ TextureInst MakeInst(Environment& env, IR::Block* block, IR::Inst& inst) {
     };
 }
 
-TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
+u32 GetTextureHandle(Environment& env, const ConstBufferAddr& cbuf) {
     const u32 secondary_index{cbuf.has_secondary ? cbuf.secondary_index : cbuf.index};
     const u32 secondary_offset{cbuf.has_secondary ? cbuf.secondary_offset : cbuf.offset};
     const u32 lhs_raw{env.ReadCbufValue(cbuf.index, cbuf.offset) << cbuf.shift_left};
     const u32 rhs_raw{env.ReadCbufValue(secondary_index, secondary_offset)
                       << cbuf.secondary_shift_left};
-    return env.ReadTextureType(lhs_raw | rhs_raw);
+    return lhs_raw | rhs_raw;
+}
+
+TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
+    return env.ReadTextureType(GetTextureHandle(env, cbuf));
 }
 
 TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
-    const u32 secondary_index{cbuf.has_secondary ? cbuf.secondary_index : cbuf.index};
-    const u32 secondary_offset{cbuf.has_secondary ? cbuf.secondary_offset : cbuf.offset};
-    const u32 lhs_raw{env.ReadCbufValue(cbuf.index, cbuf.offset)};
-    const u32 rhs_raw{env.ReadCbufValue(secondary_index, secondary_offset)};
-    return env.ReadTexturePixelFormat(lhs_raw | rhs_raw);
+    return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
 class Descriptors {
@@ -486,10 +486,10 @@ void PatchTexelFetch(IR::Block& block, IR::Inst& inst, TexturePixelFormat pixel_
     const IR::F32 w(ir.CompositeExtract(new_inst, 3));
     const IR::F16F32F64 max_value(ir.Imm32(get_max_value()));
     const IR::Value converted =
-        ir.CompositeConstruct(ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::S32>(x)), max_value),
-                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::S32>(y)), max_value),
-                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::S32>(z)), max_value),
-                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::S32>(w)), max_value));
+        ir.CompositeConstruct(ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(x)), max_value),
+                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(y)), max_value),
+                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(z)), max_value),
+                              ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(w)), max_value));
     inst.ReplaceUsesWith(converted);
 }
 } // Anonymous namespace
@@ -524,6 +524,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
 
         const auto& cbuf{texture_inst.cbuf};
         auto flags{inst->Flags<IR::TextureInstInfo>()};
+        bool is_multisample{false};
         switch (inst->GetOpcode()) {
         case IR::Opcode::ImageQueryDimensions:
             flags.type.Assign(ReadTextureType(env, cbuf));
@@ -538,6 +539,12 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             }
             break;
         case IR::Opcode::ImageFetch:
+            if (flags.type == TextureType::Color2D || flags.type == TextureType::Color2DRect ||
+                flags.type == TextureType::ColorArray2D) {
+                is_multisample = !inst->Arg(4).IsEmpty();
+            } else {
+                inst->SetArg(4, IR::U32{});
+            }
             if (flags.type != TextureType::Color1D) {
                 break;
             }
@@ -613,6 +620,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                 index = descriptors.Add(TextureDescriptor{
                     .type = flags.type,
                     .is_depth = flags.is_depth != 0,
+                    .is_multisample = is_multisample,
                     .has_secondary = cbuf.has_secondary,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,

src/shader_recompiler/shader_info.h

@@ -109,6 +109,7 @@ using ImageBufferDescriptors = boost::container::small_vector<ImageBufferDescrip
 struct TextureDescriptor {
     TextureType type;
     bool is_depth;
+    bool is_multisample;
     bool has_secondary;
     u32 cbuf_index;
     u32 cbuf_offset;

src/video_core/CMakeLists.txt

@@ -52,6 +52,8 @@ add_library(video_core STATIC
     engines/puller.cpp
     engines/puller.h
     framebuffer_config.h
+    fsr.cpp
+    fsr.h
     host1x/codecs/codec.cpp
     host1x/codecs/codec.h
     host1x/codecs/h264.cpp
@@ -110,6 +112,8 @@ add_library(video_core STATIC
     renderer_opengl/gl_device.h
     renderer_opengl/gl_fence_manager.cpp
     renderer_opengl/gl_fence_manager.h
+    renderer_opengl/gl_fsr.cpp
+    renderer_opengl/gl_fsr.h
     renderer_opengl/gl_graphics_pipeline.cpp
     renderer_opengl/gl_graphics_pipeline.h
     renderer_opengl/gl_rasterizer.cpp

src/video_core/fsr.cpp

@@ -0,0 +1,148 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cmath>
+#include "video_core/fsr.h"
+
+namespace FSR {
+namespace {
+// Reimplementations of the constant generating functions in ffx_fsr1.h
+// GCC generated a lot of warnings when using the official header.
+u32 AU1_AH1_AF1(f32 f) {
+    static constexpr u32 base[512]{
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040,
+        0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x0c00, 0x1000, 0x1400, 0x1800, 0x1c00, 0x2000,
+        0x2400, 0x2800, 0x2c00, 0x3000, 0x3400, 0x3800, 0x3c00, 0x4000, 0x4400, 0x4800, 0x4c00,
+        0x5000, 0x5400, 0x5800, 0x5c00, 0x6000, 0x6400, 0x6800, 0x6c00, 0x7000, 0x7400, 0x7800,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
+        0x7bff, 0x7bff, 0x7bff, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008,
+        0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 0x8200, 0x8400, 0x8800, 0x8c00, 0x9000, 0x9400,
+        0x9800, 0x9c00, 0xa000, 0xa400, 0xa800, 0xac00, 0xb000, 0xb400, 0xb800, 0xbc00, 0xc000,
+        0xc400, 0xc800, 0xcc00, 0xd000, 0xd400, 0xd800, 0xdc00, 0xe000, 0xe400, 0xe800, 0xec00,
+        0xf000, 0xf400, 0xf800, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
+    };
+    static constexpr s8 shift[512]{
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x16,
+        0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17,
+        0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+        0x18, 0x18,
+    };
+    const u32 u = Common::BitCast<u32>(f);
+    const u32 i = u >> 23;
+    return base[i] + ((u & 0x7fffff) >> shift[i]);
+}
+
+u32 AU1_AH2_AF2(f32 a[2]) {
+    return AU1_AH1_AF1(a[0]) + (AU1_AH1_AF1(a[1]) << 16);
+}
+
+void FsrEasuCon(u32 con0[4], u32 con1[4], u32 con2[4], u32 con3[4], f32 inputViewportInPixelsX,
+                f32 inputViewportInPixelsY, f32 inputSizeInPixelsX, f32 inputSizeInPixelsY,
+                f32 outputSizeInPixelsX, f32 outputSizeInPixelsY) {
+    con0[0] = Common::BitCast<u32>(inputViewportInPixelsX / outputSizeInPixelsX);
+    con0[1] = Common::BitCast<u32>(inputViewportInPixelsY / outputSizeInPixelsY);
+    con0[2] = Common::BitCast<u32>(0.5f * inputViewportInPixelsX / outputSizeInPixelsX - 0.5f);
+    con0[3] = Common::BitCast<u32>(0.5f * inputViewportInPixelsY / outputSizeInPixelsY - 0.5f);
+    con1[0] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
+    con1[1] = Common::BitCast<u32>(1.0f / inputSizeInPixelsY);
+    con1[2] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
+    con1[3] = Common::BitCast<u32>(-1.0f / inputSizeInPixelsY);
+    con2[0] = Common::BitCast<u32>(-1.0f / inputSizeInPixelsX);
+    con2[1] = Common::BitCast<u32>(2.0f / inputSizeInPixelsY);
+    con2[2] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
+    con2[3] = Common::BitCast<u32>(2.0f / inputSizeInPixelsY);
+    con3[0] = Common::BitCast<u32>(0.0f / inputSizeInPixelsX);
+    con3[1] = Common::BitCast<u32>(4.0f / inputSizeInPixelsY);
+    con3[2] = con3[3] = 0;
+}
+} // Anonymous namespace
+
+void FsrEasuConOffset(u32 con0[4], u32 con1[4], u32 con2[4], u32 con3[4],
+                      f32 inputViewportInPixelsX, f32 inputViewportInPixelsY,
+                      f32 inputSizeInPixelsX, f32 inputSizeInPixelsY, f32 outputSizeInPixelsX,
+                      f32 outputSizeInPixelsY, f32 inputOffsetInPixelsX, f32 inputOffsetInPixelsY) {
+    FsrEasuCon(con0, con1, con2, con3, inputViewportInPixelsX, inputViewportInPixelsY,
+               inputSizeInPixelsX, inputSizeInPixelsY, outputSizeInPixelsX, outputSizeInPixelsY);
+    con0[2] = Common::BitCast<u32>(0.5f * inputViewportInPixelsX / outputSizeInPixelsX - 0.5f +
+                                   inputOffsetInPixelsX);
+    con0[3] = Common::BitCast<u32>(0.5f * inputViewportInPixelsY / outputSizeInPixelsY - 0.5f +
+                                   inputOffsetInPixelsY);
+}
+
+void FsrRcasCon(u32* con, f32 sharpness) {
+    sharpness = std::exp2f(-sharpness);
+    f32 hSharp[2]{sharpness, sharpness};
+    con[0] = Common::BitCast<u32>(sharpness);
+    con[1] = AU1_AH2_AF2(hSharp);
+    con[2] = 0;
+    con[3] = 0;
+}
+} // namespace FSR

src/video_core/fsr.h

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/bit_cast.h"
+#include "common/common_types.h"
+
+namespace FSR {
+// Reimplementations of the constant generating functions in ffx_fsr1.h
+// GCC generated a lot of warnings when using the official header.
+void FsrEasuConOffset(u32 con0[4], u32 con1[4], u32 con2[4], u32 con3[4],
+                      f32 inputViewportInPixelsX, f32 inputViewportInPixelsY,
+                      f32 inputSizeInPixelsX, f32 inputSizeInPixelsY, f32 outputSizeInPixelsX,
+                      f32 outputSizeInPixelsY, f32 inputOffsetInPixelsX, f32 inputOffsetInPixelsY);
+
+void FsrRcasCon(u32* con, f32 sharpness);
+
+} // namespace FSR

src/video_core/host_shaders/CMakeLists.txt

@@ -3,12 +3,16 @@
 
 set(FIDELITYFX_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/externals/FidelityFX-FSR/ffx-fsr)
 
-set(GLSL_INCLUDES
-    fidelityfx_fsr.comp
+set(FIDELITYFX_FILES
     ${FIDELITYFX_INCLUDE_DIR}/ffx_a.h
     ${FIDELITYFX_INCLUDE_DIR}/ffx_fsr1.h
 )
 
+set(GLSL_INCLUDES
+    fidelityfx_fsr.comp
+    ${FIDELITYFX_FILES}
+)
+
 set(SHADER_FILES
     astc_decoder.comp
     blit_color_float.frag
@@ -24,6 +28,9 @@ set(SHADER_FILES
     fxaa.vert
     opengl_convert_s8d24.comp
     opengl_copy_bc4.comp
+    opengl_fidelityfx_fsr.frag
+    opengl_fidelityfx_fsr_easu.frag
+    opengl_fidelityfx_fsr_rcas.frag
     opengl_present.frag
     opengl_present.vert
     opengl_present_scaleforce.frag
@@ -118,6 +125,25 @@ foreach(FILENAME IN ITEMS ${SHADER_FILES})
     endif()
 endforeach()
 
+foreach(FILEPATH IN ITEMS ${FIDELITYFX_FILES})
+    get_filename_component(FILENAME ${FILEPATH} NAME)
+    string(REPLACE "." "_" HEADER_NAME ${FILENAME})
+    set(SOURCE_FILE ${FILEPATH})
+    set(SOURCE_HEADER_FILE ${SHADER_DIR}/${HEADER_NAME}.h)
+    add_custom_command(
+        OUTPUT
+            ${SOURCE_HEADER_FILE}
+        COMMAND
+            ${CMAKE_COMMAND} -P ${HEADER_GENERATOR} ${SOURCE_FILE} ${SOURCE_HEADER_FILE} ${INPUT_FILE}
+        MAIN_DEPENDENCY
+            ${SOURCE_FILE}
+        DEPENDS
+            ${INPUT_FILE}
+            # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
+    )
+    set(SHADER_HEADERS ${SHADER_HEADERS} ${SOURCE_HEADER_FILE})
+endforeach()
+
 set(SHADER_SOURCES ${SHADER_FILES})
 list(APPEND SHADER_SOURCES ${GLSL_INCLUDES})
 

src/video_core/host_shaders/opengl_fidelityfx_fsr.frag

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//!#version 460 core
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+#extension GL_AMD_gpu_shader_half_float : enable
+#extension GL_NV_gpu_shader5 : enable
+
+// FidelityFX Super Resolution Sample
+//
+// Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+layout (location = 0) uniform uvec4 constants[4];
+
+#define A_GPU 1
+#define A_GLSL 1
+
+#ifdef YUZU_USE_FP16
+    #define A_HALF
+#endif
+#include "ffx_a.h"
+
+#ifndef YUZU_USE_FP16
+    layout (binding=0) uniform sampler2D InputTexture;
+    #if USE_EASU
+        #define FSR_EASU_F 1
+        AF4 FsrEasuRF(AF2 p) { AF4 res = textureGather(InputTexture, p, 0); return res; }
+        AF4 FsrEasuGF(AF2 p) { AF4 res = textureGather(InputTexture, p, 1); return res; }
+        AF4 FsrEasuBF(AF2 p) { AF4 res = textureGather(InputTexture, p, 2); return res; }
+    #endif
+    #if USE_RCAS
+        #define FSR_RCAS_F
+        AF4 FsrRcasLoadF(ASU2 p) { return texelFetch(InputTexture, ASU2(p), 0); }
+        void FsrRcasInputF(inout AF1 r, inout AF1 g, inout AF1 b) {}
+    #endif
+#else
+    layout (binding=0) uniform sampler2D InputTexture;
+    #if USE_EASU
+        #define FSR_EASU_H 1
+        AH4 FsrEasuRH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 0)); return res; }
+        AH4 FsrEasuGH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 1)); return res; }
+        AH4 FsrEasuBH(AF2 p) { AH4 res = AH4(textureGather(InputTexture, p, 2)); return res; }
+    #endif
+    #if USE_RCAS
+        #define FSR_RCAS_H
+        AH4 FsrRcasLoadH(ASW2 p) { return AH4(texelFetch(InputTexture, ASU2(p), 0)); }
+        void FsrRcasInputH(inout AH1 r,inout AH1 g,inout AH1 b){}
+    #endif
+#endif
+
+#include "ffx_fsr1.h"
+
+#if USE_RCAS
+    layout(location = 0) in vec2 frag_texcoord;
+#endif
+layout (location = 0) out vec4 frag_color;
+
+void CurrFilter(AU2 pos)
+{
+#if USE_EASU
+    #ifndef YUZU_USE_FP16
+        AF3 c;
+        FsrEasuF(c, pos, constants[0], constants[1], constants[2], constants[3]);
+        frag_color = AF4(c, 1.0);
+    #else
+        AH3 c;
+        FsrEasuH(c, pos, constants[0], constants[1], constants[2], constants[3]);
+        frag_color = AH4(c, 1.0);
+    #endif
+#endif
+#if USE_RCAS
+    #ifndef YUZU_USE_FP16
+        AF3 c;
+        FsrRcasF(c.r, c.g, c.b, pos, constants[0]);
+        frag_color = AF4(c, 1.0);
+    #else
+        AH3 c;
+        FsrRcasH(c.r, c.g, c.b, pos, constants[0]);
+        frag_color = AH4(c, 1.0);
+    #endif
+#endif
+}
+
+void main()
+{
+#if USE_RCAS
+    CurrFilter(AU2(frag_texcoord * vec2(textureSize(InputTexture, 0))));
+#else
+    CurrFilter(AU2(gl_FragCoord.xy));
+#endif
+}

src/video_core/host_shaders/opengl_fidelityfx_fsr_easu.frag

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define USE_EASU 1
+
+#include "opengl_fidelityfx_fsr.frag"

src/video_core/host_shaders/opengl_fidelityfx_fsr_rcas.frag

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#version 460 core
+#extension GL_GOOGLE_include_directive : enable
+
+#define USE_RCAS 1
+
+#include "opengl_fidelityfx_fsr.frag"

src/video_core/memory_manager.cpp

@@ -6,7 +6,6 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/settings.h"
 #include "core/core.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_page_table.h"
@@ -46,11 +45,6 @@ MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_, u64
     big_page_table_cpu.resize(big_page_table_size);
     big_page_continous.resize(big_page_table_size / continous_bits, 0);
     entries.resize(page_table_size / 32, 0);
-    if (!Settings::IsGPULevelExtreme() && Settings::IsFastmemEnabled()) {
-        fastmem_arena = system.DeviceMemory().buffer.VirtualBasePointer();
-    } else {
-        fastmem_arena = nullptr;
-    }
 }
 
 MemoryManager::~MemoryManager() = default;
@@ -360,7 +354,7 @@ inline void MemoryManager::MemoryOperation(GPUVAddr gpu_src_addr, std::size_t si
     }
 }
 
-template <bool is_safe, bool use_fastmem>
+template <bool is_safe>
 void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
                                   [[maybe_unused]] VideoCommon::CacheType which) const {
     auto set_to_zero = [&]([[maybe_unused]] std::size_t page_index,
@@ -374,12 +368,8 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
         if constexpr (is_safe) {
             rasterizer->FlushRegion(cpu_addr_base, copy_amount, which);
         }
-        if constexpr (use_fastmem) {
-            std::memcpy(dest_buffer, &fastmem_arena[cpu_addr_base], copy_amount);
-        } else {
-            u8* physical = memory.GetPointer(cpu_addr_base);
-            std::memcpy(dest_buffer, physical, copy_amount);
-        }
+        u8* physical = memory.GetPointer(cpu_addr_base);
+        std::memcpy(dest_buffer, physical, copy_amount);
         dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
     };
     auto mapped_big = [&](std::size_t page_index, std::size_t offset, std::size_t copy_amount) {
@@ -388,15 +378,11 @@ void MemoryManager::ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std:
         if constexpr (is_safe) {
             rasterizer->FlushRegion(cpu_addr_base, copy_amount, which);
         }
-        if constexpr (use_fastmem) {
-            std::memcpy(dest_buffer, &fastmem_arena[cpu_addr_base], copy_amount);
+        if (!IsBigPageContinous(page_index)) [[unlikely]] {
+            memory.ReadBlockUnsafe(cpu_addr_base, dest_buffer, copy_amount);
         } else {
-            if (!IsBigPageContinous(page_index)) [[unlikely]] {
-                memory.ReadBlockUnsafe(cpu_addr_base, dest_buffer, copy_amount);
-            } else {
-                u8* physical = memory.GetPointer(cpu_addr_base);
-                std::memcpy(dest_buffer, physical, copy_amount);
-            }
+            u8* physical = memory.GetPointer(cpu_addr_base);
+            std::memcpy(dest_buffer, physical, copy_amount);
         }
         dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
     };
@@ -410,20 +396,12 @@ 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,
                               VideoCommon::CacheType which) const {
-    if (fastmem_arena) [[likely]] {
-        ReadBlockImpl<true, true>(gpu_src_addr, dest_buffer, size, which);
-        return;
-    }
-    ReadBlockImpl<true, false>(gpu_src_addr, dest_buffer, size, which);
+    ReadBlockImpl<true>(gpu_src_addr, dest_buffer, size, which);
 }
 
 void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
                                     const std::size_t size) const {
-    if (fastmem_arena) [[likely]] {
-        ReadBlockImpl<false, true>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
-        return;
-    }
-    ReadBlockImpl<false, false>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
+    ReadBlockImpl<false>(gpu_src_addr, dest_buffer, size, VideoCommon::CacheType::None);
 }
 
 template <bool is_safe>

src/video_core/memory_manager.h

@@ -141,7 +141,7 @@ private:
     inline void MemoryOperation(GPUVAddr gpu_src_addr, std::size_t size, FuncMapped&& func_mapped,
                                 FuncReserved&& func_reserved, FuncUnmapped&& func_unmapped) const;
 
-    template <bool is_safe, bool use_fastmem>
+    template <bool is_safe>
     void ReadBlockImpl(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size,
                        VideoCommon::CacheType which) const;
 
@@ -215,7 +215,6 @@ private:
 
     std::vector<u64> big_page_continous;
     std::vector<std::pair<VAddr, std::size_t>> page_stash{};
-    u8* fastmem_arena{};
 
     constexpr static size_t continous_bits = 64;
 

src/video_core/renderer_opengl/gl_fsr.cpp

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/settings.h"
+#include "video_core/fsr.h"
+#include "video_core/renderer_opengl/gl_fsr.h"
+#include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/renderer_opengl/gl_shader_util.h"
+
+namespace OpenGL {
+using namespace FSR;
+
+using FsrConstants = std::array<u32, 4 * 4>;
+
+FSR::FSR(std::string_view fsr_vertex_source, std::string_view fsr_easu_source,
+         std::string_view fsr_rcas_source)
+    : fsr_vertex{CreateProgram(fsr_vertex_source, GL_VERTEX_SHADER)},
+      fsr_easu_frag{CreateProgram(fsr_easu_source, GL_FRAGMENT_SHADER)},
+      fsr_rcas_frag{CreateProgram(fsr_rcas_source, GL_FRAGMENT_SHADER)} {
+    glProgramUniform2f(fsr_vertex.handle, 0, 1.0f, 1.0f);
+    glProgramUniform2f(fsr_vertex.handle, 1, 0.0f, 0.0f);
+}
+
+FSR::~FSR() = default;
+
+void FSR::Draw(ProgramManager& program_manager, const Common::Rectangle<u32>& screen,
+               u32 input_image_width, u32 input_image_height,
+               const Common::Rectangle<int>& crop_rect) {
+
+    const auto output_image_width = screen.GetWidth();
+    const auto output_image_height = screen.GetHeight();
+
+    if (fsr_intermediate_tex.handle) {
+        GLint fsr_tex_width, fsr_tex_height;
+        glGetTextureLevelParameteriv(fsr_intermediate_tex.handle, 0, GL_TEXTURE_WIDTH,
+                                     &fsr_tex_width);
+        glGetTextureLevelParameteriv(fsr_intermediate_tex.handle, 0, GL_TEXTURE_HEIGHT,
+                                     &fsr_tex_height);
+        if (static_cast<u32>(fsr_tex_width) != output_image_width ||
+            static_cast<u32>(fsr_tex_height) != output_image_height) {
+            fsr_intermediate_tex.Release();
+        }
+    }
+    if (!fsr_intermediate_tex.handle) {
+        fsr_intermediate_tex.Create(GL_TEXTURE_2D);
+        glTextureStorage2D(fsr_intermediate_tex.handle, 1, GL_RGB16F, output_image_width,
+                           output_image_height);
+        glNamedFramebufferTexture(fsr_framebuffer.handle, GL_COLOR_ATTACHMENT0,
+                                  fsr_intermediate_tex.handle, 0);
+    }
+
+    GLint old_draw_fb;
+    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_fb);
+
+    glFrontFace(GL_CW);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fsr_framebuffer.handle);
+    glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(output_image_width),
+                       static_cast<GLfloat>(output_image_height));
+
+    FsrConstants constants;
+    FsrEasuConOffset(
+        constants.data() + 0, constants.data() + 4, constants.data() + 8, constants.data() + 12,
+
+        static_cast<f32>(crop_rect.GetWidth()), static_cast<f32>(crop_rect.GetHeight()),
+        static_cast<f32>(input_image_width), static_cast<f32>(input_image_height),
+        static_cast<f32>(output_image_width), static_cast<f32>(output_image_height),
+        static_cast<f32>(crop_rect.left), static_cast<f32>(crop_rect.top));
+
+    glProgramUniform4uiv(fsr_easu_frag.handle, 0, sizeof(constants), std::data(constants));
+
+    program_manager.BindPresentPrograms(fsr_vertex.handle, fsr_easu_frag.handle);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_fb);
+    glBindTextureUnit(0, fsr_intermediate_tex.handle);
+
+    const float sharpening =
+        static_cast<float>(Settings::values.fsr_sharpening_slider.GetValue()) / 100.0f;
+
+    FsrRcasCon(constants.data(), sharpening);
+    glProgramUniform4uiv(fsr_rcas_frag.handle, 0, sizeof(constants), std::data(constants));
+}
+
+void FSR::InitBuffers() {
+    fsr_framebuffer.Create();
+}
+
+void FSR::ReleaseBuffers() {
+    fsr_framebuffer.Release();
+    fsr_intermediate_tex.Release();
+}
+
+const OGLProgram& FSR::GetPresentFragmentProgram() const noexcept {
+    return fsr_rcas_frag;
+}
+
+bool FSR::AreBuffersInitialized() const noexcept {
+    return fsr_framebuffer.handle;
+}
+
+} // namespace OpenGL

src/video_core/renderer_opengl/gl_fsr.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string_view>
+
+#include "common/common_types.h"
+#include "common/math_util.h"
+#include "video_core/fsr.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+
+namespace OpenGL {
+
+class ProgramManager;
+
+class FSR {
+public:
+    explicit FSR(std::string_view fsr_vertex_source, std::string_view fsr_easu_source,
+                 std::string_view fsr_rcas_source);
+    ~FSR();
+
+    void Draw(ProgramManager& program_manager, const Common::Rectangle<u32>& screen,
+              u32 input_image_width, u32 input_image_height,
+              const Common::Rectangle<int>& crop_rect);
+
+    void InitBuffers();
+
+    void ReleaseBuffers();
+
+    [[nodiscard]] const OGLProgram& GetPresentFragmentProgram() const noexcept;
+
+    [[nodiscard]] bool AreBuffersInitialized() const noexcept;
+
+private:
+    OGLFramebuffer fsr_framebuffer;
+    OGLProgram fsr_vertex;
+    OGLProgram fsr_easu_frag;
+    OGLProgram fsr_rcas_frag;
+    OGLTexture fsr_intermediate_tex;
+};
+
+} // namespace OpenGL

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -17,8 +17,14 @@
 #include "core/frontend/emu_window.h"
 #include "core/memory.h"
 #include "core/telemetry_session.h"
+#include "video_core/host_shaders/ffx_a_h.h"
+#include "video_core/host_shaders/ffx_fsr1_h.h"
+#include "video_core/host_shaders/full_screen_triangle_vert.h"
 #include "video_core/host_shaders/fxaa_frag.h"
 #include "video_core/host_shaders/fxaa_vert.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_easu_frag.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_frag.h"
+#include "video_core/host_shaders/opengl_fidelityfx_fsr_rcas_frag.h"
 #include "video_core/host_shaders/opengl_present_frag.h"
 #include "video_core/host_shaders/opengl_present_scaleforce_frag.h"
 #include "video_core/host_shaders/opengl_present_vert.h"
@@ -31,6 +37,7 @@
 #include "video_core/host_shaders/smaa_edge_detection_vert.h"
 #include "video_core/host_shaders/smaa_neighborhood_blending_frag.h"
 #include "video_core/host_shaders/smaa_neighborhood_blending_vert.h"
+#include "video_core/renderer_opengl/gl_fsr.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
@@ -268,12 +275,17 @@ void RendererOpenGL::InitOpenGLObjects() {
     fxaa_vertex = CreateProgram(HostShaders::FXAA_VERT, GL_VERTEX_SHADER);
     fxaa_fragment = CreateProgram(HostShaders::FXAA_FRAG, GL_FRAGMENT_SHADER);
 
-    const auto SmaaShader = [](std::string_view specialized_source, GLenum stage) {
-        std::string shader_source{specialized_source};
-        constexpr std::string_view include_string = "#include \"opengl_smaa.glsl\"";
+    const auto replace_include = [](std::string& shader_source, std::string_view include_name,
+                                    std::string_view include_content) {
+        const std::string include_string = fmt::format("#include \"{}\"", include_name);
         const std::size_t pos = shader_source.find(include_string);
         ASSERT(pos != std::string::npos);
-        shader_source.replace(pos, include_string.size(), HostShaders::OPENGL_SMAA_GLSL);
+        shader_source.replace(pos, include_string.size(), include_content);
+    };
+
+    const auto SmaaShader = [&](std::string_view specialized_source, GLenum stage) {
+        std::string shader_source{specialized_source};
+        replace_include(shader_source, "opengl_smaa.glsl", HostShaders::OPENGL_SMAA_GLSL);
         return CreateProgram(shader_source, stage);
     };
 
@@ -298,14 +310,32 @@ void RendererOpenGL::InitOpenGLObjects() {
         CreateProgram(fmt::format("#version 460\n{}", HostShaders::OPENGL_PRESENT_SCALEFORCE_FRAG),
                       GL_FRAGMENT_SHADER);
 
+    std::string fsr_source{HostShaders::OPENGL_FIDELITYFX_FSR_FRAG};
+    replace_include(fsr_source, "ffx_a.h", HostShaders::FFX_A_H);
+    replace_include(fsr_source, "ffx_fsr1.h", HostShaders::FFX_FSR1_H);
+
+    std::string fsr_easu_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_EASU_FRAG};
+    std::string fsr_rcas_frag_source{HostShaders::OPENGL_FIDELITYFX_FSR_RCAS_FRAG};
+    replace_include(fsr_easu_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source);
+    replace_include(fsr_rcas_frag_source, "opengl_fidelityfx_fsr.frag", fsr_source);
+
+    fsr = std::make_unique<FSR>(HostShaders::FULL_SCREEN_TRIANGLE_VERT, fsr_easu_frag_source,
+                                fsr_rcas_frag_source);
+
     // Generate presentation sampler
     present_sampler.Create();
     glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glSamplerParameteri(present_sampler.handle, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(present_sampler.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 
     present_sampler_nn.Create();
     glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glSamplerParameteri(present_sampler_nn.handle, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 
     // Generate VBO handle for drawing
     vertex_buffer.Create();
@@ -525,6 +555,31 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
 
         glBindTextureUnit(0, aa_texture.handle);
     }
+    glDisablei(GL_SCISSOR_TEST, 0);
+
+    if (Settings::values.scaling_filter.GetValue() == Settings::ScalingFilter::Fsr) {
+        if (!fsr->AreBuffersInitialized()) {
+            fsr->InitBuffers();
+        }
+
+        auto crop_rect = framebuffer_crop_rect;
+        if (crop_rect.GetWidth() == 0) {
+            crop_rect.right = framebuffer_width;
+        }
+        if (crop_rect.GetHeight() == 0) {
+            crop_rect.bottom = framebuffer_height;
+        }
+        crop_rect = crop_rect.Scale(Settings::values.resolution_info.up_factor);
+        const auto fsr_input_width = Settings::values.resolution_info.ScaleUp(framebuffer_width);
+        const auto fsr_input_height = Settings::values.resolution_info.ScaleUp(framebuffer_height);
+        glBindSampler(0, present_sampler.handle);
+        fsr->Draw(program_manager, layout.screen, fsr_input_width, fsr_input_height, crop_rect);
+    } else {
+        if (fsr->AreBuffersInitialized()) {
+            fsr->ReleaseBuffers();
+        }
+    }
+
     const std::array ortho_matrix =
         MakeOrthographicMatrix(static_cast<float>(layout.width), static_cast<float>(layout.height));
 
@@ -540,10 +595,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
         case Settings::ScalingFilter::ScaleForce:
             return present_scaleforce_fragment.handle;
         case Settings::ScalingFilter::Fsr:
-            LOG_WARNING(
-                Render_OpenGL,
-                "FidelityFX Super Resolution is not supported in OpenGL, changing to ScaleForce");
-            return present_scaleforce_fragment.handle;
+            return fsr->GetPresentFragmentProgram().handle;
         default:
             return present_bilinear_fragment.handle;
         }
@@ -578,15 +630,18 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
     f32 scale_u = static_cast<f32>(framebuffer_width) / static_cast<f32>(screen_info.texture.width);
     f32 scale_v =
         static_cast<f32>(framebuffer_height) / static_cast<f32>(screen_info.texture.height);
-    // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
-    // (e.g. handheld mode) on a 1920x1080 framebuffer.
-    if (framebuffer_crop_rect.GetWidth() > 0) {
-        scale_u = static_cast<f32>(framebuffer_crop_rect.GetWidth()) /
-                  static_cast<f32>(screen_info.texture.width);
-    }
-    if (framebuffer_crop_rect.GetHeight() > 0) {
-        scale_v = static_cast<f32>(framebuffer_crop_rect.GetHeight()) /
-                  static_cast<f32>(screen_info.texture.height);
+
+    if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::Fsr) {
+        // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
+        // (e.g. handheld mode) on a 1920x1080 framebuffer.
+        if (framebuffer_crop_rect.GetWidth() > 0) {
+            scale_u = static_cast<f32>(framebuffer_crop_rect.GetWidth()) /
+                      static_cast<f32>(screen_info.texture.width);
+        }
+        if (framebuffer_crop_rect.GetHeight() > 0) {
+            scale_v = static_cast<f32>(framebuffer_crop_rect.GetHeight()) /
+                      static_cast<f32>(screen_info.texture.height);
+        }
     }
     if (Settings::values.anti_aliasing.GetValue() == Settings::AntiAliasing::Fxaa &&
         !screen_info.was_accelerated) {
@@ -612,7 +667,6 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
     } else {
         glDisable(GL_FRAMEBUFFER_SRGB);
     }
-    glDisablei(GL_SCISSOR_TEST, 0);
     glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width),
                        static_cast<GLfloat>(layout.height));
 

src/video_core/renderer_opengl/renderer_opengl.h

@@ -10,6 +10,7 @@
 
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/gl_device.h"
+#include "video_core/renderer_opengl/gl_fsr.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
@@ -141,6 +142,8 @@ private:
     OGLTexture smaa_edges_tex;
     OGLTexture smaa_blend_tex;
 
+    std::unique_ptr<FSR> fsr;
+
     /// OpenGL framebuffer data
     std::vector<u8> gl_framebuffer_data;
 

src/video_core/renderer_vulkan/vk_fsr.cpp

@@ -1,12 +1,11 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <cmath>
-#include "common/bit_cast.h"
 #include "common/common_types.h"
 #include "common/div_ceil.h"
 #include "common/settings.h"
 
+#include "video_core/fsr.h"
 #include "video_core/host_shaders/vulkan_fidelityfx_fsr_easu_fp16_comp_spv.h"
 #include "video_core/host_shaders/vulkan_fidelityfx_fsr_easu_fp32_comp_spv.h"
 #include "video_core/host_shaders/vulkan_fidelityfx_fsr_rcas_fp16_comp_spv.h"
@@ -17,146 +16,7 @@
 #include "video_core/vulkan_common/vulkan_device.h"
 
 namespace Vulkan {
-namespace {
-// Reimplementations of the constant generating functions in ffx_fsr1.h
-// GCC generated a lot of warnings when using the official header.
-u32 AU1_AH1_AF1(f32 f) {
-    static constexpr u32 base[512]{
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040,
-        0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x0c00, 0x1000, 0x1400, 0x1800, 0x1c00, 0x2000,
-        0x2400, 0x2800, 0x2c00, 0x3000, 0x3400, 0x3800, 0x3c00, 0x4000, 0x4400, 0x4800, 0x4c00,
-        0x5000, 0x5400, 0x5800, 0x5c00, 0x6000, 0x6400, 0x6800, 0x6c00, 0x7000, 0x7400, 0x7800,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008,
-        0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 0x8200, 0x8400, 0x8800, 0x8c00, 0x9000, 0x9400,
-        0x9800, 0x9c00, 0xa000, 0xa400, 0xa800, 0xac00, 0xb000, 0xb400, 0xb800, 0xbc00, 0xc000,
-        0xc400, 0xc800, 0xcc00, 0xd000, 0xd400, 0xd800, 0xdc00, 0xe000, 0xe400, 0xe800, 0xec00,
-        0xf000, 0xf400, 0xf800, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-    };
-    static constexpr s8 shift[512]{
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x16,
-        0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17,
-        0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18,
-    };
-    const u32 u = Common::BitCast<u32>(f);
-    const u32 i = u >> 23;
-    return base[i] + ((u & 0x7fffff) >> shift[i]);
-}
-
-u32 AU1_AH2_AF2(f32 a[2]) {
-    return AU1_AH1_AF1(a[0]) + (AU1_AH1_AF1(a[1]) << 16);
-}
-
-void FsrEasuCon(u32 con0[4], u32 con1[4], u32 con2[4], u32 con3[4], f32 inputViewportInPixelsX,
-                f32 inputViewportInPixelsY, f32 inputSizeInPixelsX, f32 inputSizeInPixelsY,
-                f32 outputSizeInPixelsX, f32 outputSizeInPixelsY) {
-    con0[0] = Common::BitCast<u32>(inputViewportInPixelsX / outputSizeInPixelsX);
-    con0[1] = Common::BitCast<u32>(inputViewportInPixelsY / outputSizeInPixelsY);
-    con0[2] = Common::BitCast<u32>(0.5f * inputViewportInPixelsX / outputSizeInPixelsX - 0.5f);
-    con0[3] = Common::BitCast<u32>(0.5f * inputViewportInPixelsY / outputSizeInPixelsY - 0.5f);
-    con1[0] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
-    con1[1] = Common::BitCast<u32>(1.0f / inputSizeInPixelsY);
-    con1[2] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
-    con1[3] = Common::BitCast<u32>(-1.0f / inputSizeInPixelsY);
-    con2[0] = Common::BitCast<u32>(-1.0f / inputSizeInPixelsX);
-    con2[1] = Common::BitCast<u32>(2.0f / inputSizeInPixelsY);
-    con2[2] = Common::BitCast<u32>(1.0f / inputSizeInPixelsX);
-    con2[3] = Common::BitCast<u32>(2.0f / inputSizeInPixelsY);
-    con3[0] = Common::BitCast<u32>(0.0f / inputSizeInPixelsX);
-    con3[1] = Common::BitCast<u32>(4.0f / inputSizeInPixelsY);
-    con3[2] = con3[3] = 0;
-}
-
-void FsrEasuConOffset(u32 con0[4], u32 con1[4], u32 con2[4], u32 con3[4],
-                      f32 inputViewportInPixelsX, f32 inputViewportInPixelsY,
-                      f32 inputSizeInPixelsX, f32 inputSizeInPixelsY, f32 outputSizeInPixelsX,
-                      f32 outputSizeInPixelsY, f32 inputOffsetInPixelsX, f32 inputOffsetInPixelsY) {
-    FsrEasuCon(con0, con1, con2, con3, inputViewportInPixelsX, inputViewportInPixelsY,
-               inputSizeInPixelsX, inputSizeInPixelsY, outputSizeInPixelsX, outputSizeInPixelsY);
-    con0[2] = Common::BitCast<u32>(0.5f * inputViewportInPixelsX / outputSizeInPixelsX - 0.5f +
-                                   inputOffsetInPixelsX);
-    con0[3] = Common::BitCast<u32>(0.5f * inputViewportInPixelsY / outputSizeInPixelsY - 0.5f +
-                                   inputOffsetInPixelsY);
-}
-
-void FsrRcasCon(u32* con, f32 sharpness) {
-    sharpness = std::exp2f(-sharpness);
-    f32 hSharp[2]{sharpness, sharpness};
-    con[0] = Common::BitCast<u32>(sharpness);
-    con[1] = AU1_AH2_AF2(hSharp);
-    con[2] = 0;
-    con[3] = 0;
-}
-} // Anonymous namespace
+using namespace FSR;
 
 FSR::FSR(const Device& device_, MemoryAllocator& memory_allocator_, size_t image_count_,
          VkExtent2D output_size_)

src/yuzu/configuration/configure_dialog.cpp

@@ -66,7 +66,6 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_,
 
     web_tab->SetWebServiceConfigEnabled(enable_web_config);
     hotkeys_tab->Populate(registry);
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     input_tab->Initialize(input_subsystem);
 

src/yuzu/configuration/configure_graphics.ui

@@ -460,7 +460,7 @@
              </item>
              <item>
               <property name="text">
-               <string>AMD FidelityFX™️ Super Resolution (Vulkan Only)</string>
+               <string>AMD FidelityFX™️ Super Resolution</string>
               </property>
              </item>
             </widget>

src/yuzu/configuration/configure_motion_touch.cpp

@@ -89,7 +89,6 @@ ConfigureMotionTouch::ConfigureMotionTouch(QWidget* parent,
            "using-a-controller-or-android-phone-for-motion-or-touch-input'><span "
            "style=\"text-decoration: underline; color:#039be5;\">Learn More</span></a>"));
 
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
     SetConfiguration();
     UpdateUiDisplay();
     ConnectEvents();

src/yuzu/configuration/configure_per_game.cpp

@@ -66,8 +66,6 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const std::st
 
     setFocusPolicy(Qt::ClickFocus);
     setWindowTitle(tr("Properties"));
-    // remove Help question mark button from the title bar
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     addons_tab->SetTitleId(title_id);
 

src/yuzu/configuration/configure_tas.cpp

@@ -17,7 +17,6 @@ ConfigureTasDialog::ConfigureTasDialog(QWidget* parent)
 
     setFocusPolicy(Qt::ClickFocus);
     setWindowTitle(tr("TAS Configuration"));
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     connect(ui->tas_path_button, &QToolButton::pressed, this,
             [this] { SetDirectory(DirectoryTarget::TAS, ui->tas_path_edit); });

src/yuzu/debugger/controller.cpp

@@ -20,9 +20,8 @@ ControllerDialog::ControllerDialog(Core::HID::HIDCore& hid_core_,
     setWindowTitle(tr("Controller P1"));
     resize(500, 350);
     setMinimumSize(500, 350);
-    // Remove the "?" button from the titlebar and enable the maximize button
-    setWindowFlags((windowFlags() & ~Qt::WindowContextHelpButtonHint) |
-                   Qt::WindowMaximizeButtonHint);
+    // Enable the maximize button
+    setWindowFlags(windowFlags() | Qt::WindowMaximizeButtonHint);
 
     widget = new PlayerControlPreview(this);
     refreshConfiguration();

src/yuzu/debugger/profiler.cpp

@@ -49,9 +49,8 @@ MicroProfileDialog::MicroProfileDialog(QWidget* parent) : QWidget(parent, Qt::Di
     setObjectName(QStringLiteral("MicroProfile"));
     setWindowTitle(tr("&MicroProfile"));
     resize(1000, 600);
-    // Remove the "?" button from the titlebar and enable the maximize button
-    setWindowFlags((windowFlags() & ~Qt::WindowContextHelpButtonHint) |
-                   Qt::WindowMaximizeButtonHint);
+    // Enable the maximize button
+    setWindowFlags(windowFlags() | Qt::WindowMaximizeButtonHint);
 
 #if MICROPROFILE_ENABLED
 

src/yuzu/install_dialog.cpp

@@ -46,7 +46,6 @@ InstallDialog::InstallDialog(QWidget* parent, const QStringList& files) : QDialo
     vbox_layout->addLayout(hbox_layout);
 
     setLayout(vbox_layout);
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
     setWindowTitle(tr("Install Files to NAND"));
 }
 

src/yuzu/main.cpp

@@ -983,11 +983,6 @@ void GMainWindow::InitializeWidgets() {
     filter_status_button->setFocusPolicy(Qt::NoFocus);
     connect(filter_status_button, &QPushButton::clicked, this,
             &GMainWindow::OnToggleAdaptingFilter);
-    auto filter = Settings::values.scaling_filter.GetValue();
-    if (Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::OpenGL &&
-        filter == Settings::ScalingFilter::Fsr) {
-        Settings::values.scaling_filter.SetValue(Settings::ScalingFilter::NearestNeighbor);
-    }
     UpdateFilterText();
     filter_status_button->setCheckable(true);
     filter_status_button->setChecked(true);
@@ -2758,8 +2753,7 @@ void GMainWindow::OnMenuInstallToNAND() {
     ui->action_Install_File_NAND->setEnabled(false);
 
     install_progress = new QProgressDialog(QString{}, tr("Cancel"), 0, total_size, this);
-    install_progress->setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint &
-                                     ~Qt::WindowMaximizeButtonHint);
+    install_progress->setWindowFlags(windowFlags() & ~Qt::WindowMaximizeButtonHint);
     install_progress->setAttribute(Qt::WA_DeleteOnClose, true);
     install_progress->setFixedWidth(installDialog.GetMinimumWidth() + 40);
     install_progress->show();
@@ -3469,10 +3463,6 @@ void GMainWindow::OnToggleAdaptingFilter() {
     } else {
         filter = static_cast<Settings::ScalingFilter>(static_cast<u32>(filter) + 1);
     }
-    if (Settings::values.renderer_backend.GetValue() == Settings::RendererBackend::OpenGL &&
-        filter == Settings::ScalingFilter::Fsr) {
-        filter = Settings::ScalingFilter::NearestNeighbor;
-    }
     Settings::values.scaling_filter.SetValue(filter);
     filter_status_button->setChecked(true);
     UpdateFilterText();
@@ -4456,6 +4446,11 @@ int main(int argc, char* argv[]) {
     }
 #endif
 
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    // Disables the "?" button on all dialogs. Disabled by default on Qt6.
+    QCoreApplication::setAttribute(Qt::AA_DisableWindowContextHelpButton);
+#endif
+
     // Enables the core to make the qt created contexts current on std::threads
     QCoreApplication::setAttribute(Qt::AA_DontCheckOpenGLContextThreadAffinity);
     QApplication app(argc, argv);

src/yuzu/multiplayer/direct_connect.cpp

@@ -81,20 +81,13 @@ void DirectConnectWindow::Connect() {
             }
         }
     }
-    switch (static_cast<ConnectionType>(ui->connection_type->currentIndex())) {
-    case ConnectionType::TraversalServer:
-        break;
-    case ConnectionType::IP:
-        if (!ui->ip->hasAcceptableInput()) {
-            NetworkMessage::ErrorManager::ShowError(
-                NetworkMessage::ErrorManager::IP_ADDRESS_NOT_VALID);
-            return;
-        }
-        if (!ui->port->hasAcceptableInput()) {
-            NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::PORT_NOT_VALID);
-            return;
-        }
-        break;
+    if (!ui->ip->hasAcceptableInput()) {
+        NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::IP_ADDRESS_NOT_VALID);
+        return;
+    }
+    if (!ui->port->hasAcceptableInput()) {
+        NetworkMessage::ErrorManager::ShowError(NetworkMessage::ErrorManager::PORT_NOT_VALID);
+        return;
     }
 
     // Store settings

src/yuzu/multiplayer/direct_connect.ui

@@ -26,20 +26,11 @@
          <property name="leftMargin">
           <number>0</number>
          </property>
-         <item>
-          <widget class="QComboBox" name="connection_type">
-           <item>
-            <property name="text">
-             <string>IP Address</string>
-            </property>
-           </item>
-          </widget>
-         </item>
          <item>
           <widget class="QWidget" name="ip_container" native="true">
            <layout class="QHBoxLayout" name="ip_layout">
             <property name="leftMargin">
-             <number>5</number>
+             <number>0</number>
             </property>
             <property name="topMargin">
              <number>0</number>
@@ -53,17 +44,17 @@
             <item>
              <widget class="QLabel" name="label_2">
               <property name="text">
-               <string>IP</string>
+               <string>Server Address</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QLineEdit" name="ip">
               <property name="toolTip">
-               <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;IPv4 address of the host&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+               <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Server address of the host&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
               </property>
               <property name="maxLength">
-               <number>16</number>
+               <number>253</number>
               </property>
              </widget>
             </item>
@@ -85,6 +76,12 @@
               <property name="placeholderText">
                <string notr="true" extracomment="placeholder string that tells user default port">24872</string>
               </property>
+              <property name="maximumSize">
+               <size>
+                <width>65</width>
+                <height>50</height>
+               </size>
+              </property>
              </widget>
             </item>
            </layout>

src/yuzu/multiplayer/validation.h

@@ -38,11 +38,28 @@ private:
         QRegularExpression(QStringLiteral("^[a-zA-Z0-9._ -]{4,20}"));
     QRegularExpressionValidator nickname;
 
-    /// ipv4 address only
-    // TODO remove this when we support hostnames in direct connect
+    /// ipv4 / ipv6 / hostnames
     QRegularExpression ip_regex = QRegularExpression(QStringLiteral(
-        "(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|"
-        "2[0-4][0-9]|25[0-5])"));
+        // IPv4 regex
+        "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|"
+        // IPv6 regex
+        "^((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|"
+        "(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-"
+        "5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|"
+        "(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)"
+        "(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|"
+        "(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]"
+        "\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|"
+        "(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2["
+        "0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|"
+        "(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2["
+        "0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|"
+        "(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2["
+        "0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|"
+        "(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?"
+        "\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?$|"
+        // Hostname regex
+        "^([a-zA-Z0-9]+(-[a-zA-Z0-9]+)*\\.)+[a-zA-Z]{2,}$"));
     QRegularExpressionValidator ip;
 
     /// port must be between 0 and 65535

src/yuzu/util/limitable_input_dialog.cpp

@@ -16,8 +16,6 @@ LimitableInputDialog::LimitableInputDialog(QWidget* parent) : QDialog{parent} {
 LimitableInputDialog::~LimitableInputDialog() = default;
 
 void LimitableInputDialog::CreateUI() {
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
-
     text_label = new QLabel(this);
     text_entry = new QLineEdit(this);
     text_label_invalid = new QLabel(this);

src/yuzu/util/sequence_dialog/sequence_dialog.cpp

@@ -8,7 +8,6 @@
 
 SequenceDialog::SequenceDialog(QWidget* parent) : QDialog(parent) {
     setWindowTitle(tr("Enter a hotkey"));
-    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
     key_sequence = new QKeySequenceEdit;
 

src/yuzu_cmd/default_ini.h

@@ -5,8 +5,8 @@
 
 namespace DefaultINI {
 
-const char* sdl2_config_file = R"(
-
+const char* sdl2_config_file =
+    R"(
 [ControlsP0]
 # The input devices and parameters for each Switch native input
 # The config section determines the player number where the config will be applied on. For example "ControlsP0", "ControlsP1", ...
@@ -143,6 +143,8 @@ mouse_enabled =
 # 0 (default): Disabled, 1: Enabled
 keyboard_enabled =
 
+)"
+    R"(
 [Core]
 # Whether to use multi-core for CPU emulation
 # 0: Disabled, 1 (default): Enabled
@@ -242,6 +244,8 @@ cpuopt_unsafe_fastmem_check =
 # 0: Disabled, 1 (default): Enabled
 cpuopt_unsafe_ignore_global_monitor =
 
+)"
+    R"(
 [Renderer]
 # Which backend API to use.
 # 0: OpenGL, 1 (default): Vulkan
@@ -360,6 +364,8 @@ bg_red =
 bg_blue =
 bg_green =
 
+)"
+    R"(
 [Audio]
 # Which audio output engine to use.
 # auto (default): Auto-select