renderer_opengl: Only log warnings when graphics debugging is enabled

This reduces noise in the log and it may increase performance on some
games where warnings are spammed.

.ci/scripts/linux/docker.sh

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_VULKAN=No
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
 
 ninja
 

.ci/scripts/windows/docker.sh

@@ -13,7 +13,7 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_VULKAN=No
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja
 
 # Clean up the dirty hacks
@@ -29,7 +29,13 @@ echo 'Prepare binaries...'
 cd ..
 mkdir package
 
-QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
+if [ -d "/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/" ]; then
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
+else
+  #fallback to qt
+  QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt/plugins/platforms/'
+fi
+
 find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
 
 # copy Qt plugins

CMakeModules/MinGWCross.cmake

@@ -10,8 +10,8 @@ set(SDL2_PATH                       ${MINGW_PREFIX})
 set(MINGW_TOOL_PREFIX               ${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-)
 
 # Specify the cross compiler
-set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}gcc-posix)
-set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}g++-posix)
+set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}gcc)
+set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}g++)
 set(CMAKE_RC_COMPILER           ${MINGW_TOOL_PREFIX}windres)
 
 # Mingw tools

src/common/uuid.h

@@ -40,6 +40,11 @@ struct UUID {
         uuid = INVALID_UUID;
     }
 
+    // TODO(ogniK): Properly generate a Nintendo ID
+    constexpr u64 GetNintendoID() const {
+        return uuid[0];
+    }
+
     std::string Format() const;
     std::string FormatSwitch() const;
 };

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -185,10 +185,9 @@ void ARM_Dynarmic_64::Step() {
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, ExclusiveMonitor& exclusive_monitor,
                                  std::size_t core_index)
-    : ARM_Interface{system},
-      cb(std::make_unique<DynarmicCallbacks64>(*this)), inner_unicorn{system},
-      core_index{core_index}, exclusive_monitor{
-                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
+    : ARM_Interface{system}, cb(std::make_unique<DynarmicCallbacks64>(*this)),
+      inner_unicorn{system, ARM_Unicorn::Arch::AArch64}, core_index{core_index},
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
 
 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;
 

src/core/arm/unicorn/arm_unicorn.cpp

@@ -62,8 +62,9 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
     return false;
 }
 
-ARM_Unicorn::ARM_Unicorn(System& system) : ARM_Interface{system} {
-    CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc));
+ARM_Unicorn::ARM_Unicorn(System& system, Arch architecture) : ARM_Interface{system} {
+    const auto arch = architecture == Arch::AArch32 ? UC_ARCH_ARM : UC_ARCH_ARM64;
+    CHECKED(uc_open(arch, UC_MODE_ARM, &uc));
 
     auto fpv = 3 << 20;
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_CPACR_EL1, &fpv));

src/core/arm/unicorn/arm_unicorn.h

@@ -15,7 +15,12 @@ class System;
 
 class ARM_Unicorn final : public ARM_Interface {
 public:
-    explicit ARM_Unicorn(System& system);
+    enum class Arch {
+        AArch32, // 32-bit ARM
+        AArch64, // 64-bit ARM
+    };
+
+    explicit ARM_Unicorn(System& system, Arch architecture);
     ~ARM_Unicorn() override;
 
     void SetPC(u64 pc) override;

src/core/hle/kernel/handle_table.cpp

@@ -30,6 +30,7 @@ HandleTable::~HandleTable() = default;
 
 ResultCode HandleTable::SetSize(s32 handle_table_size) {
     if (static_cast<u32>(handle_table_size) > MAX_COUNT) {
+        LOG_ERROR(Kernel, "Handle table size {} is greater than {}", handle_table_size, MAX_COUNT);
         return ERR_OUT_OF_MEMORY;
     }
 
@@ -80,6 +81,7 @@ ResultVal<Handle> HandleTable::Duplicate(Handle handle) {
 
 ResultCode HandleTable::Close(Handle handle) {
     if (!IsValid(handle)) {
+        LOG_ERROR(Kernel, "Handle is not valid! handle={:08X}", handle);
         return ERR_INVALID_HANDLE;
     }
 

src/core/hle/kernel/hle_ipc.cpp

@@ -13,7 +13,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
@@ -57,7 +56,6 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
             return true;
         });
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event) {
         // Create event if not provided
         const auto pair = WritableEvent::CreateEventPair(kernel, "HLE Pause Event: " + reason);
@@ -79,9 +77,11 @@ std::shared_ptr<WritableEvent> HLERequestContext::SleepClientThread(
     return writable_event;
 }
 
-HLERequestContext::HLERequestContext(std::shared_ptr<Kernel::ServerSession> server_session,
+HLERequestContext::HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
+                                     std::shared_ptr<ServerSession> server_session,
                                      std::shared_ptr<Thread> thread)
-    : server_session(std::move(server_session)), thread(std::move(thread)) {
+    : server_session(std::move(server_session)),
+      thread(std::move(thread)), kernel{kernel}, memory{memory} {
     cmd_buf[0] = 0;
 }
 
@@ -216,7 +216,6 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const HandleTabl
 ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     auto& owner_process = *thread.GetOwnerProcess();
     auto& handle_table = owner_process.GetHandleTable();
-    auto& memory = Core::System::GetInstance().Memory();
 
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
     memory.ReadBlock(owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
@@ -286,7 +285,6 @@ std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
     std::vector<u8> buffer;
     const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                            BufferDescriptorA()[buffer_index].Size()};
-    auto& memory = Core::System::GetInstance().Memory();
 
     if (is_buffer_a) {
         ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
@@ -319,7 +317,6 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
         size = buffer_size; // TODO(bunnei): This needs to be HW tested
     }
 
-    auto& memory = Core::System::GetInstance().Memory();
     if (is_buffer_b) {
         ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
                    "BufferDescriptorB invalid buffer_index {}", buffer_index);

src/core/hle/kernel/hle_ipc.h

@@ -19,6 +19,10 @@
 
 union ResultCode;
 
+namespace Core::Memory {
+class Memory;
+}
+
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -28,6 +32,7 @@ namespace Kernel {
 class Domain;
 class HandleTable;
 class HLERequestContext;
+class KernelCore;
 class Process;
 class ServerSession;
 class Thread;
@@ -98,7 +103,8 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(std::shared_ptr<ServerSession> session,
+    explicit HLERequestContext(KernelCore& kernel, Core::Memory::Memory& memory,
+                               std::shared_ptr<ServerSession> session,
                                std::shared_ptr<Thread> thread);
     ~HLERequestContext();
 
@@ -305,6 +311,9 @@ private:
 
     std::vector<std::shared_ptr<SessionRequestHandler>> domain_request_handlers;
     bool is_thread_waiting{};
+
+    KernelCore& kernel;
+    Core::Memory::Memory& memory;
 };
 
 } // namespace Kernel

src/core/hle/kernel/memory/address_space_info.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #include <array>
 
@@ -49,18 +49,18 @@ constexpr bool IsAllowedIndexForAddress(std::size_t index) {
     return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid;
 }
 
-constexpr std::size_t
-    AddressSpaceIndices32Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices32Bit{
         0, 1, 0, 2, 0, 3,
     };
 
-constexpr std::size_t
-    AddressSpaceIndices36Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices36Bit{
         4, 5, 4, 6, 4, 7,
     };
 
-constexpr std::size_t
-    AddressSpaceIndices39Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
+constexpr std::array<std::size_t, static_cast<std::size_t>(AddressSpaceInfo::Type::Count)>
+    AddressSpaceIndices39Bit{
         9, 8, 8, 10, 12, 11,
     };
 

src/core/hle/kernel/memory/address_space_info.h

@@ -2,12 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {

src/core/hle/kernel/memory/memory_block.h

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/memory_block_manager.cpp

@@ -67,7 +67,6 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p
                                 MemoryPermission prev_perm, MemoryAttribute prev_attribute,
                                 MemoryState state, MemoryPermission perm,
                                 MemoryAttribute attribute) {
-    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 
@@ -109,7 +108,6 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState p
 
 void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState state,
                                 MemoryPermission perm, MemoryAttribute attribute) {
-    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 
@@ -145,7 +143,6 @@ void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState s
 
 void MemoryBlockManager::UpdateLock(VAddr addr, std::size_t num_pages, LockFunc&& lock_func,
                                     MemoryPermission perm) {
-    const std::size_t prev_count{memory_block_tree.size()};
     const VAddr end_addr{addr + num_pages * PageSize};
     iterator node{memory_block_tree.begin()};
 

src/core/hle/kernel/memory/memory_block_manager.h

@@ -6,7 +6,6 @@
 
 #include <functional>
 #include <list>
-#include <memory>
 
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_block.h"

src/core/hle/kernel/memory/memory_manager.cpp

@@ -104,9 +104,9 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
     // Ensure that we don't leave anything un-freed
     auto group_guard = detail::ScopeExit([&] {
         for (const auto& it : page_list.Nodes()) {
-            const auto num_pages{std::min(
+            const auto min_num_pages{std::min(
                 it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-            chosen_manager.Free(it.GetAddress(), num_pages);
+            chosen_manager.Free(it.GetAddress(), min_num_pages);
         }
     });
 
@@ -165,9 +165,9 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
 
     // Free all of the pages
     for (const auto& it : page_list.Nodes()) {
-        const auto num_pages{std::min(
+        const auto min_num_pages{std::min(
             it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-        chosen_manager.Free(it.GetAddress(), num_pages);
+        chosen_manager.Free(it.GetAddress(), min_num_pages);
     }
 
     return RESULT_SUCCESS;

src/core/hle/kernel/memory/memory_manager.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <mutex>
 
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/page_heap.h"
 #include "core/hle/result.h"

src/core/hle/kernel/memory/page_heap.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #include "core/core.h"
 #include "core/hle/kernel/memory/page_heap.h"

src/core/hle/kernel/memory/page_heap.h

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 

src/core/hle/kernel/memory/page_linked_list.h

@@ -7,7 +7,6 @@
 #include <list>
 
 #include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/memory_types.h"
 #include "core/hle/result.h"

src/core/hle/kernel/memory/page_table.cpp

@@ -6,7 +6,6 @@
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/core.h"
-#include "core/device_memory.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory/address_space_info.h"

src/core/hle/kernel/memory/page_table.h

@@ -4,16 +4,15 @@
 
 #pragma once
 
-#include <list>
 #include <memory>
 #include <mutex>
 
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/page_table.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/memory/memory_block.h"
 #include "core/hle/kernel/memory/memory_manager.h"
+#include "core/hle/result.h"
 
 namespace Core {
 class System;

src/core/hle/kernel/memory/slab_heap.h

@@ -2,15 +2,14 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-// This file references various implementation details from Atmosph<EFBFBD>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<EFBFBD>re-NX.
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
 
 #pragma once
 
 #include <atomic>
 
 #include "common/assert.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Kernel::Memory {

src/core/hle/kernel/memory/system_control.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include <random>
 
 #include "core/hle/kernel/memory/system_control.h"

src/core/hle/kernel/mutex.cpp

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "common/assert.h"
+#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
@@ -67,6 +68,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
                              Handle requesting_thread_handle) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
+        LOG_ERROR(Kernel, "Address is not 4-byte aligned! address={:016X}", address);
         return ERR_INVALID_ADDRESS;
     }
 
@@ -88,6 +90,8 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     }
 
     if (holding_thread == nullptr) {
+        LOG_ERROR(Kernel, "Holding thread does not exist! thread_handle={:08X}",
+                  holding_thread_handle);
         return ERR_INVALID_HANDLE;
     }
 
@@ -109,6 +113,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
 ResultCode Mutex::Release(VAddr address) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
+        LOG_ERROR(Kernel, "Address is not 4-byte aligned! address={:016X}", address);
         return ERR_INVALID_ADDRESS;
     }
 

src/core/hle/kernel/physical_core.cpp

@@ -27,7 +27,9 @@ PhysicalCore::PhysicalCore(Core::System& system, std::size_t id,
         std::make_unique<Core::ARM_Dynarmic_64>(system, exclusive_monitor, core_index);
 
 #else
-    arm_interface = std::make_shared<Core::ARM_Unicorn>(system);
+    using Core::ARM_Unicorn;
+    arm_interface_32 = std::make_unique<ARM_Unicorn>(system, ARM_Unicorn::Arch::AArch32);
+    arm_interface_64 = std::make_unique<ARM_Unicorn>(system, ARM_Unicorn::Arch::AArch64);
     LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
 

src/core/hle/kernel/process_capability.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "common/bit_util.h"
+#include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/memory/page_table.h"
@@ -119,22 +120,30 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
             // The MapPhysical type uses two descriptor flags for its parameters.
             // If there's only one, then there's a problem.
             if (i >= num_capabilities) {
+                LOG_ERROR(Kernel, "Invalid combination! i={}", i);
                 return ERR_INVALID_COMBINATION;
             }
 
             const auto size_flags = capabilities[i];
             if (GetCapabilityType(size_flags) != CapabilityType::MapPhysical) {
+                LOG_ERROR(Kernel, "Invalid capability type! size_flags={}", size_flags);
                 return ERR_INVALID_COMBINATION;
             }
 
             const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
             if (result.IsError()) {
+                LOG_ERROR(Kernel, "Failed to map physical flags! descriptor={}, size_flags={}",
+                          descriptor, size_flags);
                 return result;
             }
         } else {
             const auto result =
                 ParseSingleFlagCapability(set_flags, set_svc_bits, descriptor, page_table);
             if (result.IsError()) {
+                LOG_ERROR(
+                    Kernel,
+                    "Failed to parse capability flag! set_flags={}, set_svc_bits={}, descriptor={}",
+                    set_flags, set_svc_bits, descriptor);
                 return result;
             }
         }
@@ -162,6 +171,9 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
     const u32 flag_length = GetFlagBitOffset(type);
     const u32 set_flag = 1U << flag_length;
     if ((set_flag & set_flags & InitializeOnceMask) != 0) {
+        LOG_ERROR(Kernel,
+                  "Attempted to initialize flags that may only be initialized once. set_flags={}",
+                  set_flags);
         return ERR_INVALID_COMBINATION;
     }
     set_flags |= set_flag;
@@ -187,6 +199,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
         break;
     }
 
+    LOG_ERROR(Kernel, "Invalid capability type! type={}", static_cast<u32>(type));
     return ERR_INVALID_CAPABILITY_DESCRIPTOR;
 }
 
@@ -208,23 +221,31 @@ void ProcessCapabilities::Clear() {
 
 ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
     if (priority_mask != 0 || core_mask != 0) {
+        LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
+                  priority_mask, core_mask);
         return ERR_INVALID_CAPABILITY_DESCRIPTOR;
     }
 
     const u32 core_num_min = (flags >> 16) & 0xFF;
     const u32 core_num_max = (flags >> 24) & 0xFF;
     if (core_num_min > core_num_max) {
+        LOG_ERROR(Kernel, "Core min is greater than core max! core_num_min={}, core_num_max={}",
+                  core_num_min, core_num_max);
         return ERR_INVALID_COMBINATION;
     }
 
     const u32 priority_min = (flags >> 10) & 0x3F;
     const u32 priority_max = (flags >> 4) & 0x3F;
     if (priority_min > priority_max) {
+        LOG_ERROR(Kernel,
+                  "Priority min is greater than priority max! priority_min={}, priority_max={}",
+                  core_num_min, priority_max);
         return ERR_INVALID_COMBINATION;
     }
 
     // The switch only has 4 usable cores.
     if (core_num_max >= 4) {
+        LOG_ERROR(Kernel, "Invalid max cores specified! core_num_max={}", core_num_max);
         return ERR_INVALID_PROCESSOR_ID;
     }
 
@@ -259,6 +280,7 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
         }
 
         if (svc_number >= svc_capabilities.size()) {
+            LOG_ERROR(Kernel, "Process svc capability is out of range! svc_number={}", svc_number);
             return ERR_OUT_OF_RANGE;
         }
 
@@ -295,6 +317,8 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
         // emulate that, it's sufficient to mark every interrupt as defined.
 
         if (interrupt >= interrupt_capabilities.size()) {
+            LOG_ERROR(Kernel, "Process interrupt capability is out of range! svc_number={}",
+                      interrupt);
             return ERR_OUT_OF_RANGE;
         }
 
@@ -307,6 +331,7 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
     const u32 reserved = flags >> 17;
     if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 
@@ -324,6 +349,9 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
     const u32 major_version = kernel_version >> 19;
 
     if (major_version != 0 || flags < 0x80000) {
+        LOG_ERROR(Kernel,
+                  "Kernel version is non zero or flags are too small! major_version={}, flags={}",
+                  major_version, flags);
         return ERR_INVALID_CAPABILITY_DESCRIPTOR;
     }
 
@@ -334,6 +362,7 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
     const u32 reserved = flags >> 26;
     if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 
@@ -344,6 +373,7 @@ ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
 ResultCode ProcessCapabilities::HandleDebugFlags(u32 flags) {
     const u32 reserved = flags >> 19;
     if (reserved != 0) {
+        LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
         return ERR_RESERVED_VALUE;
     }
 

src/core/hle/kernel/readable_event.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include "common/assert.h"
+#include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/readable_event.h"
@@ -23,10 +24,12 @@ void ReadableEvent::Acquire(Thread* thread) {
 }
 
 void ReadableEvent::Signal() {
-    if (!is_signaled) {
-        is_signaled = true;
-        SynchronizationObject::Signal();
-    };
+    if (is_signaled) {
+        return;
+    }
+
+    is_signaled = true;
+    SynchronizationObject::Signal();
 }
 
 void ReadableEvent::Clear() {
@@ -35,6 +38,8 @@ void ReadableEvent::Clear() {
 
 ResultCode ReadableEvent::Reset() {
     if (!is_signaled) {
+        LOG_ERROR(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
+                  GetObjectId(), GetTypeName(), GetName());
         return ERR_INVALID_STATE;
     }
 

src/core/hle/kernel/resource_limit.cpp

@@ -69,6 +69,8 @@ ResultCode ResourceLimit::SetLimitValue(ResourceType resource, s64 value) {
         limit[index] = value;
         return RESULT_SUCCESS;
     } else {
+        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}",
+                  static_cast<u32>(resource), value, index);
         return ERR_INVALID_STATE;
     }
 }

src/core/hle/kernel/server_session.cpp

@@ -137,8 +137,8 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
 ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread,
                                            Core::Memory::Memory& memory) {
     u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
-    std::shared_ptr<Kernel::HLERequestContext> context{
-        std::make_shared<Kernel::HLERequestContext>(SharedFrom(this), std::move(thread))};
+    auto context =
+        std::make_shared<HLERequestContext>(kernel, memory, SharedFrom(this), std::move(thread));
 
     context->PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
     request_queue.Push(std::move(context));

src/core/hle/kernel/svc.cpp

@@ -685,6 +685,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
     case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
     case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {
         if (info_sub_id != 0) {
+            LOG_ERROR(Kernel_SVC, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
+                      info_sub_id);
             return ERR_INVALID_ENUM_VALUE;
         }
 
@@ -692,6 +694,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             system.Kernel().CurrentProcess()->GetHandleTable();
         const auto process = current_process_handle_table.Get<Process>(static_cast<Handle>(handle));
         if (!process) {
+            LOG_ERROR(Kernel_SVC, "Process is not valid! info_id={}, info_sub_id={}, handle={:08X}",
+                      info_id, info_sub_id, handle);
             return ERR_INVALID_HANDLE;
         }
 
@@ -783,10 +787,13 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
 
     case GetInfoType::RegisterResourceLimit: {
         if (handle != 0) {
+            LOG_ERROR(Kernel, "Handle is non zero! handle={:08X}", handle);
             return ERR_INVALID_HANDLE;
         }
 
         if (info_sub_id != 0) {
+            LOG_ERROR(Kernel, "Info sub id is non zero! info_id={}, info_sub_id={}", info_id,
+                      info_sub_id);
             return ERR_INVALID_COMBINATION;
         }
 

src/core/hle/kernel/thread.cpp

@@ -423,6 +423,8 @@ ResultCode Thread::SetCoreAndAffinityMask(s32 new_core, u64 new_affinity_mask) {
     if (new_core == THREADPROCESSORID_DONT_UPDATE) {
         new_core = use_override ? ideal_core_override : ideal_core;
         if ((new_affinity_mask & (1ULL << new_core)) == 0) {
+            LOG_ERROR(Kernel, "New affinity mask is incorrect! new_core={}, new_affinity_mask={}",
+                      new_core, new_affinity_mask);
             return ERR_INVALID_COMBINATION;
         }
     }

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

@@ -228,7 +228,8 @@ public:
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
-    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
+    explicit IManagerForApplication(Common::UUID user_id)
+        : ServiceFramework("IManagerForApplication"), user_id(user_id) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
@@ -254,12 +255,14 @@ private:
     }
 
     void GetAccountId(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-        // Should return a nintendo account ID
+        LOG_DEBUG(Service_ACC, "called");
+
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u64>(1);
+        rb.PushRaw<u64>(user_id.GetNintendoID());
     }
+
+    Common::UUID user_id;
 };
 
 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
@@ -319,46 +322,37 @@ void Module::Interface::IsUserRegistrationRequestPermitted(Kernel::HLERequestCon
 
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto pid = rp.Pop<u64>();
 
-    LOG_DEBUG(Service_ACC, "called, process_id={}", pid);
+    LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(InitializeApplicationInfoBase(pid));
+    rb.Push(InitializeApplicationInfoBase());
 }
 
 void Module::Interface::InitializeApplicationInfoRestricted(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto pid = rp.Pop<u64>();
 
-    LOG_WARNING(Service_ACC, "(Partial implementation) called, process_id={}", pid);
+    LOG_WARNING(Service_ACC, "(Partial implementation) called");
 
     // TODO(ogniK): We require checking if the user actually owns the title and what not. As of
     // currently, we assume the user owns the title. InitializeApplicationInfoBase SHOULD be called
     // first then we do extra checks if the game is a digital copy.
 
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(InitializeApplicationInfoBase(pid));
+    rb.Push(InitializeApplicationInfoBase());
 }
 
-ResultCode Module::Interface::InitializeApplicationInfoBase(u64 process_id) {
+ResultCode Module::Interface::InitializeApplicationInfoBase() {
     if (application_info) {
         LOG_ERROR(Service_ACC, "Application already initialized");
         return ERR_ACCOUNTINFO_ALREADY_INITIALIZED;
     }
 
-    const auto& list = system.Kernel().GetProcessList();
-    const auto iter = std::find_if(list.begin(), list.end(), [&process_id](const auto& process) {
-        return process->GetProcessID() == process_id;
-    });
-
-    if (iter == list.end()) {
-        LOG_ERROR(Service_ACC, "Failed to find process ID");
-        application_info.application_type = ApplicationType::Unknown;
-
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
-    }
-
-    const auto launch_property = system.GetARPManager().GetLaunchProperty((*iter)->GetTitleID());
+    // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
+    // processes emulated. As we don't actually have pid support we should assume we're just using
+    // our own process
+    const auto& current_process = system.Kernel().CurrentProcess();
+    const auto launch_property =
+        system.GetARPManager().GetLaunchProperty(current_process->GetTitleID());
 
     if (launch_property.Failed()) {
         LOG_ERROR(Service_ACC, "Failed to get launch property");
@@ -372,10 +366,12 @@ ResultCode Module::Interface::InitializeApplicationInfoBase(u64 process_id) {
     case FileSys::StorageId::Host:
     case FileSys::StorageId::NandUser:
     case FileSys::StorageId::SdCard:
+    case FileSys::StorageId::None: // Yuzu specific, differs from hardware
         application_info.application_type = ApplicationType::Digital;
         break;
     default:
-        LOG_ERROR(Service_ACC, "Invalid game storage ID");
+        LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}",
+                  launch_property->base_game_storage_id);
         return ERR_ACCOUNTINFO_BAD_APPLICATION;
     }
 
@@ -389,7 +385,7 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IManagerForApplication>();
+    rb.PushIpcInterface<IManagerForApplication>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx) {
@@ -428,6 +424,17 @@ void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IProfileEditor>(user_id, *profile_manager);
 }
 
+void Module::Interface::ListQualifiedUsers(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+
+    // All users should be qualified. We don't actually have parental control or anything to do with
+    // nintendo online currently. We're just going to assume the user running the game has access to
+    // the game regardless of parental control settings.
+    ctx.WriteBuffer(profile_manager->GetAllUsers());
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
 void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_ACC, "called");
     // A u8 is passed into this function which we can safely ignore. It's to determine if we have

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

@@ -33,9 +33,10 @@ public:
         void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);
         void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
         void GetProfileEditor(Kernel::HLERequestContext& ctx);
+        void ListQualifiedUsers(Kernel::HLERequestContext& ctx);
 
     private:
-        ResultCode InitializeApplicationInfoBase(u64 process_id);
+        ResultCode InitializeApplicationInfoBase();
 
         enum class ApplicationType : u32_le {
             GameCard = 0,

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

@@ -35,7 +35,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {113, nullptr, "GetSaveDataThumbnailExistence"},
         {120, nullptr, "ListOpenUsersInApplication"},
         {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
+        {140, &ACC_SU::ListQualifiedUsers, "ListQualifiedUsers"},
         {150, nullptr, "AuthenticateApplicationAsync"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},

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

@@ -32,7 +32,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {130, nullptr, "LoadOpenContext"},
         {131, nullptr, "ListOpenContextStoredUsers"},
         {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"},
-        {141, nullptr, "ListQualifiedUsers"},
+        {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"},
         {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"},
     };
     // clang-format on

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

@@ -34,7 +34,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
         {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
+        {140, &ACC_U1::ListQualifiedUsers, "ListQualifiedUsers"},
         {150, nullptr, "AuthenticateApplicationAsync"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},

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

@@ -52,11 +52,6 @@ enum class LaunchParameterKind : u32 {
     AccountPreselectedUser = 2,
 };
 
-enum class VrMode : u8 {
-    Disabled = 0,
-    Enabled = 1,
-};
-
 constexpr u32 LAUNCH_PARAMETER_ACCOUNT_PRESELECTED_USER_MAGIC = 0xC79497CA;
 
 struct LaunchParameterAccountPreselectedUser {
@@ -685,27 +680,21 @@ void ICommonStateGetter::GetCurrentFocusState(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::IsVrModeEnabled(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(VrMode::Disabled);
+    rb.Push(vr_mode_state);
 }
 
 void ICommonStateGetter::SetVrModeEnabled(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto is_vr_mode_enabled = rp.Pop<bool>();
+    vr_mode_state = rp.Pop<bool>();
 
-    LOG_WARNING(Service_AM, "(STUBBED) called. is_vr_mode_enabled={}", is_vr_mode_enabled);
+    LOG_WARNING(Service_AM, "VR Mode is {}", vr_mode_state ? "on" : "off");
 
     IPC::ResponseBuilder rb{ctx, 2};
-    if (!is_vr_mode_enabled) {
-        rb.Push(RESULT_SUCCESS);
-    } else {
-        // TODO: Find better error code for this
-        UNIMPLEMENTED_MSG("is_vr_mode_enabled={}", is_vr_mode_enabled);
-        rb.Push(RESULT_UNKNOWN);
-    }
+    rb.Push(RESULT_SUCCESS);
 }
 
 void ICommonStateGetter::SetLcdBacklighOffEnabled(Kernel::HLERequestContext& ctx) {
@@ -1169,7 +1158,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {121, nullptr, "ClearUserChannel"},
         {122, nullptr, "UnpopToUserChannel"},
         {130, &IApplicationFunctions::GetGpuErrorDetectedSystemEvent, "GetGpuErrorDetectedSystemEvent"},
-        {140, nullptr, "GetFriendInvitationStorageChannelEvent"},
+        {140, &IApplicationFunctions::GetFriendInvitationStorageChannelEvent, "GetFriendInvitationStorageChannelEvent"},
         {141, nullptr, "TryPopFromFriendInvitationStorageChannel"},
         {150, nullptr, "GetNotificationStorageChannelEvent"},
         {151, nullptr, "TryPopFromNotificationStorageChannel"},
@@ -1186,6 +1175,9 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
     auto& kernel = system.Kernel();
     gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
         kernel, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
+
+    friend_invitation_storage_channel_event = Kernel::WritableEvent::CreateEventPair(
+        kernel, "IApplicationFunctions:FriendInvitationStorageChannelEvent");
 }
 
 IApplicationFunctions::~IApplicationFunctions() = default;
@@ -1343,12 +1335,23 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
 }
 
 void IApplicationFunctions::GetDisplayVersion(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+    LOG_DEBUG(Service_AM, "called");
+
+    std::array<u8, 0x10> version_string{};
+
+    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
+    const auto res = pm.GetControlMetadata();
+    if (res.first != nullptr) {
+        const auto& version = res.first->GetVersionString();
+        std::copy(version.begin(), version.end(), version_string.begin());
+    } else {
+        constexpr u128 default_version = {1, 0};
+        std::memcpy(version_string.data(), default_version.data(), sizeof(u128));
+    }
 
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(1);
-    rb.Push<u64>(0);
+    rb.PushRaw(version_string);
 }
 
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
@@ -1500,6 +1503,14 @@ void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestCon
     rb.PushCopyObjects(gpu_error_detected_event.readable);
 }
 
+void IApplicationFunctions::GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_AM, "called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(friend_invitation_storage_channel_event.readable);
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager,
                        std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system.Kernel());
@@ -1514,14 +1525,15 @@ void InstallInterfaces(SM::ServiceManager& service_manager,
     std::make_shared<TCAP>()->InstallAsService(service_manager);
 }
 
-IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions") {
+IHomeMenuFunctions::IHomeMenuFunctions(Kernel::KernelCore& kernel)
+    : ServiceFramework("IHomeMenuFunctions"), kernel(kernel) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {10, &IHomeMenuFunctions::RequestToGetForeground, "RequestToGetForeground"},
         {11, nullptr, "LockForeground"},
         {12, nullptr, "UnlockForeground"},
         {20, nullptr, "PopFromGeneralChannel"},
-        {21, nullptr, "GetPopFromGeneralChannelEvent"},
+        {21, &IHomeMenuFunctions::GetPopFromGeneralChannelEvent, "GetPopFromGeneralChannelEvent"},
         {30, nullptr, "GetHomeButtonWriterLockAccessor"},
         {31, nullptr, "GetWriterLockAccessorEx"},
         {100, nullptr, "PopRequestLaunchApplicationForDebug"},
@@ -1531,6 +1543,9 @@ IHomeMenuFunctions::IHomeMenuFunctions() : ServiceFramework("IHomeMenuFunctions"
     // clang-format on
 
     RegisterHandlers(functions);
+
+    pop_from_general_channel_event = Kernel::WritableEvent::CreateEventPair(
+        kernel, "IHomeMenuFunctions:PopFromGeneralChannelEvent");
 }
 
 IHomeMenuFunctions::~IHomeMenuFunctions() = default;
@@ -1542,6 +1557,14 @@ void IHomeMenuFunctions::RequestToGetForeground(Kernel::HLERequestContext& ctx)
     rb.Push(RESULT_SUCCESS);
 }
 
+void IHomeMenuFunctions::GetPopFromGeneralChannelEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(pop_from_general_channel_event.readable);
+}
+
 IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStateController") {
     // clang-format off
     static const FunctionInfo functions[] = {

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

@@ -191,6 +191,7 @@ private:
 
     Core::System& system;
     std::shared_ptr<AppletMessageQueue> msg_queue;
+    bool vr_mode_state{};
 };
 
 class IStorageImpl {
@@ -280,20 +281,26 @@ private:
     void QueryApplicationPlayStatistics(Kernel::HLERequestContext& ctx);
     void QueryApplicationPlayStatisticsByUid(Kernel::HLERequestContext& ctx);
     void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
+    void GetFriendInvitationStorageChannelEvent(Kernel::HLERequestContext& ctx);
 
     bool launch_popped_application_specific = false;
     bool launch_popped_account_preselect = false;
     Kernel::EventPair gpu_error_detected_event;
+    Kernel::EventPair friend_invitation_storage_channel_event;
     Core::System& system;
 };
 
 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
 public:
-    IHomeMenuFunctions();
+    explicit IHomeMenuFunctions(Kernel::KernelCore& kernel);
     ~IHomeMenuFunctions() override;
 
 private:
     void RequestToGetForeground(Kernel::HLERequestContext& ctx);
+    void GetPopFromGeneralChannelEvent(Kernel::HLERequestContext& ctx);
+
+    Kernel::EventPair pop_from_general_channel_event;
+    Kernel::KernelCore& kernel;
 };
 
 class IGlobalStateController final : public ServiceFramework<IGlobalStateController> {

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

@@ -202,7 +202,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IHomeMenuFunctions>();
+        rb.PushIpcInterface<IHomeMenuFunctions>(system.Kernel());
     }
 
     void GetGlobalStateController(Kernel::HLERequestContext& ctx) {

src/core/hle/service/audio/audin_u.cpp

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audin_u.h"
 
 namespace Service::Audio {
@@ -36,11 +39,12 @@ public:
 AudInU::AudInU() : ServiceFramework("audin:u") {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, nullptr, "ListAudioIns"},
-        {1, nullptr, "OpenAudioIn"},
-        {2, nullptr, "Unknown"},
-        {3, nullptr, "OpenAudioInAuto"},
-        {4, nullptr, "ListAudioInsAuto"},
+        {0, &AudInU::ListAudioIns, "ListAudioIns"},
+        {1, &AudInU::OpenAudioIn, "OpenAudioIn"},
+        {2, &AudInU::ListAudioIns, "ListAudioInsAuto"},
+        {3, &AudInU::OpenAudioIn, "OpenAudioInAuto"},
+        {4, &AudInU::ListAudioInsAutoFiltered, "ListAudioInsAutoFiltered"},
+        {5, &AudInU::OpenAudioInProtocolSpecified, "OpenAudioInProtocolSpecified"},
     };
     // clang-format on
 
@@ -49,4 +53,60 @@ AudInU::AudInU() : ServiceFramework("audin:u") {
 
 AudInU::~AudInU() = default;
 
+void AudInU::ListAudioIns(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Audio, "called");
+    const std::size_t count = ctx.GetWriteBufferSize() / sizeof(AudioInDeviceName);
+
+    const std::size_t device_count = std::min(count, audio_device_names.size());
+    std::vector<AudioInDeviceName> device_names;
+    device_names.reserve(device_count);
+
+    for (std::size_t i = 0; i < device_count; i++) {
+        const auto& device_name = audio_device_names[i];
+        auto& entry = device_names.emplace_back();
+        device_name.copy(entry.data(), device_name.size());
+    }
+
+    ctx.WriteBuffer(device_names);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u32>(device_names.size()));
+}
+
+void AudInU::ListAudioInsAutoFiltered(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Audio, "called");
+    constexpr u32 device_count = 0;
+
+    // Since we don't actually use any other audio input devices, we return 0 devices. Filtered
+    // device listing just omits the default input device
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u32>(device_count));
+}
+
+void AudInU::OpenInOutImpl(Kernel::HLERequestContext& ctx) {
+    AudInOutParams params{};
+    params.channel_count = 2;
+    params.sample_format = SampleFormat::PCM16;
+    params.sample_rate = 48000;
+    params.state = State::Started;
+
+    IPC::ResponseBuilder rb{ctx, 6, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<AudInOutParams>(params);
+    rb.PushIpcInterface<IAudioIn>();
+}
+
+void AudInU::OpenAudioIn(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+    OpenInOutImpl(ctx);
+}
+
+void AudInU::OpenAudioInProtocolSpecified(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Audio, "(STUBBED) called");
+    OpenInOutImpl(ctx);
+}
+
 } // namespace Service::Audio

src/core/hle/service/audio/audin_u.h

@@ -16,6 +16,35 @@ class AudInU final : public ServiceFramework<AudInU> {
 public:
     explicit AudInU();
     ~AudInU() override;
+
+private:
+    enum class SampleFormat : u32_le {
+        PCM16 = 2,
+    };
+
+    enum class State : u32_le {
+        Started = 0,
+        Stopped = 1,
+    };
+
+    struct AudInOutParams {
+        u32_le sample_rate{};
+        u32_le channel_count{};
+        SampleFormat sample_format{};
+        State state{};
+    };
+    static_assert(sizeof(AudInOutParams) == 0x10, "AudInOutParams is an invalid size");
+
+    using AudioInDeviceName = std::array<char, 256>;
+    static constexpr std::array<std::string_view, 1> audio_device_names{{
+        "BuiltInHeadset",
+    }};
+
+    void ListAudioIns(Kernel::HLERequestContext& ctx);
+    void ListAudioInsAutoFiltered(Kernel::HLERequestContext& ctx);
+    void OpenInOutImpl(Kernel::HLERequestContext& ctx);
+    void OpenAudioIn(Kernel::HLERequestContext& ctx);
+    void OpenAudioInProtocolSpecified(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Audio

src/core/hle/service/caps/caps_su.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/caps/caps_su.h"
 
 namespace Service::Capture {
@@ -9,8 +11,11 @@ namespace Service::Capture {
 CAPS_SU::CAPS_SU() : ServiceFramework("caps:su") {
     // clang-format off
     static const FunctionInfo functions[] = {
+        {32, &CAPS_SU::SetShimLibraryVersion, "SetShimLibraryVersion"},
         {201, nullptr, "SaveScreenShot"},
         {203, nullptr, "SaveScreenShotEx0"},
+        {205, nullptr, "SaveScreenShotEx1"},
+        {210, nullptr, "SaveScreenShotEx2"},
     };
     // clang-format on
 
@@ -19,4 +24,11 @@ CAPS_SU::CAPS_SU() : ServiceFramework("caps:su") {
 
 CAPS_SU::~CAPS_SU() = default;
 
+void CAPS_SU::SetShimLibraryVersion(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_Capture, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
 } // namespace Service::Capture

src/core/hle/service/caps/caps_su.h

@@ -16,6 +16,9 @@ class CAPS_SU final : public ServiceFramework<CAPS_SU> {
 public:
     explicit CAPS_SU();
     ~CAPS_SU() override;
+
+private:
+    void SetShimLibraryVersion(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Capture

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

@@ -316,8 +316,8 @@ public:
             {8, &IFileSystem::OpenFile, "OpenFile"},
             {9, &IFileSystem::OpenDirectory, "OpenDirectory"},
             {10, &IFileSystem::Commit, "Commit"},
-            {11, nullptr, "GetFreeSpaceSize"},
-            {12, nullptr, "GetTotalSpaceSize"},
+            {11, &IFileSystem::GetFreeSpaceSize, "GetFreeSpaceSize"},
+            {12, &IFileSystem::GetTotalSpaceSize, "GetTotalSpaceSize"},
             {13, &IFileSystem::CleanDirectoryRecursively, "CleanDirectoryRecursively"},
             {14, nullptr, "GetFileTimeStampRaw"},
             {15, nullptr, "QueryEntry"},

src/core/hle/service/nim/nim.cpp

@@ -15,6 +15,66 @@
 
 namespace Service::NIM {
 
+class IShopServiceAsync final : public ServiceFramework<IShopServiceAsync> {
+public:
+    IShopServiceAsync() : ServiceFramework("IShopServiceAsync") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Cancel"},
+            {1, nullptr, "GetSize"},
+            {2, nullptr, "Read"},
+            {3, nullptr, "GetErrorCode"},
+            {4, nullptr, "Request"},
+            {5, nullptr, "Prepare"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class IShopServiceAccessor final : public ServiceFramework<IShopServiceAccessor> {
+public:
+    IShopServiceAccessor() : ServiceFramework("IShopServiceAccessor") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IShopServiceAccessor::CreateAsyncInterface, "CreateAsyncInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateAsyncInterface(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IShopServiceAsync>();
+    }
+};
+
+class IShopServiceAccessServer final : public ServiceFramework<IShopServiceAccessServer> {
+public:
+    IShopServiceAccessServer() : ServiceFramework("IShopServiceAccessServer") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IShopServiceAccessServer::CreateAccessorInterface, "CreateAccessorInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateAccessorInterface(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IShopServiceAccessor>();
+    }
+};
+
 class NIM final : public ServiceFramework<NIM> {
 public:
     explicit NIM() : ServiceFramework{"nim"} {
@@ -78,7 +138,7 @@ public:
     explicit NIM_ECA() : ServiceFramework{"nim:eca"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "CreateServerInterface"},
+            {0, &NIM_ECA::CreateServerInterface, "CreateServerInterface"},
             {1, nullptr, "RefreshDebugAvailability"},
             {2, nullptr, "ClearDebugResponse"},
             {3, nullptr, "RegisterDebugResponse"},
@@ -87,6 +147,14 @@ public:
 
         RegisterHandlers(functions);
     }
+
+private:
+    void CreateServerInterface(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IShopServiceAccessServer>();
+    }
 };
 
 class NIM_SHP final : public ServiceFramework<NIM_SHP> {

src/core/hle/service/ns/ns.cpp

@@ -371,10 +371,15 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
     // Convert to application language, get priority list
     const auto application_language = ConvertToApplicationLanguage(language_code);
     if (application_language == std::nullopt) {
+        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}",
+                  language_code);
         return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
     const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
     if (!priority_list) {
+        LOG_ERROR(Service_NS,
+                  "Could not find application language priorities! application_language={}",
+                  *application_language);
         return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
 
@@ -386,6 +391,8 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
         }
     }
 
+    LOG_ERROR(Service_NS, "Could not find a valid language! supported_languages={:08X}",
+              supported_languages);
     return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
 }
 
@@ -410,6 +417,7 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
     const auto language_code =
         ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
     if (language_code == std::nullopt) {
+        LOG_ERROR(Service_NS, "Language not found! application_language={}", application_language);
         return ERR_APPLICATION_LANGUAGE_NOT_FOUND;
     }
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h

@@ -159,9 +159,10 @@ private:
     static_assert(sizeof(IoctlFlushL2) == 8, "IoctlFlushL2 is incorrect size");
 
     struct IoctlGetGpuTime {
-        u64_le gpu_time;
+        u64_le gpu_time{};
+        INSERT_PADDING_WORDS(2);
     };
-    static_assert(sizeof(IoctlGetGpuTime) == 8, "IoctlGetGpuTime is incorrect size");
+    static_assert(sizeof(IoctlGetGpuTime) == 0x10, "IoctlGetGpuTime is incorrect size");
 
     u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
                            std::vector<u8>& output2, IoctlVersion version);

src/core/hle/service/ptm/psm.cpp

@@ -12,9 +12,6 @@
 
 namespace Service::PSM {
 
-constexpr u32 BATTERY_FULLY_CHARGED = 100;    // 100% Full
-constexpr u32 BATTERY_CURRENTLY_CHARGING = 1; // Plugged into an official dock
-
 class PSM final : public ServiceFramework<PSM> {
 public:
     explicit PSM() : ServiceFramework{"psm"} {
@@ -48,20 +45,30 @@ public:
 
 private:
     void GetBatteryChargePercentage(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_PSM, "(STUBBED) called");
+        LOG_DEBUG(Service_PSM, "called");
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(BATTERY_FULLY_CHARGED);
+        rb.Push<u32>(battery_charge_percentage);
     }
 
     void GetChargerType(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_PSM, "(STUBBED) called");
+        LOG_DEBUG(Service_PSM, "called");
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(BATTERY_CURRENTLY_CHARGING);
+        rb.PushEnum(charger_type);
     }
+
+    enum class ChargerType : u32 {
+        Unplugged = 0,
+        RegularCharger = 1,
+        LowPowerCharger = 2,
+        Unknown = 3,
+    };
+
+    u32 battery_charge_percentage{100}; // 100%
+    ChargerType charger_type{ChargerType::RegularCharger};
 };
 
 void InstallInterfaces(SM::ServiceManager& sm) {

src/core/hle/service/set/set.cpp

@@ -67,6 +67,7 @@ void SET::MakeLanguageCode(Kernel::HLERequestContext& ctx) {
     const auto index = rp.Pop<u32>();
 
     if (index >= available_language_codes.size()) {
+        LOG_ERROR(Service_SET, "Invalid language code index! index={}", index);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ERR_INVALID_LANGUAGE);
         return;

src/core/hle/service/sm/sm.cpp

@@ -28,9 +28,11 @@ void ServiceManager::InvokeControlRequest(Kernel::HLERequestContext& context) {
 
 static ResultCode ValidateServiceName(const std::string& name) {
     if (name.size() <= 0 || name.size() > 8) {
+        LOG_ERROR(Service_SM, "Invalid service name! service={}", name);
         return ERR_INVALID_NAME;
     }
     if (name.find('\0') != std::string::npos) {
+        LOG_ERROR(Service_SM, "A non null terminated service was passed");
         return ERR_INVALID_NAME;
     }
     return RESULT_SUCCESS;
@@ -51,8 +53,10 @@ ResultVal<std::shared_ptr<Kernel::ServerPort>> ServiceManager::RegisterService(
 
     CASCADE_CODE(ValidateServiceName(name));
 
-    if (registered_services.find(name) != registered_services.end())
+    if (registered_services.find(name) != registered_services.end()) {
+        LOG_ERROR(Service_SM, "Service is already registered! service={}", name);
         return ERR_ALREADY_REGISTERED;
+    }
 
     auto& kernel = Core::System::GetInstance().Kernel();
     auto [server_port, client_port] =
@@ -66,9 +70,10 @@ ResultCode ServiceManager::UnregisterService(const std::string& name) {
     CASCADE_CODE(ValidateServiceName(name));
 
     const auto iter = registered_services.find(name);
-    if (iter == registered_services.end())
+    if (iter == registered_services.end()) {
+        LOG_ERROR(Service_SM, "Server is not registered! service={}", name);
         return ERR_SERVICE_NOT_REGISTERED;
-
+    }
     registered_services.erase(iter);
     return RESULT_SUCCESS;
 }
@@ -79,6 +84,7 @@ ResultVal<std::shared_ptr<Kernel::ClientPort>> ServiceManager::GetServicePort(
     CASCADE_CODE(ValidateServiceName(name));
     auto it = registered_services.find(name);
     if (it == registered_services.end()) {
+        LOG_ERROR(Service_SM, "Server is not registered! service={}", name);
         return ERR_SERVICE_NOT_REGISTERED;
     }
 

src/core/hle/service/vi/vi.cpp

@@ -867,6 +867,7 @@ private:
 
         const auto layer_id = nv_flinger->CreateLayer(display);
         if (!layer_id) {
+            LOG_ERROR(Service_VI, "Layer not found! display=0x{:016X}", display);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -983,6 +984,7 @@ private:
 
         const auto display_id = nv_flinger->OpenDisplay(name);
         if (!display_id) {
+            LOG_ERROR(Service_VI, "Display not found! display_name={}", name);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1082,6 +1084,7 @@ private:
 
         const auto display_id = nv_flinger->OpenDisplay(display_name);
         if (!display_id) {
+            LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1089,6 +1092,7 @@ private:
 
         const auto buffer_queue_id = nv_flinger->FindBufferQueueId(*display_id, layer_id);
         if (!buffer_queue_id) {
+            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1124,6 +1128,7 @@ private:
 
         const auto layer_id = nv_flinger->CreateLayer(display_id);
         if (!layer_id) {
+            LOG_ERROR(Service_VI, "Layer not found! layer_id={}", *layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1131,6 +1136,7 @@ private:
 
         const auto buffer_queue_id = nv_flinger->FindBufferQueueId(display_id, *layer_id);
         if (!buffer_queue_id) {
+            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1161,6 +1167,7 @@ private:
 
         const auto vsync_event = nv_flinger->FindVsyncEvent(display_id);
         if (!vsync_event) {
+            LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ERR_NOT_FOUND);
             return;
@@ -1201,6 +1208,7 @@ private:
         case NintendoScaleMode::PreserveAspectRatio:
             return MakeResult(ConvertedScaleMode::PreserveAspectRatio);
         default:
+            LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
             return ERR_OPERATION_FAILED;
         }
     }
@@ -1257,6 +1265,7 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
     const auto policy = rp.PopEnum<Policy>();
 
     if (!IsValidServiceAccess(permission, policy)) {
+        LOG_ERROR(Service_VI, "Permission denied for policy {}", static_cast<u32>(policy));
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ERR_PERMISSION_DENIED);
         return;

src/core/settings.cpp

@@ -96,6 +96,7 @@ void LogSettings() {
     LogSetting("Renderer_UseAsynchronousGpuEmulation",
                Settings::values.use_asynchronous_gpu_emulation);
     LogSetting("Renderer_UseVsync", Settings::values.use_vsync);
+    LogSetting("Renderer_AnisotropicFilteringLevel", Settings::values.max_anisotropy);
     LogSetting("Audio_OutputEngine", Settings::values.sink_id);
     LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
     LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);

src/input_common/main.cpp

@@ -18,7 +18,9 @@ namespace InputCommon {
 
 static std::shared_ptr<Keyboard> keyboard;
 static std::shared_ptr<MotionEmu> motion_emu;
+#ifdef HAVE_SDL2
 static std::unique_ptr<SDL::State> sdl;
+#endif
 static std::unique_ptr<CemuhookUDP::State> udp;
 
 void Init() {
@@ -29,7 +31,9 @@ void Init() {
     motion_emu = std::make_shared<MotionEmu>();
     Input::RegisterFactory<Input::MotionDevice>("motion_emu", motion_emu);
 
+#ifdef HAVE_SDL2
     sdl = SDL::Init();
+#endif
 
     udp = CemuhookUDP::Init();
 }
@@ -40,7 +44,9 @@ void Shutdown() {
     Input::UnregisterFactory<Input::AnalogDevice>("analog_from_button");
     Input::UnregisterFactory<Input::MotionDevice>("motion_emu");
     motion_emu.reset();
+#ifdef HAVE_SDL2
     sdl.reset();
+#endif
     udp.reset();
 }
 

src/video_core/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(video_core STATIC
     dma_pusher.h
     engines/const_buffer_engine_interface.h
     engines/const_buffer_info.h
+    engines/engine_interface.h
     engines/engine_upload.cpp
     engines/engine_upload.h
     engines/fermi_2d.cpp
@@ -124,6 +125,8 @@ add_library(video_core STATIC
     shader/decode.cpp
     shader/expr.cpp
     shader/expr.h
+    shader/memory_util.cpp
+    shader/memory_util.h
     shader/node_helper.cpp
     shader/node_helper.h
     shader/node.h

src/video_core/buffer_cache/buffer_cache.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <list>
 #include <memory>
 #include <mutex>
@@ -89,10 +88,6 @@ public:
                 map->MarkAsWritten(true);
                 MarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
             }
-        } else {
-            if (map->IsWritten()) {
-                WriteBarrier();
-            }
         }
 
         return {ToHandle(block), static_cast<u64>(block->GetOffset(cpu_addr))};
@@ -254,8 +249,6 @@ protected:
 
     virtual BufferType ToHandle(const OwnerBuffer& storage) = 0;
 
-    virtual void WriteBarrier() = 0;
-
     virtual OwnerBuffer CreateBlock(VAddr cpu_addr, std::size_t size) = 0;
 
     virtual void UploadBlockData(const OwnerBuffer& buffer, std::size_t offset, std::size_t size,

src/video_core/dma_pusher.cpp

@@ -27,6 +27,8 @@ void DmaPusher::DispatchCalls() {
 
     dma_pushbuffer_subindex = 0;
 
+    dma_state.is_last_call = true;
+
     while (system.IsPoweredOn()) {
         if (!Step()) {
             break;
@@ -82,9 +84,11 @@ bool DmaPusher::Step() {
                     index);
                 CallMultiMethod(&command_header.argument, max_write);
                 dma_state.method_count -= max_write;
+                dma_state.is_last_call = true;
                 index += max_write;
                 continue;
             } else {
+                dma_state.is_last_call = dma_state.method_count <= 1;
                 CallMethod(command_header.argument);
             }
 
@@ -144,12 +148,22 @@ void DmaPusher::SetState(const CommandHeader& command_header) {
 }
 
 void DmaPusher::CallMethod(u32 argument) const {
-    gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+    if (dma_state.method < non_puller_methods) {
+        gpu.CallMethod({dma_state.method, argument, dma_state.subchannel, dma_state.method_count});
+    } else {
+        subchannels[dma_state.subchannel]->CallMethod(dma_state.method, argument,
+                                                      dma_state.is_last_call);
+    }
 }
 
 void DmaPusher::CallMultiMethod(const u32* base_start, u32 num_methods) const {
-    gpu.CallMultiMethod(dma_state.method, dma_state.subchannel, base_start, num_methods,
-                        dma_state.method_count);
+    if (dma_state.method < non_puller_methods) {
+        gpu.CallMultiMethod(dma_state.method, dma_state.subchannel, base_start, num_methods,
+                            dma_state.method_count);
+    } else {
+        subchannels[dma_state.subchannel]->CallMultiMethod(dma_state.method, base_start,
+                                                           num_methods, dma_state.method_count);
+    }
 }
 
 } // namespace Tegra

src/video_core/dma_pusher.h

@@ -4,11 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <vector>
 #include <queue>
 
 #include "common/bit_field.h"
 #include "common/common_types.h"
+#include "video_core/engines/engine_interface.h"
 
 namespace Core {
 class System;
@@ -69,7 +71,13 @@ public:
 
     void DispatchCalls();
 
+    void BindSubchannel(Tegra::Engines::EngineInterface* engine, u32 subchannel_id) {
+        subchannels[subchannel_id] = engine;
+    }
+
 private:
+    static constexpr u32 non_puller_methods = 0x40;
+    static constexpr u32 max_subchannels = 8;
     bool Step();
 
     void SetState(const CommandHeader& command_header);
@@ -88,6 +96,7 @@ private:
         u32 method_count;      ///< Current method count
         u32 length_pending;    ///< Large NI command length pending
         bool non_incrementing; ///< Current command's NI flag
+        bool is_last_call;
     };
 
     DmaState dma_state{};
@@ -96,6 +105,8 @@ private:
     GPUVAddr dma_mget{};  ///< main pushbuffer last read address
     bool ib_enable{true}; ///< IB mode enabled
 
+    std::array<Tegra::Engines::EngineInterface*, max_subchannels> subchannels{};
+
     GPU& gpu;
     Core::System& system;
 };

src/video_core/engines/engine_interface.h

@@ -0,0 +1,22 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <type_traits>
+#include "common/common_types.h"
+
+namespace Tegra::Engines {
+
+class EngineInterface {
+public:
+    /// Write the value to the register identified by method.
+    virtual void CallMethod(u32 method, u32 method_argument, bool is_last_call) = 0;
+
+    /// Write multiple values to the register identified by method.
+    virtual void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                                 u32 methods_pending) = 0;
+};
+
+} // namespace Tegra::Engines

src/video_core/engines/fermi_2d.cpp

@@ -12,13 +12,13 @@ namespace Tegra::Engines {
 
 Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}
 
-void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void Fermi2D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Fermi2D register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (method) {
     // Trigger the surface copy on the last register write. This is blit_src_y, but this is 64-bit,
     // so trigger on the second 32-bit write.
     case FERMI2D_REG_INDEX(blit_src_y) + 1: {
@@ -30,7 +30,7 @@ void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
 
 void Fermi2D::CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending) {
     for (std::size_t i = 0; i < amount; i++) {
-        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/fermi_2d.h

@@ -10,6 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/math_util.h"
+#include "video_core/engines/engine_interface.h"
 #include "video_core/gpu.h"
 
 namespace Tegra {
@@ -31,16 +32,17 @@ namespace Tegra::Engines {
 #define FERMI2D_REG_INDEX(field_name)                                                              \
     (offsetof(Tegra::Engines::Fermi2D::Regs, field_name) / sizeof(u32))
 
-class Fermi2D final {
+class Fermi2D final : public EngineInterface {
 public:
     explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer);
     ~Fermi2D() = default;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     enum class Origin : u32 {
         Center = 0,

src/video_core/engines/kepler_compute.cpp

@@ -24,20 +24,19 @@ KeplerCompute::KeplerCompute(Core::System& system, VideoCore::RasterizerInterfac
 
 KeplerCompute::~KeplerCompute() = default;
 
-void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void KeplerCompute::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid KeplerCompute register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (method) {
     case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
         upload_state.ProcessExec(regs.exec_upload.linear != 0);
         break;
     }
     case KEPLER_COMPUTE_REG_INDEX(data_upload): {
-        const bool is_last_call = method_call.IsLastCall();
-        upload_state.ProcessData(method_call.argument, is_last_call);
+        upload_state.ProcessData(method_argument, is_last_call);
         if (is_last_call) {
             system.GPU().Maxwell3D().OnMemoryWrite();
         }
@@ -54,7 +53,7 @@ void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
 void KeplerCompute::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                     u32 methods_pending) {
     for (std::size_t i = 0; i < amount; i++) {
-        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/kepler_compute.h

@@ -11,6 +11,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "video_core/engines/const_buffer_engine_interface.h"
+#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
@@ -39,7 +40,7 @@ namespace Tegra::Engines {
 #define KEPLER_COMPUTE_REG_INDEX(field_name)                                                       \
     (offsetof(Tegra::Engines::KeplerCompute::Regs, field_name) / sizeof(u32))
 
-class KeplerCompute final : public ConstBufferEngineInterface {
+class KeplerCompute final : public ConstBufferEngineInterface, public EngineInterface {
 public:
     explicit KeplerCompute(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                            MemoryManager& memory_manager);
@@ -200,10 +201,11 @@ public:
                   "KeplerCompute LaunchParams has wrong size");
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     Texture::FullTextureInfo GetTexture(std::size_t offset) const;
 

src/video_core/engines/kepler_memory.cpp

@@ -19,20 +19,19 @@ KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
 
 KeplerMemory::~KeplerMemory() = default;
 
-void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void KeplerMemory::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid KeplerMemory register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
-    switch (method_call.method) {
+    switch (method) {
     case KEPLERMEMORY_REG_INDEX(exec): {
         upload_state.ProcessExec(regs.exec.linear != 0);
         break;
     }
     case KEPLERMEMORY_REG_INDEX(data): {
-        const bool is_last_call = method_call.IsLastCall();
-        upload_state.ProcessData(method_call.argument, is_last_call);
+        upload_state.ProcessData(method_argument, is_last_call);
         if (is_last_call) {
             system.GPU().Maxwell3D().OnMemoryWrite();
         }
@@ -44,7 +43,7 @@ void KeplerMemory::CallMethod(const GPU::MethodCall& method_call) {
 void KeplerMemory::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                    u32 methods_pending) {
     for (std::size_t i = 0; i < amount; i++) {
-        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 

src/video_core/engines/kepler_memory.h

@@ -10,6 +10,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"
 
@@ -32,16 +33,17 @@ namespace Tegra::Engines {
 #define KEPLERMEMORY_REG_INDEX(field_name)                                                         \
     (offsetof(Tegra::Engines::KeplerMemory::Regs, field_name) / sizeof(u32))
 
-class KeplerMemory final {
+class KeplerMemory final : public EngineInterface {
 public:
     KeplerMemory(Core::System& system, MemoryManager& memory_manager);
     ~KeplerMemory();
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     struct Regs {
         static constexpr size_t NUM_REGS = 0x7F;

src/video_core/engines/maxwell_3d.cpp

@@ -125,12 +125,10 @@ void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u3
     }
 }
 
-void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
-    const u32 method = method_call.method;
-
+void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
     if (method == cb_data_state.current) {
-        regs.reg_array[method] = method_call.argument;
-        ProcessCBData(method_call.argument);
+        regs.reg_array[method] = method_argument;
+        ProcessCBData(method_argument);
         return;
     } else if (cb_data_state.current != null_cb_data) {
         FinishCBData();
@@ -153,10 +151,10 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
             executing_macro = method;
         }
 
-        macro_params.push_back(method_call.argument);
+        macro_params.push_back(method_argument);
 
         // Call the macro when there are no more parameters in the command buffer
-        if (method_call.IsLastCall()) {
+        if (is_last_call) {
             CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
             macro_params.clear();
         }
@@ -166,7 +164,7 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Maxwell3D register, increase the size of the Regs structure");
 
-    u32 arg = method_call.argument;
+    u32 arg = method_argument;
     // Keep track of the register value in shadow_state when requested.
     if (shadow_state.shadow_ram_control == Regs::ShadowRamControl::Track ||
         shadow_state.shadow_ram_control == Regs::ShadowRamControl::TrackWithFilter) {
@@ -184,8 +182,12 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
     }
 
     switch (method) {
+    case MAXWELL3D_REG_INDEX(wait_for_idle): {
+        rasterizer.WaitForIdle();
+        break;
+    }
     case MAXWELL3D_REG_INDEX(shadow_ram_control): {
-        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_call.argument);
+        shadow_state.shadow_ram_control = static_cast<Regs::ShadowRamControl>(method_argument);
         break;
     }
     case MAXWELL3D_REG_INDEX(macros.data): {
@@ -268,7 +270,6 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
         break;
     }
     case MAXWELL3D_REG_INDEX(data_upload): {
-        const bool is_last_call = method_call.IsLastCall();
         upload_state.ProcessData(arg, is_last_call);
         if (is_last_call) {
             OnMemoryWrite();
@@ -326,7 +327,7 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
     }
     default: {
         for (std::size_t i = 0; i < amount; i++) {
-            CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
+            CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
         }
     }
     }
@@ -356,16 +357,15 @@ void Maxwell3D::StepInstance(const MMEDrawMode expected_mode, const u32 count) {
     StepInstance(expected_mode, count);
 }
 
-void Maxwell3D::CallMethodFromMME(const GPU::MethodCall& method_call) {
-    const u32 method = method_call.method;
+void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
     if (mme_inline[method]) {
-        regs.reg_array[method] = method_call.argument;
+        regs.reg_array[method] = method_argument;
         if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count) ||
             method == MAXWELL3D_REG_INDEX(index_array.count)) {
             const MMEDrawMode expected_mode = method == MAXWELL3D_REG_INDEX(vertex_buffer.count)
                                                   ? MMEDrawMode::Array
                                                   : MMEDrawMode::Indexed;
-            StepInstance(expected_mode, method_call.argument);
+            StepInstance(expected_mode, method_argument);
         } else if (method == MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)) {
             mme_draw.instance_mode =
                 (regs.draw.instance_next != 0) || (regs.draw.instance_cont != 0);
@@ -377,7 +377,7 @@ void Maxwell3D::CallMethodFromMME(const GPU::MethodCall& method_call) {
         if (mme_draw.current_mode != MMEDrawMode::Undefined) {
             FlushMMEInlineDraw();
         }
-        CallMethod(method_call);
+        CallMethod(method, method_argument, true);
     }
 }
 

src/video_core/engines/maxwell_3d.h

@@ -19,6 +19,7 @@
 #include "common/math_util.h"
 #include "video_core/engines/const_buffer_engine_interface.h"
 #include "video_core/engines/const_buffer_info.h"
+#include "video_core/engines/engine_interface.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
@@ -48,7 +49,7 @@ namespace Tegra::Engines {
 #define MAXWELL3D_REG_INDEX(field_name)                                                            \
     (offsetof(Tegra::Engines::Maxwell3D::Regs, field_name) / sizeof(u32))
 
-class Maxwell3D final : public ConstBufferEngineInterface {
+class Maxwell3D final : public ConstBufferEngineInterface, public EngineInterface {
 public:
     explicit Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                        MemoryManager& memory_manager);
@@ -709,7 +710,9 @@ public:
 
         union {
             struct {
-                INSERT_UNION_PADDING_WORDS(0x45);
+                INSERT_UNION_PADDING_WORDS(0x44);
+
+                u32 wait_for_idle;
 
                 struct {
                     u32 upload_address;
@@ -1179,6 +1182,7 @@ public:
                     BitField<0, 1, u32> depth_range_0_1;
                     BitField<3, 1, u32> depth_clamp_near;
                     BitField<4, 1, u32> depth_clamp_far;
+                    BitField<11, 1, u32> depth_clamp_disabled;
                 } view_volume_clip_control;
 
                 INSERT_UNION_PADDING_WORDS(0x1F);
@@ -1357,13 +1361,14 @@ public:
     u32 GetRegisterValue(u32 method) const;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     /// Write the value to the register identified by method.
-    void CallMethodFromMME(const GPU::MethodCall& method_call);
+    void CallMethodFromMME(u32 method, u32 method_argument);
 
     void FlushMMEInlineDraw();
 
@@ -1535,6 +1540,7 @@ private:
     static_assert(offsetof(Maxwell3D::Regs, field_name) == position * 4,                           \
                   "Field " #field_name " has invalid position")
 
+ASSERT_REG_POSITION(wait_for_idle, 0x44);
 ASSERT_REG_POSITION(macros, 0x45);
 ASSERT_REG_POSITION(shadow_ram_control, 0x49);
 ASSERT_REG_POSITION(upload, 0x60);

src/video_core/engines/maxwell_dma.cpp

@@ -17,16 +17,16 @@ namespace Tegra::Engines {
 MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
     : system{system}, memory_manager{memory_manager} {}
 
-void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
-    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
+void MaxwellDMA::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
+    ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid MaxwellDMA register, increase the size of the Regs structure");
 
-    regs.reg_array[method_call.method] = method_call.argument;
+    regs.reg_array[method] = method_argument;
 
 #define MAXWELLDMA_REG_INDEX(field_name)                                                           \
     (offsetof(Tegra::Engines::MaxwellDMA::Regs, field_name) / sizeof(u32))
 
-    switch (method_call.method) {
+    switch (method) {
     case MAXWELLDMA_REG_INDEX(exec): {
         HandleCopy();
         break;
@@ -39,7 +39,7 @@ void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
 void MaxwellDMA::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                                  u32 methods_pending) {
     for (std::size_t i = 0; i < amount; i++) {
-        CallMethod({method, base_start[i], 0, methods_pending - static_cast<u32>(i)});
+        CallMethod(method, base_start[i], methods_pending - static_cast<u32>(i) <= 1);
     }
 }
 
@@ -90,7 +90,47 @@ void MaxwellDMA::HandleCopy() {
     ASSERT(regs.exec.enable_2d == 1);
 
     if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
+
         ASSERT(regs.src_params.BlockDepth() == 0);
+        // Optimized path for micro copies.
+        if (regs.dst_pitch * regs.y_count < Texture::GetGOBSize() && regs.dst_pitch <= 64) {
+            const u32 bytes_per_pixel = regs.dst_pitch / regs.x_count;
+            const std::size_t src_size = Texture::GetGOBSize();
+            const std::size_t dst_size = regs.dst_pitch * regs.y_count;
+            u32 pos_x = regs.src_params.pos_x;
+            u32 pos_y = regs.src_params.pos_y;
+            const u64 offset =
+                Texture::GetGOBOffset(regs.src_params.size_x, regs.src_params.size_y, pos_x, pos_y,
+                                      regs.src_params.BlockDepth(), bytes_per_pixel);
+            const u32 x_in_gob = 64 / bytes_per_pixel;
+            pos_x = pos_x % x_in_gob;
+            pos_y = pos_y % 8;
+
+            if (read_buffer.size() < src_size) {
+                read_buffer.resize(src_size);
+            }
+
+            if (write_buffer.size() < dst_size) {
+                write_buffer.resize(dst_size);
+            }
+
+            if (Settings::IsGPULevelExtreme()) {
+                memory_manager.ReadBlock(source + offset, read_buffer.data(), src_size);
+                memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);
+            } else {
+                memory_manager.ReadBlockUnsafe(source + offset, read_buffer.data(), src_size);
+                memory_manager.ReadBlockUnsafe(dest, write_buffer.data(), dst_size);
+            }
+
+            Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
+                                      regs.src_params.size_x, bytes_per_pixel, read_buffer.data(),
+                                      write_buffer.data(), regs.src_params.BlockHeight(), pos_x,
+                                      pos_y);
+
+            memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
+
+            return;
+        }
         // If the input is tiled and the output is linear, deswizzle the input and copy it over.
         const u32 bytes_per_pixel = regs.dst_pitch / regs.x_count;
         const std::size_t src_size = Texture::CalculateSize(

src/video_core/engines/maxwell_dma.h

@@ -10,6 +10,7 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "video_core/engines/engine_interface.h"
 #include "video_core/gpu.h"
 
 namespace Core {
@@ -27,16 +28,17 @@ namespace Tegra::Engines {
  * https://github.com/envytools/envytools/blob/master/rnndb/fifo/gk104_copy.xml
  */
 
-class MaxwellDMA final {
+class MaxwellDMA final : public EngineInterface {
 public:
     explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
     ~MaxwellDMA() = default;
 
     /// Write the value to the register identified by method.
-    void CallMethod(const GPU::MethodCall& method_call);
+    void CallMethod(u32 method, u32 method_argument, bool is_last_call) override;
 
     /// Write multiple values to the register identified by method.
-    void CallMultiMethod(u32 method, const u32* base_start, u32 amount, u32 methods_pending);
+    void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
+                         u32 methods_pending) override;
 
     struct Regs {
         static constexpr std::size_t NUM_REGS = 0x1D6;

src/video_core/engines/shader_bytecode.h

@@ -813,6 +813,10 @@ union Instruction {
         BitField<49, 1, u64> negate_a;
     } alu_integer;
 
+    union {
+        BitField<43, 1, u64> x;
+    } iadd;
+
     union {
         BitField<39, 1, u64> ftz;
         BitField<32, 1, u64> saturate;

src/video_core/fence_manager.h

@@ -88,7 +88,8 @@ public:
             }
             PopAsyncFlushes();
             if (current_fence->IsSemaphore()) {
-                memory_manager.Write<u32>(current_fence->GetAddress(), current_fence->GetPayload());
+                memory_manager.template Write<u32>(current_fence->GetAddress(),
+                                                   current_fence->GetPayload());
             } else {
                 gpu.IncrementSyncPoint(current_fence->GetPayload());
             }
@@ -134,7 +135,8 @@ private:
             }
             PopAsyncFlushes();
             if (current_fence->IsSemaphore()) {
-                memory_manager.Write<u32>(current_fence->GetAddress(), current_fence->GetPayload());
+                memory_manager.template Write<u32>(current_fence->GetAddress(),
+                                                   current_fence->GetPayload());
             } else {
                 gpu.IncrementSyncPoint(current_fence->GetPayload());
             }

src/video_core/gpu.cpp

@@ -299,19 +299,21 @@ void GPU::CallEngineMethod(const MethodCall& method_call) {
 
     switch (engine) {
     case EngineID::FERMI_TWOD_A:
-        fermi_2d->CallMethod(method_call);
+        fermi_2d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_B:
-        maxwell_3d->CallMethod(method_call);
+        maxwell_3d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        kepler_compute->CallMethod(method_call);
+        kepler_compute->CallMethod(method_call.method, method_call.argument,
+                                   method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        maxwell_dma->CallMethod(method_call);
+        maxwell_dma->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        kepler_memory->CallMethod(method_call);
+        kepler_memory->CallMethod(method_call.method, method_call.argument,
+                                  method_call.IsLastCall());
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
@@ -347,7 +349,27 @@ void GPU::ProcessBindMethod(const MethodCall& method_call) {
     // Bind the current subchannel to the desired engine id.
     LOG_DEBUG(HW_GPU, "Binding subchannel {} to engine {}", method_call.subchannel,
               method_call.argument);
-    bound_engines[method_call.subchannel] = static_cast<EngineID>(method_call.argument);
+    const auto engine_id = static_cast<EngineID>(method_call.argument);
+    bound_engines[method_call.subchannel] = static_cast<EngineID>(engine_id);
+    switch (engine_id) {
+    case EngineID::FERMI_TWOD_A:
+        dma_pusher->BindSubchannel(fermi_2d.get(), method_call.subchannel);
+        break;
+    case EngineID::MAXWELL_B:
+        dma_pusher->BindSubchannel(maxwell_3d.get(), method_call.subchannel);
+        break;
+    case EngineID::KEPLER_COMPUTE_B:
+        dma_pusher->BindSubchannel(kepler_compute.get(), method_call.subchannel);
+        break;
+    case EngineID::MAXWELL_DMA_COPY_A:
+        dma_pusher->BindSubchannel(maxwell_dma.get(), method_call.subchannel);
+        break;
+    case EngineID::KEPLER_INLINE_TO_MEMORY_B:
+        dma_pusher->BindSubchannel(kepler_memory.get(), method_call.subchannel);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", static_cast<u32>(engine_id));
+    }
 }
 
 void GPU::ProcessSemaphoreTriggerMethod() {

src/video_core/macro_interpreter.cpp

@@ -328,7 +328,7 @@ void MacroInterpreter::SetMethodAddress(u32 address) {
 }
 
 void MacroInterpreter::Send(u32 value) {
-    maxwell3d.CallMethodFromMME({method_address.address, value});
+    maxwell3d.CallMethodFromMME(method_address.address, value);
     // Increment the method address by the method increment.
     method_address.address.Assign(method_address.address.Value() +
                                   method_address.increment.Value());

src/video_core/rasterizer_interface.h

@@ -80,6 +80,9 @@ public:
     /// and invalidated
     virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
 
+    /// Notify the host renderer to wait for previous primitive and compute operations.
+    virtual void WaitForIdle() = 0;
+
     /// Notify the rasterizer to send all written commands to the host GPU.
     virtual void FlushCommands() = 0;
 

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -51,10 +51,6 @@ Buffer OGLBufferCache::CreateBlock(VAddr cpu_addr, std::size_t size) {
     return std::make_shared<CachedBufferBlock>(cpu_addr, size);
 }
 
-void OGLBufferCache::WriteBarrier() {
-    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
-}
-
 GLuint OGLBufferCache::ToHandle(const Buffer& buffer) {
     return buffer->GetHandle();
 }

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -59,8 +59,6 @@ protected:
 
     GLuint ToHandle(const Buffer& buffer) override;
 
-    void WriteBarrier() override;
-
     void UploadBlockData(const Buffer& buffer, std::size_t offset, std::size_t size,
                          const u8* data) override;
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -59,14 +59,12 @@ constexpr std::size_t NumSupportedVertexAttributes = 16;
 template <typename Engine, typename Entry>
 Tegra::Texture::FullTextureInfo GetTextureInfo(const Engine& engine, const Entry& entry,
                                                ShaderType shader_type, std::size_t index = 0) {
-    if (entry.IsBindless()) {
-        const Tegra::Texture::TextureHandle tex_handle =
-            engine.AccessConstBuffer32(shader_type, entry.GetBuffer(), entry.GetOffset());
+    if (entry.is_bindless) {
+        const auto tex_handle = engine.AccessConstBuffer32(shader_type, entry.buffer, entry.offset);
         return engine.GetTextureInfo(tex_handle);
     }
     const auto& gpu_profile = engine.AccessGuestDriverProfile();
-    const u32 offset =
-        entry.GetOffset() + static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
+    const u32 offset = entry.offset + static_cast<u32>(index * gpu_profile.GetTextureHandlerSize());
     if constexpr (std::is_same_v<Engine, Tegra::Engines::Maxwell3D>) {
         return engine.GetStageTexture(shader_type, offset);
     } else {
@@ -348,7 +346,7 @@ void RasterizerOpenGL::ConfigureFramebuffers() {
 
     texture_cache.GuardRenderTargets(true);
 
-    View depth_surface = texture_cache.GetDepthBufferSurface();
+    View depth_surface = texture_cache.GetDepthBufferSurface(true);
 
     const auto& regs = gpu.regs;
     UNIMPLEMENTED_IF(regs.rt_separate_frag_data == 0);
@@ -357,7 +355,7 @@ void RasterizerOpenGL::ConfigureFramebuffers() {
     FramebufferCacheKey key;
     const auto colors_count = static_cast<std::size_t>(regs.rt_control.count);
     for (std::size_t index = 0; index < colors_count; ++index) {
-        View color_surface{texture_cache.GetColorBufferSurface(index)};
+        View color_surface{texture_cache.GetColorBufferSurface(index, true)};
         if (!color_surface) {
             continue;
         }
@@ -381,28 +379,52 @@ void RasterizerOpenGL::ConfigureFramebuffers() {
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer_cache.GetFramebuffer(key));
 }
 
-void RasterizerOpenGL::ConfigureClearFramebuffer(bool using_color_fb, bool using_depth_fb,
-                                                 bool using_stencil_fb) {
+void RasterizerOpenGL::ConfigureClearFramebuffer(bool using_color, bool using_depth_stencil) {
     auto& gpu = system.GPU().Maxwell3D();
     const auto& regs = gpu.regs;
 
     texture_cache.GuardRenderTargets(true);
     View color_surface;
-    if (using_color_fb) {
+
+    if (using_color) {
+        // Determine if we have to preserve the contents.
+        // First we have to make sure all clear masks are enabled.
+        bool preserve_contents = !regs.clear_buffers.R || !regs.clear_buffers.G ||
+                                 !regs.clear_buffers.B || !regs.clear_buffers.A;
         const std::size_t index = regs.clear_buffers.RT;
-        color_surface = texture_cache.GetColorBufferSurface(index);
+        if (regs.clear_flags.scissor) {
+            // Then we have to confirm scissor testing clears the whole image.
+            const auto& scissor = regs.scissor_test[0];
+            preserve_contents |= scissor.min_x > 0;
+            preserve_contents |= scissor.min_y > 0;
+            preserve_contents |= scissor.max_x < regs.rt[index].width;
+            preserve_contents |= scissor.max_y < regs.rt[index].height;
+        }
+
+        color_surface = texture_cache.GetColorBufferSurface(index, preserve_contents);
         texture_cache.MarkColorBufferInUse(index);
     }
+
     View depth_surface;
-    if (using_depth_fb || using_stencil_fb) {
-        depth_surface = texture_cache.GetDepthBufferSurface();
+    if (using_depth_stencil) {
+        bool preserve_contents = false;
+        if (regs.clear_flags.scissor) {
+            // For depth stencil clears we only have to confirm scissor test covers the whole image.
+            const auto& scissor = regs.scissor_test[0];
+            preserve_contents |= scissor.min_x > 0;
+            preserve_contents |= scissor.min_y > 0;
+            preserve_contents |= scissor.max_x < regs.zeta_width;
+            preserve_contents |= scissor.max_y < regs.zeta_height;
+        }
+
+        depth_surface = texture_cache.GetDepthBufferSurface(preserve_contents);
         texture_cache.MarkDepthBufferInUse();
     }
     texture_cache.GuardRenderTargets(false);
 
     FramebufferCacheKey key;
-    key.colors[0] = color_surface;
-    key.zeta = depth_surface;
+    key.colors[0] = std::move(color_surface);
+    key.zeta = std::move(depth_surface);
 
     state_tracker.NotifyFramebuffer();
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer_cache.GetFramebuffer(key));
@@ -422,8 +444,7 @@ void RasterizerOpenGL::Clear() {
     if (regs.clear_buffers.R || regs.clear_buffers.G || regs.clear_buffers.B ||
         regs.clear_buffers.A) {
         use_color = true;
-    }
-    if (use_color) {
+
         state_tracker.NotifyColorMask0();
         glColorMaski(0, regs.clear_buffers.R != 0, regs.clear_buffers.G != 0,
                      regs.clear_buffers.B != 0, regs.clear_buffers.A != 0);
@@ -461,7 +482,7 @@ void RasterizerOpenGL::Clear() {
 
     UNIMPLEMENTED_IF(regs.clear_flags.viewport);
 
-    ConfigureClearFramebuffer(use_color, use_depth, use_stencil);
+    ConfigureClearFramebuffer(use_color, use_depth || use_stencil);
 
     if (use_color) {
         glClearBufferfv(GL_COLOR, 0, regs.clear_color);
@@ -725,6 +746,17 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
     InvalidateRegion(addr, size);
 }
 
+void RasterizerOpenGL::WaitForIdle() {
+    // Place a barrier on everything that is not framebuffer related.
+    // This is related to another flag that is not currently implemented.
+    glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT | GL_ELEMENT_ARRAY_BARRIER_BIT |
+                    GL_UNIFORM_BARRIER_BIT | GL_TEXTURE_FETCH_BARRIER_BIT |
+                    GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_COMMAND_BARRIER_BIT |
+                    GL_PIXEL_BUFFER_BARRIER_BIT | GL_TEXTURE_UPDATE_BARRIER_BIT |
+                    GL_BUFFER_UPDATE_BARRIER_BIT | GL_TRANSFORM_FEEDBACK_BARRIER_BIT |
+                    GL_SHADER_STORAGE_BARRIER_BIT | GL_QUERY_BUFFER_BARRIER_BIT);
+}
+
 void RasterizerOpenGL::FlushCommands() {
     // Only flush when we have commands queued to OpenGL.
     if (num_queued_commands == 0) {
@@ -833,9 +865,9 @@ void RasterizerOpenGL::SetupDrawGlobalMemory(std::size_t stage_index, const Shad
 
     u32 binding = device.GetBaseBindings(stage_index).shader_storage_buffer;
     for (const auto& entry : shader->GetEntries().global_memory_entries) {
-        const auto addr{cbufs.const_buffers[entry.GetCbufIndex()].address + entry.GetCbufOffset()};
-        const auto gpu_addr{memory_manager.Read<u64>(addr)};
-        const auto size{memory_manager.Read<u32>(addr + 8)};
+        const GPUVAddr addr{cbufs.const_buffers[entry.cbuf_index].address + entry.cbuf_offset};
+        const GPUVAddr gpu_addr{memory_manager.Read<u64>(addr)};
+        const u32 size{memory_manager.Read<u32>(addr + 8)};
         SetupGlobalMemory(binding++, entry, gpu_addr, size);
     }
 }
@@ -847,7 +879,7 @@ void RasterizerOpenGL::SetupComputeGlobalMemory(const Shader& kernel) {
 
     u32 binding = 0;
     for (const auto& entry : kernel->GetEntries().global_memory_entries) {
-        const auto addr{cbufs[entry.GetCbufIndex()].Address() + entry.GetCbufOffset()};
+        const auto addr{cbufs[entry.cbuf_index].Address() + entry.cbuf_offset};
         const auto gpu_addr{memory_manager.Read<u64>(addr)};
         const auto size{memory_manager.Read<u32>(addr + 8)};
         SetupGlobalMemory(binding++, entry, gpu_addr, size);
@@ -858,7 +890,7 @@ void RasterizerOpenGL::SetupGlobalMemory(u32 binding, const GlobalMemoryEntry& e
                                          GPUVAddr gpu_addr, std::size_t size) {
     const auto alignment{device.GetShaderStorageBufferAlignment()};
     const auto [ssbo, buffer_offset] =
-        buffer_cache.UploadMemory(gpu_addr, size, alignment, entry.IsWritten());
+        buffer_cache.UploadMemory(gpu_addr, size, alignment, entry.is_written);
     glBindBufferRange(GL_SHADER_STORAGE_BUFFER, binding, ssbo, buffer_offset,
                       static_cast<GLsizeiptr>(size));
 }
@@ -869,7 +901,7 @@ void RasterizerOpenGL::SetupDrawTextures(std::size_t stage_index, const Shader&
     u32 binding = device.GetBaseBindings(stage_index).sampler;
     for (const auto& entry : shader->GetEntries().samplers) {
         const auto shader_type = static_cast<ShaderType>(stage_index);
-        for (std::size_t i = 0; i < entry.Size(); ++i) {
+        for (std::size_t i = 0; i < entry.size; ++i) {
             const auto texture = GetTextureInfo(maxwell3d, entry, shader_type, i);
             SetupTexture(binding++, texture, entry);
         }
@@ -881,7 +913,7 @@ void RasterizerOpenGL::SetupComputeTextures(const Shader& kernel) {
     const auto& compute = system.GPU().KeplerCompute();
     u32 binding = 0;
     for (const auto& entry : kernel->GetEntries().samplers) {
-        for (std::size_t i = 0; i < entry.Size(); ++i) {
+        for (std::size_t i = 0; i < entry.size; ++i) {
             const auto texture = GetTextureInfo(compute, entry, ShaderType::Compute, i);
             SetupTexture(binding++, texture, entry);
         }
@@ -938,7 +970,7 @@ void RasterizerOpenGL::SetupImage(u32 binding, const Tegra::Texture::TICEntry& t
     if (!tic.IsBuffer()) {
         view->ApplySwizzle(tic.x_source, tic.y_source, tic.z_source, tic.w_source);
     }
-    if (entry.IsWritten()) {
+    if (entry.is_written) {
         view->MarkAsModified(texture_cache.Tick());
     }
     glBindImageTexture(binding, view->GetTexture(), 0, GL_TRUE, 0, GL_READ_WRITE,
@@ -999,11 +1031,7 @@ void RasterizerOpenGL::SyncDepthClamp() {
     }
     flags[Dirty::DepthClampEnabled] = false;
 
-    const auto& state = gpu.regs.view_volume_clip_control;
-    UNIMPLEMENTED_IF_MSG(state.depth_clamp_far != state.depth_clamp_near,
-                         "Unimplemented depth clamp separation!");
-
-    oglEnable(GL_DEPTH_CLAMP, state.depth_clamp_far || state.depth_clamp_near);
+    oglEnable(GL_DEPTH_CLAMP, gpu.regs.view_volume_clip_control.depth_clamp_disabled == 0);
 }
 
 void RasterizerOpenGL::SyncClipEnabled(u32 clip_mask) {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -75,6 +75,7 @@ public:
     void SignalSyncPoint(u32 value) override;
     void ReleaseFences() override;
     void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
+    void WaitForIdle() override;
     void FlushCommands() override;
     void TickFrame() override;
     bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
@@ -95,7 +96,8 @@ private:
     /// Configures the color and depth framebuffer states.
     void ConfigureFramebuffers();
 
-    void ConfigureClearFramebuffer(bool using_color_fb, bool using_depth_fb, bool using_stencil_fb);
+    /// Configures the color and depth framebuffer for clearing.
+    void ConfigureClearFramebuffer(bool using_color, bool using_depth_stencil);
 
     /// Configures the current constbuffers to use for the draw command.
     void SetupDrawConstBuffers(std::size_t stage_index, const Shader& shader);

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -10,8 +10,6 @@
 #include <thread>
 #include <unordered_set>
 
-#include <boost/functional/hash.hpp>
-
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -28,76 +26,26 @@
 #include "video_core/renderer_opengl/gl_shader_disk_cache.h"
 #include "video_core/renderer_opengl/gl_state_tracker.h"
 #include "video_core/renderer_opengl/utils.h"
+#include "video_core/shader/memory_util.h"
 #include "video_core/shader/registry.h"
 #include "video_core/shader/shader_ir.h"
 
 namespace OpenGL {
 
 using Tegra::Engines::ShaderType;
+using VideoCommon::Shader::GetShaderAddress;
+using VideoCommon::Shader::GetShaderCode;
+using VideoCommon::Shader::GetUniqueIdentifier;
+using VideoCommon::Shader::KERNEL_MAIN_OFFSET;
 using VideoCommon::Shader::ProgramCode;
 using VideoCommon::Shader::Registry;
 using VideoCommon::Shader::ShaderIR;
+using VideoCommon::Shader::STAGE_MAIN_OFFSET;
 
 namespace {
 
-constexpr u32 STAGE_MAIN_OFFSET = 10;
-constexpr u32 KERNEL_MAIN_OFFSET = 0;
-
 constexpr VideoCommon::Shader::CompilerSettings COMPILER_SETTINGS{};
 
-/// Gets the address for the specified shader stage program
-GPUVAddr GetShaderAddress(Core::System& system, Maxwell::ShaderProgram program) {
-    const auto& gpu{system.GPU().Maxwell3D()};
-    const auto& shader_config{gpu.regs.shader_config[static_cast<std::size_t>(program)]};
-    return gpu.regs.code_address.CodeAddress() + shader_config.offset;
-}
-
-/// Gets if the current instruction offset is a scheduler instruction
-constexpr bool IsSchedInstruction(std::size_t offset, std::size_t main_offset) {
-    // Sched instructions appear once every 4 instructions.
-    constexpr std::size_t SchedPeriod = 4;
-    const std::size_t absolute_offset = offset - main_offset;
-    return (absolute_offset % SchedPeriod) == 0;
-}
-
-/// Calculates the size of a program stream
-std::size_t CalculateProgramSize(const ProgramCode& program) {
-    constexpr std::size_t start_offset = 10;
-    // This is the encoded version of BRA that jumps to itself. All Nvidia
-    // shaders end with one.
-    constexpr u64 self_jumping_branch = 0xE2400FFFFF07000FULL;
-    constexpr u64 mask = 0xFFFFFFFFFF7FFFFFULL;
-    std::size_t offset = start_offset;
-    while (offset < program.size()) {
-        const u64 instruction = program[offset];
-        if (!IsSchedInstruction(offset, start_offset)) {
-            if ((instruction & mask) == self_jumping_branch) {
-                // End on Maxwell's "nop" instruction
-                break;
-            }
-            if (instruction == 0) {
-                break;
-            }
-        }
-        offset++;
-    }
-    // The last instruction is included in the program size
-    return std::min(offset + 1, program.size());
-}
-
-/// Gets the shader program code from memory for the specified address
-ProgramCode GetShaderCode(Tegra::MemoryManager& memory_manager, const GPUVAddr gpu_addr,
-                          const u8* host_ptr) {
-    ProgramCode code(VideoCommon::Shader::MAX_PROGRAM_LENGTH);
-    ASSERT_OR_EXECUTE(host_ptr != nullptr, {
-        std::fill(code.begin(), code.end(), 0);
-        return code;
-    });
-    memory_manager.ReadBlockUnsafe(gpu_addr, code.data(), code.size() * sizeof(u64));
-    code.resize(CalculateProgramSize(code));
-    return code;
-}
-
 /// Gets the shader type from a Maxwell program type
 constexpr GLenum GetGLShaderType(ShaderType shader_type) {
     switch (shader_type) {
@@ -114,17 +62,6 @@ constexpr GLenum GetGLShaderType(ShaderType shader_type) {
     }
 }
 
-/// Hashes one (or two) program streams
-u64 GetUniqueIdentifier(ShaderType shader_type, bool is_a, const ProgramCode& code,
-                        const ProgramCode& code_b = {}) {
-    u64 unique_identifier = boost::hash_value(code);
-    if (is_a) {
-        // VertexA programs include two programs
-        boost::hash_combine(unique_identifier, boost::hash_value(code_b));
-    }
-    return unique_identifier;
-}
-
 constexpr const char* GetShaderTypeName(ShaderType shader_type) {
     switch (shader_type) {
     case ShaderType::Vertex:
@@ -456,11 +393,12 @@ Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
     const auto host_ptr{memory_manager.GetPointer(address)};
 
     // No shader found - create a new one
-    ProgramCode code{GetShaderCode(memory_manager, address, host_ptr)};
+    ProgramCode code{GetShaderCode(memory_manager, address, host_ptr, false)};
     ProgramCode code_b;
     if (program == Maxwell::ShaderProgram::VertexA) {
         const GPUVAddr address_b{GetShaderAddress(system, Maxwell::ShaderProgram::VertexB)};
-        code_b = GetShaderCode(memory_manager, address_b, memory_manager.GetPointer(address_b));
+        const u8* host_ptr_b = memory_manager.GetPointer(address_b);
+        code_b = GetShaderCode(memory_manager, address_b, host_ptr_b, false);
     }
 
     const auto unique_identifier = GetUniqueIdentifier(
@@ -498,7 +436,7 @@ Shader ShaderCacheOpenGL::GetComputeKernel(GPUVAddr code_addr) {
 
     const auto host_ptr{memory_manager.GetPointer(code_addr)};
     // No kernel found, create a new one
-    auto code{GetShaderCode(memory_manager, code_addr, host_ptr)};
+    auto code{GetShaderCode(memory_manager, code_addr, host_ptr, true)};
     const auto unique_identifier{GetUniqueIdentifier(ShaderType::Compute, false, code)};
 
     const ShaderParameters params{system,    disk_cache, device,

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -870,13 +870,13 @@ private:
         for (const auto& sampler : ir.GetSamplers()) {
             const std::string name = GetSampler(sampler);
             const std::string description = fmt::format("layout (binding = {}) uniform", binding);
-            binding += sampler.IsIndexed() ? sampler.Size() : 1;
+            binding += sampler.is_indexed ? sampler.size : 1;
 
             std::string sampler_type = [&]() {
-                if (sampler.IsBuffer()) {
+                if (sampler.is_buffer) {
                     return "samplerBuffer";
                 }
-                switch (sampler.GetType()) {
+                switch (sampler.type) {
                 case Tegra::Shader::TextureType::Texture1D:
                     return "sampler1D";
                 case Tegra::Shader::TextureType::Texture2D:
@@ -890,17 +890,17 @@ private:
                     return "sampler2D";
                 }
             }();
-            if (sampler.IsArray()) {
+            if (sampler.is_array) {
                 sampler_type += "Array";
             }
-            if (sampler.IsShadow()) {
+            if (sampler.is_shadow) {
                 sampler_type += "Shadow";
             }
 
-            if (!sampler.IsIndexed()) {
+            if (!sampler.is_indexed) {
                 code.AddLine("{} {} {};", description, sampler_type, name);
             } else {
-                code.AddLine("{} {} {}[{}];", description, sampler_type, name, sampler.Size());
+                code.AddLine("{} {} {}[{}];", description, sampler_type, name, sampler.size);
             }
         }
         if (!ir.GetSamplers().empty()) {
@@ -946,14 +946,14 @@ private:
         u32 binding = device.GetBaseBindings(stage).image;
         for (const auto& image : ir.GetImages()) {
             std::string qualifier = "coherent volatile";
-            if (image.IsRead() && !image.IsWritten()) {
+            if (image.is_read && !image.is_written) {
                 qualifier += " readonly";
-            } else if (image.IsWritten() && !image.IsRead()) {
+            } else if (image.is_written && !image.is_read) {
                 qualifier += " writeonly";
             }
 
-            const char* format = image.IsAtomic() ? "r32ui, " : "";
-            const char* type_declaration = GetImageTypeDeclaration(image.GetType());
+            const char* format = image.is_atomic ? "r32ui, " : "";
+            const char* type_declaration = GetImageTypeDeclaration(image.type);
             code.AddLine("layout ({}binding = {}) {} uniform uimage{} {};", format, binding++,
                          qualifier, type_declaration, GetImage(image));
         }
@@ -1337,8 +1337,8 @@ private:
         ASSERT(meta);
 
         const std::size_t count = operation.GetOperandsCount();
-        const bool has_array = meta->sampler.IsArray();
-        const bool has_shadow = meta->sampler.IsShadow();
+        const bool has_array = meta->sampler.is_array;
+        const bool has_shadow = meta->sampler.is_shadow;
 
         std::string expr = "texture" + function_suffix;
         if (!meta->aoffi.empty()) {
@@ -1346,7 +1346,7 @@ private:
         } else if (!meta->ptp.empty()) {
             expr += "Offsets";
         }
-        if (!meta->sampler.IsIndexed()) {
+        if (!meta->sampler.is_indexed) {
             expr += '(' + GetSampler(meta->sampler) + ", ";
         } else {
             expr += '(' + GetSampler(meta->sampler) + '[' + Visit(meta->index).AsUint() + "], ";
@@ -1870,6 +1870,14 @@ private:
         return GenerateBinaryInfix(operation, ">=", Type::Bool, type, type);
     }
 
+    Expression LogicalAddCarry(Operation operation) {
+        const std::string carry = code.GenerateTemporary();
+        code.AddLine("uint {};", carry);
+        code.AddLine("uaddCarry({}, {}, {});", VisitOperand(operation, 0).AsUint(),
+                     VisitOperand(operation, 1).AsUint(), carry);
+        return {fmt::format("({} != 0)", carry), Type::Bool};
+    }
+
     Expression LogicalFIsNan(Operation operation) {
         return GenerateUnary(operation, "isnan", Type::Bool, Type::Float);
     }
@@ -1974,7 +1982,7 @@ private:
 
         std::string expr = GenerateTexture(
             operation, "", {TextureOffset{}, TextureArgument{Type::Float, meta->bias}});
-        if (meta->sampler.IsShadow()) {
+        if (meta->sampler.is_shadow) {
             expr = "vec4(" + expr + ')';
         }
         return {expr + GetSwizzle(meta->element), Type::Float};
@@ -1986,7 +1994,7 @@ private:
 
         std::string expr = GenerateTexture(
             operation, "Lod", {TextureArgument{Type::Float, meta->lod}, TextureOffset{}});
-        if (meta->sampler.IsShadow()) {
+        if (meta->sampler.is_shadow) {
             expr = "vec4(" + expr + ')';
         }
         return {expr + GetSwizzle(meta->element), Type::Float};
@@ -1995,11 +2003,11 @@ private:
     Expression TextureGather(Operation operation) {
         const auto& meta = std::get<MetaTexture>(operation.GetMeta());
 
-        const auto type = meta.sampler.IsShadow() ? Type::Float : Type::Int;
-        const bool separate_dc = meta.sampler.IsShadow();
+        const auto type = meta.sampler.is_shadow ? Type::Float : Type::Int;
+        const bool separate_dc = meta.sampler.is_shadow;
 
         std::vector<TextureIR> ir;
-        if (meta.sampler.IsShadow()) {
+        if (meta.sampler.is_shadow) {
             ir = {TextureOffset{}};
         } else {
             ir = {TextureOffset{}, TextureArgument{type, meta.component}};
@@ -2044,7 +2052,7 @@ private:
         constexpr std::array constructors = {"int", "ivec2", "ivec3", "ivec4"};
         const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
         ASSERT(meta);
-        UNIMPLEMENTED_IF(meta->sampler.IsArray());
+        UNIMPLEMENTED_IF(meta->sampler.is_array);
         const std::size_t count = operation.GetOperandsCount();
 
         std::string expr = "texelFetch(";
@@ -2065,7 +2073,7 @@ private:
         }
         expr += ')';
 
-        if (meta->lod && !meta->sampler.IsBuffer()) {
+        if (meta->lod && !meta->sampler.is_buffer) {
             expr += ", ";
             expr += Visit(meta->lod).AsInt();
         }
@@ -2076,12 +2084,10 @@ private:
     }
 
     Expression TextureGradient(Operation operation) {
-        const auto meta = std::get_if<MetaTexture>(&operation.GetMeta());
-        ASSERT(meta);
-
+        const auto& meta = std::get<MetaTexture>(operation.GetMeta());
         std::string expr =
             GenerateTexture(operation, "Grad", {TextureDerivates{}, TextureOffset{}});
-        return {std::move(expr) + GetSwizzle(meta->element), Type::Float};
+        return {std::move(expr) + GetSwizzle(meta.element), Type::Float};
     }
 
     Expression ImageLoad(Operation operation) {
@@ -2441,6 +2447,8 @@ private:
         &GLSLDecompiler::LogicalNotEqual<Type::Uint>,
         &GLSLDecompiler::LogicalGreaterEqual<Type::Uint>,
 
+        &GLSLDecompiler::LogicalAddCarry,
+
         &GLSLDecompiler::Logical2HLessThan<false>,
         &GLSLDecompiler::Logical2HEqual<false>,
         &GLSLDecompiler::Logical2HLessEqual<false>,
@@ -2598,11 +2606,11 @@ private:
     }
 
     std::string GetSampler(const Sampler& sampler) const {
-        return AppendSuffix(static_cast<u32>(sampler.GetIndex()), "sampler");
+        return AppendSuffix(sampler.index, "sampler");
     }
 
     std::string GetImage(const Image& image) const {
-        return AppendSuffix(static_cast<u32>(image.GetIndex()), "image");
+        return AppendSuffix(image.index, "image");
     }
 
     std::string AppendSuffix(u32 index, std::string_view name) const {

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -33,36 +33,19 @@ public:
     }
 
 private:
-    u32 index{};
+    u32 index = 0;
 };
 
-class GlobalMemoryEntry {
-public:
-    explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read, bool is_written)
+struct GlobalMemoryEntry {
+    constexpr explicit GlobalMemoryEntry(u32 cbuf_index, u32 cbuf_offset, bool is_read,
+                                         bool is_written)
         : cbuf_index{cbuf_index}, cbuf_offset{cbuf_offset}, is_read{is_read}, is_written{
                                                                                   is_written} {}
 
-    u32 GetCbufIndex() const {
-        return cbuf_index;
-    }
-
-    u32 GetCbufOffset() const {
-        return cbuf_offset;
-    }
-
-    bool IsRead() const {
-        return is_read;
-    }
-
-    bool IsWritten() const {
-        return is_written;
-    }
-
-private:
-    u32 cbuf_index{};
-    u32 cbuf_offset{};
-    bool is_read{};
-    bool is_written{};
+    u32 cbuf_index = 0;
+    u32 cbuf_offset = 0;
+    bool is_read = false;
+    bool is_written = false;
 };
 
 struct ShaderEntries {

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -177,14 +177,19 @@ const char* GetType(GLenum type) {
 
 void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
                            const GLchar* message, const void* user_param) {
-    const char format[] = "{} {} {}: {}";
+    static constexpr char format[] = "{} {} {}: {}";
+    if (severity == GL_DEBUG_SEVERITY_HIGH) {
+        LOG_CRITICAL(Render_OpenGL, format, GetSource(source), GetType(type), id, message);
+        return;
+    }
+
+    if (!Settings::values.renderer_debug) {
+        return;
+    }
     const char* const str_source = GetSource(source);
     const char* const str_type = GetType(type);
 
     switch (severity) {
-    case GL_DEBUG_SEVERITY_HIGH:
-        LOG_CRITICAL(Render_OpenGL, format, str_source, str_type, id, message);
-        break;
     case GL_DEBUG_SEVERITY_MEDIUM:
         LOG_WARNING(Render_OpenGL, format, str_source, str_type, id, message);
         break;

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -81,7 +81,7 @@ void FixedPipelineState::Rasterizer::Fill(const Maxwell& regs) noexcept {
     primitive_restart_enable.Assign(regs.primitive_restart.enabled != 0 ? 1 : 0);
     cull_enable.Assign(regs.cull_test_enabled != 0 ? 1 : 0);
     depth_bias_enable.Assign(enabled_lut[POLYGON_OFFSET_ENABLE_LUT[topology_index]] != 0 ? 1 : 0);
-    depth_clamp_enable.Assign(clip.depth_clamp_near == 1 || clip.depth_clamp_far == 1 ? 1 : 0);
+    depth_clamp_disabled.Assign(regs.view_volume_clip_control.depth_clamp_disabled.Value());
     ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
     cull_face.Assign(PackCullFace(regs.cull_face));
     front_face.Assign(packed_front_face);

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -153,7 +153,7 @@ struct FixedPipelineState {
             BitField<4, 1, u32> primitive_restart_enable;
             BitField<5, 1, u32> cull_enable;
             BitField<6, 1, u32> depth_bias_enable;
-            BitField<7, 1, u32> depth_clamp_enable;
+            BitField<7, 1, u32> depth_clamp_disabled;
             BitField<8, 1, u32> ndc_minus_one_to_one;
             BitField<9, 2, u32> cull_face;
             BitField<11, 1, u32> front_face;

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -12,15 +12,12 @@
 
 #include <fmt/format.h>
 
-#include "common/assert.h"
 #include "common/dynamic_library.h"
 #include "common/logging/log.h"
 #include "common/telemetry.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/frontend/emu_window.h"
-#include "core/memory.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 #include "video_core/gpu.h"

src/video_core/renderer_vulkan/renderer_vulkan.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <optional>
 #include <string>
 #include <vector>
 

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <memory>
 #include <tuple>
 

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -5,11 +5,7 @@
 #include <algorithm>
 #include <cstring>
 #include <memory>
-#include <optional>
-#include <tuple>
 
-#include "common/assert.h"
-#include "common/bit_util.h"
 #include "core/core.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_device.h"

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -5,14 +5,11 @@
 #pragma once
 
 #include <memory>
-#include <unordered_map>
-#include <vector>
 
 #include "common/common_types.h"
 #include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/rasterizer_cache.h"
 #include "video_core/renderer_vulkan/vk_memory_manager.h"
-#include "video_core/renderer_vulkan/vk_resource_manager.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_stream_buffer.h"
 #include "video_core/renderer_vulkan/wrapper.h"
@@ -55,8 +52,6 @@ public:
 protected:
     VkBuffer ToHandle(const Buffer& buffer) override;
 
-    void WriteBarrier() override {}
-
     Buffer CreateBlock(VAddr cpu_addr, std::size_t size) override;
 
     void UploadBlockData(const Buffer& buffer, std::size_t offset, std::size_t size,

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -6,7 +6,7 @@
 #include <memory>
 #include <optional>
 #include <utility>
-#include <vector>
+
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"

src/video_core/renderer_vulkan/vk_compute_pass.h

@@ -6,7 +6,7 @@
 
 #include <optional>
 #include <utility>
-#include <vector>
+
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -2,14 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
 #include <vector>
 
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
-#include "video_core/renderer_vulkan/vk_resource_manager.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_decompiler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"

src/video_core/renderer_vulkan/vk_compute_pipeline.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <memory>
-
 #include "common/common_types.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_shader_decompiler.h"

src/video_core/renderer_vulkan/vk_descriptor_pool.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <memory>
 #include <vector>
 
 #include "common/common_types.h"

src/video_core/renderer_vulkan/vk_descriptor_pool.h

@@ -4,10 +4,8 @@
 
 #pragma once
 
-#include <memory>
 #include <vector>
 
-#include "common/common_types.h"
 #include "video_core/renderer_vulkan/vk_resource_manager.h"
 #include "video_core/renderer_vulkan/wrapper.h"
 

src/video_core/renderer_vulkan/vk_device.cpp

@@ -4,7 +4,6 @@
 
 #include <bitset>
 #include <chrono>
-#include <cstdlib>
 #include <optional>
 #include <string_view>
 #include <thread>
@@ -294,6 +293,17 @@ bool VKDevice::Create() {
         LOG_INFO(Render_Vulkan, "Device doesn't support transform feedbacks");
     }
 
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT custom_border;
+    if (ext_custom_border_color) {
+        custom_border.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+        custom_border.pNext = nullptr;
+        custom_border.customBorderColors = VK_TRUE;
+        custom_border.customBorderColorWithoutFormat = VK_TRUE;
+        SetNext(next, custom_border);
+    } else {
+        LOG_INFO(Render_Vulkan, "Device doesn't support custom border colors");
+    }
+
     if (!ext_depth_range_unrestricted) {
         LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
     }
@@ -521,6 +531,7 @@ std::vector<const char*> VKDevice::LoadExtensions() {
     bool has_khr_shader_float16_int8{};
     bool has_ext_subgroup_size_control{};
     bool has_ext_transform_feedback{};
+    bool has_ext_custom_border_color{};
     for (const auto& extension : physical.EnumerateDeviceExtensionProperties()) {
         Test(extension, khr_uniform_buffer_standard_layout,
              VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
@@ -535,6 +546,8 @@ std::vector<const char*> VKDevice::LoadExtensions() {
              false);
         Test(extension, has_ext_transform_feedback, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME,
              false);
+        Test(extension, has_ext_custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME,
+             false);
         if (Settings::values.renderer_debug) {
             Test(extension, nv_device_diagnostics_config,
                  VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME, true);
@@ -607,6 +620,19 @@ std::vector<const char*> VKDevice::LoadExtensions() {
         }
     }
 
+    if (has_ext_custom_border_color) {
+        VkPhysicalDeviceCustomBorderColorFeaturesEXT border_features;
+        border_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+        border_features.pNext = nullptr;
+        features.pNext = &border_features;
+        physical.GetFeatures2KHR(features);
+
+        if (border_features.customBorderColors && border_features.customBorderColorWithoutFormat) {
+            extensions.push_back(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+            ext_custom_border_color = true;
+        }
+    }
+
     return extensions;
 }