"Merge Tagged PR 1340"

"Merge Tagged PR 4836"
"Merge Tagged PR 5896"
2021-03-05 13:02:40 +00:00 · 2021-03-05 13:02:37 +00:00 · 2021-03-05 13:02:36 +00:00 · 2021-03-04 23:59:06 -08:00 · 2021-03-04 11:07:31 -08:00 · 2021-03-03 15:45:32 -08:00
52 changed files with 916 additions and 462 deletions
@@ -29,22 +29,19 @@ assert_noinline_call(const Fn& fn) {
 }

 #define ASSERT(_a_)                                                                                \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+        LOG_CRITICAL(Debug, "Assertion Failed!");                                                  \
+    }

 #define ASSERT_MSG(_a_, ...)                                                                       \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+        LOG_CRITICAL(Debug, "Assertion Failed! " __VA_ARGS__);                                     \
+    }

-#define UNREACHABLE() assert_noinline_call([] { LOG_CRITICAL(Debug, "Unreachable code!"); })
+#define UNREACHABLE()                                                                              \
+    { LOG_CRITICAL(Debug, "Unreachable code!"); }
 #define UNREACHABLE_MSG(...)                                                                       \
-    assert_noinline_call([&] { LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__); })
+    { LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__); }

 #ifdef _DEBUG
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
@@ -52,9 +52,13 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-// Defined in Misc.cpp.
+// Defined in misc.cpp.
 [[nodiscard]] std::string GetLastErrorMsg();

+// Like GetLastErrorMsg(), but passing an explicit error code.
+// Defined in misc.cpp.
+[[nodiscard]] std::string NativeErrorToString(int e);
+
 #define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
    [[nodiscard]] constexpr type operator|(type a, type b) noexcept {                              \
        using T = std::underlying_type_t<type>;                                                    \
@@ -24,7 +24,7 @@ struct Fiber::FiberImpl {
    std::function<void(void*)> rewind_point;
    void* rewind_parameter{};
    void* start_parameter{};
-    std::shared_ptr<Fiber> previous_fiber;
+    Fiber* previous_fiber;
    bool is_thread_fiber{};
    bool released{};

@@ -47,7 +47,7 @@ void Fiber::Start(boost::context::detail::transfer_t& transfer) {
    ASSERT(impl->previous_fiber != nullptr);
    impl->previous_fiber->impl->context = transfer.fctx;
    impl->previous_fiber->impl->guard.unlock();
-    impl->previous_fiber.reset();
+    impl->previous_fiber = nullptr;
    impl->entry_point(impl->start_parameter);
    UNREACHABLE();
 }
@@ -116,20 +116,20 @@ void Fiber::Rewind() {
    boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }

-void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
+void Fiber::YieldTo(Fiber* from, Fiber* to) {
    ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
    ASSERT_MSG(to != nullptr, "Next fiber is null!");
    to->impl->guard.lock();
    to->impl->previous_fiber = from;
-    auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get());
+    auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to);
    ASSERT(from->impl->previous_fiber != nullptr);
    from->impl->previous_fiber->impl->context = transfer.fctx;
    from->impl->previous_fiber->impl->guard.unlock();
-    from->impl->previous_fiber.reset();
+    from->impl->previous_fiber = nullptr;
 }

-std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
-    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
+std::unique_ptr<Fiber> Fiber::ThreadToFiber() {
+    std::unique_ptr<Fiber> fiber = std::unique_ptr<Fiber>{new Fiber()};
    fiber->impl->guard.lock();
    fiber->impl->is_thread_fiber = true;
    return fiber;
@@ -41,8 +41,8 @@ public:

    /// Yields control from Fiber 'from' to Fiber 'to'
    /// Fiber 'from' must be the currently running fiber.
-    static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to);
-    [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
+    static void YieldTo(Fiber* from, Fiber* to);
+    [[nodiscard]] static std::unique_ptr<Fiber> ThreadToFiber();

    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);

@@ -12,27 +12,41 @@

 #include "common/common_funcs.h"

-// Generic function to get last error message.
-// Call directly after the command or use the error num.
-// This function might change the error code.
-std::string GetLastErrorMsg() {
-    static constexpr std::size_t buff_size = 255;
-    char err_str[buff_size];
-
+std::string NativeErrorToString(int e) {
 #ifdef _WIN32
-    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
-                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
-    return std::string(err_str, buff_size);
-#elif defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
+    LPSTR err_str;
+
+    DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                   FORMAT_MESSAGE_IGNORE_INSERTS,
+                               nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
+    if (!res) {
+        return "(FormatMessageA failed to format error)";
+    }
+    std::string ret(err_str);
+    LocalFree(err_str);
+    return ret;
+#else
+    char err_str[255];
+#if defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
    // Thread safe (GNU-specific)
-    const char* str = strerror_r(errno, err_str, buff_size);
+    const char* str = strerror_r(e, err_str, sizeof(err_str));
    return std::string(str);
 #else
    // Thread safe (XSI-compliant)
-    const int success = strerror_r(errno, err_str, buff_size);
-    if (success != 0) {
-        return {};
+    int second_err = strerror_r(e, err_str, sizeof(err_str));
+    if (second_err != 0) {
+        return "(strerror_r failed to format error)";
    }
    return std::string(err_str);
+#endif // GLIBC etc.
+#endif // _WIN32
+}
+
+std::string GetLastErrorMsg() {
+#ifdef _WIN32
+    return NativeErrorToString(GetLastError());
+#else
+    return NativeErrorToString(errno);
 #endif
 }
@@ -299,28 +299,17 @@ struct System::Impl {
            gpu_core->WaitIdle();
        }

-        // Shutdown emulation session
        services.reset();
        service_manager.reset();
        cheat_engine.reset();
        telemetry_session.reset();
-
-        // Close all CPU/threading state
        cpu_manager.Shutdown();
-
-        // Release the Time Manager's resources
        time_manager.Shutdown();
-
-        // Shutdown kernel and core timing
        core_timing.Shutdown();
-        kernel.Shutdown();
-
-        // Close app loader
        app_loader.reset();
        gpu_core.reset();
        perf_stats.reset();
-
-        // Clear all applets
+        kernel.Shutdown();
        applet_manager.ClearAll();

        LOG_DEBUG(Core, "Shutdown OK");
@@ -111,7 +111,7 @@ void CpuManager::MultiCoreRunGuestThread() {
    auto& kernel = system.Kernel();
    kernel.CurrentScheduler()->OnThreadStart();
    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
-    auto& host_context = thread->GetHostContext();
+    auto host_context = thread->GetHostContext();
    host_context->SetRewindPoint(GuestRewindFunction, this);
    MultiCoreRunGuestLoop();
 }
@@ -148,7 +148,8 @@ void CpuManager::MultiCoreRunSuspendThread() {
        auto core = kernel.GetCurrentHostThreadID();
        auto& scheduler = *kernel.CurrentScheduler();
        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
-        Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[core].host_context);
+        Common::Fiber::YieldTo(current_thread->GetHostContext(),
+                               core_data[core].host_context.get());
        ASSERT(scheduler.ContextSwitchPending());
        ASSERT(core == kernel.GetCurrentHostThreadID());
        scheduler.RescheduleCurrentCore();
@@ -201,7 +202,7 @@ void CpuManager::SingleCoreRunGuestThread() {
    auto& kernel = system.Kernel();
    kernel.CurrentScheduler()->OnThreadStart();
    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
-    auto& host_context = thread->GetHostContext();
+    auto host_context = thread->GetHostContext();
    host_context->SetRewindPoint(GuestRewindFunction, this);
    SingleCoreRunGuestLoop();
 }
@@ -245,7 +246,7 @@ void CpuManager::SingleCoreRunSuspendThread() {
        auto core = kernel.GetCurrentHostThreadID();
        auto& scheduler = *kernel.CurrentScheduler();
        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
-        Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context);
+        Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context.get());
        ASSERT(scheduler.ContextSwitchPending());
        ASSERT(core == kernel.GetCurrentHostThreadID());
        scheduler.RescheduleCurrentCore();
@@ -363,7 +364,7 @@ void CpuManager::RunThread(std::size_t core) {

        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
        data.is_running = true;
-        Common::Fiber::YieldTo(data.host_context, current_thread->GetHostContext());
+        Common::Fiber::YieldTo(data.host_context.get(), current_thread->GetHostContext());
        data.is_running = false;
        data.is_paused = true;
        data.exit_barrier->Wait();
@@ -83,7 +83,7 @@ private:
    void RunThread(std::size_t core);

    struct CoreData {
-        std::shared_ptr<Common::Fiber> host_context;
+        std::unique_ptr<Common::Fiber> host_context;
        std::unique_ptr<Common::Event> enter_barrier;
        std::unique_ptr<Common::Event> exit_barrier;
        std::atomic<bool> is_running;
@@ -608,7 +608,7 @@ void KScheduler::YieldToAnyThread(KernelCore& kernel) {
 }

 KScheduler::KScheduler(Core::System& system, s32 core_id) : system(system), core_id(core_id) {
-    switch_fiber = std::make_shared<Common::Fiber>(OnSwitch, this);
+    switch_fiber = std::make_unique<Common::Fiber>(OnSwitch, this);
    state.needs_scheduling.store(true);
    state.interrupt_task_thread_runnable = false;
    state.should_count_idle = false;
@@ -726,15 +726,15 @@ void KScheduler::ScheduleImpl() {
    // Save context for previous thread
    Unload(previous_thread);

-    std::shared_ptr<Common::Fiber>* old_context;
+    Common::Fiber* old_context;
    if (previous_thread != nullptr) {
-        old_context = &previous_thread->GetHostContext();
+        old_context = previous_thread->GetHostContext();
    } else {
-        old_context = &idle_thread->GetHostContext();
+        old_context = idle_thread->GetHostContext();
    }
    guard.unlock();

-    Common::Fiber::YieldTo(*old_context, switch_fiber);
+    Common::Fiber::YieldTo(old_context, switch_fiber.get());
    /// When a thread wakes up, the scheduler may have changed to other in another core.
    auto& next_scheduler = *system.Kernel().CurrentScheduler();
    next_scheduler.SwitchContextStep2();
@@ -769,13 +769,13 @@ void KScheduler::SwitchToCurrent() {
                    break;
                }
            }
-            std::shared_ptr<Common::Fiber>* next_context;
+            Common::Fiber* next_context;
            if (next_thread != nullptr) {
-                next_context = &next_thread->GetHostContext();
+                next_context = next_thread->GetHostContext();
            } else {
-                next_context = &idle_thread->GetHostContext();
+                next_context = idle_thread->GetHostContext();
            }
-            Common::Fiber::YieldTo(switch_fiber, *next_context);
+            Common::Fiber::YieldTo(switch_fiber.get(), next_context);
        } while (!is_switch_pending());
    }
 }
@@ -68,12 +68,12 @@ public:

    void OnThreadStart();

-    [[nodiscard]] std::shared_ptr<Common::Fiber>& ControlContext() {
-        return switch_fiber;
+    [[nodiscard]] Common::Fiber* ControlContext() {
+        return switch_fiber.get();
    }

-    [[nodiscard]] const std::shared_ptr<Common::Fiber>& ControlContext() const {
-        return switch_fiber;
+    [[nodiscard]] const Common::Fiber* ControlContext() const {
+        return switch_fiber.get();
    }

    [[nodiscard]] u64 UpdateHighestPriorityThread(KThread* highest_thread);
@@ -178,7 +178,7 @@ private:

    KThread* idle_thread;

-    std::shared_ptr<Common::Fiber> switch_fiber{};
+    std::unique_ptr<Common::Fiber> switch_fiber{};

    struct SchedulingState {
        std::atomic<bool> needs_scheduling;
@@ -991,10 +991,6 @@ void KThread::SetState(ThreadState state) {
    }
 }

-std::shared_ptr<Common::Fiber>& KThread::GetHostContext() {
-    return host_context;
-}
-
 ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, ThreadType type_flags,
                                                    std::string name, VAddr entry_point,
                                                    u32 priority, u64 arg, s32 processor_id,
@@ -1028,7 +1024,7 @@ ResultVal<std::shared_ptr<KThread>> KThread::Create(Core::System& system, Thread
    scheduler.AddThread(thread);

    thread->host_context =
-        std::make_shared<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);
+        std::make_unique<Common::Fiber>(std::move(thread_start_func), thread_start_parameter);

    return MakeResult<std::shared_ptr<KThread>>(std::move(thread));
 }
@@ -293,7 +293,13 @@ public:
        return thread_context_64;
    }

-    [[nodiscard]] std::shared_ptr<Common::Fiber>& GetHostContext();
+    [[nodiscard]] Common::Fiber* GetHostContext() {
+        return host_context.get();
+    }
+
+    [[nodiscard]] const Common::Fiber* GetHostContext() const {
+        return host_context.get();
+    }

    [[nodiscard]] ThreadState GetState() const {
        return thread_state & ThreadState::Mask;
@@ -719,7 +725,7 @@ private:
    Common::SpinLock context_guard{};

    // For emulation
-    std::shared_ptr<Common::Fiber> host_context{};
+    std::unique_ptr<Common::Fiber> host_context{};

    // For debugging
    std::vector<KSynchronizationObject*> wait_objects_for_debugging;
@@ -2626,8 +2626,7 @@ void Call(Core::System& system, u32 immediate) {
    kernel.ExitSVCProfile();

    if (!thread->IsCallingSvc()) {
-        auto* host_context = thread->GetHostContext().get();
-        host_context->Rewind();
+        thread->GetHostContext()->Rewind();
    }

    system.EnterDynarmicProfile();
@@ -156,7 +156,7 @@ public:
        is_initialized = true;

        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
+        rb.Push(ERROR_DISABLED);
    }

 private:
@@ -36,6 +36,7 @@ NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
                LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
                Tegra::ChCommandHeaderList cmdlist{{0xDEADB33F}};
                system.GPU().PushCommandBuffer(cmdlist);
+                system.GPU().MemoryManager().InvalidateQueuedCaches();
            }
            return UnmapBuffer(input, output);
        }
@@ -193,7 +193,13 @@ NvResult nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vec
            return NvResult::InvalidState;
        }
        if (const auto size{RemoveBufferMap(object->dma_map_addr)}; size) {
-            gpu.MemoryManager().Unmap(object->dma_map_addr, *size);
+            if (vic_device) {
+                // UnmapVicFrame defers texture_cache invalidation of the frame address until
+                // the stream is over
+                gpu.MemoryManager().UnmapVicFrame(object->dma_map_addr, *size);
+            } else {
+                gpu.MemoryManager().Unmap(object->dma_map_addr, *size);
+            }
        } else {
            // This occurs quite frequently, however does not seem to impact functionality
            LOG_DEBUG(Service_NVDRV, "invalid offset=0x{:X} dma=0x{:X}", object->addr,
@@ -160,6 +160,7 @@ protected:

    s32_le nvmap_fd{};
    u32_le submit_timeout{};
+    bool vic_device{};
    std::shared_ptr<nvmap> nvmap_dev;
    SyncpointManager& syncpoint_manager;
    std::array<u32, MaxSyncPoints> device_syncpoints{};
@@ -12,8 +12,9 @@
 namespace Service::Nvidia::Devices {
 nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
                       SyncpointManager& syncpoint_manager)
-    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {}
-
+    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {
+    vic_device = true;
+}
 nvhost_vic::~nvhost_vic() = default;

 NvResult nvhost_vic::Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
@@ -7,6 +7,7 @@
 #include <limits>
 #include <utility>
 #include <vector>
+#include "common/common_funcs.h"

 #ifdef _WIN32
 #define _WINSOCK_DEPRECATED_NO_WARNINGS // gethostname
@@ -90,15 +91,36 @@ LINGER MakeLinger(bool enable, u32 linger_value) {
    return value;
 }

-int LastError() {
-    return WSAGetLastError();
-}
-
 bool EnableNonBlock(SOCKET fd, bool enable) {
    u_long value = enable ? 1 : 0;
    return ioctlsocket(fd, FIONBIO, &value) != SOCKET_ERROR;
 }

+Errno TranslateNativeError(int e) {
+    switch (e) {
+    case WSAEBADF:
+        return Errno::BADF;
+    case WSAEINVAL:
+        return Errno::INVAL;
+    case WSAEMFILE:
+        return Errno::MFILE;
+    case WSAENOTCONN:
+        return Errno::NOTCONN;
+    case WSAEWOULDBLOCK:
+        return Errno::AGAIN;
+    case WSAECONNREFUSED:
+        return Errno::CONNREFUSED;
+    case WSAEHOSTUNREACH:
+        return Errno::HOSTUNREACH;
+    case WSAENETDOWN:
+        return Errno::NETDOWN;
+    case WSAENETUNREACH:
+        return Errno::NETUNREACH;
+    default:
+        return Errno::OTHER;
+    }
+}
+
 #elif YUZU_UNIX // ^ _WIN32 v YUZU_UNIX

 using SOCKET = int;
@@ -108,9 +130,6 @@ using ULONG = u64;
 constexpr SOCKET INVALID_SOCKET = -1;
 constexpr SOCKET SOCKET_ERROR = -1;

-constexpr int WSAEWOULDBLOCK = EAGAIN;
-constexpr int WSAENOTCONN = ENOTCONN;
-
 constexpr int SD_RECEIVE = SHUT_RD;
 constexpr int SD_SEND = SHUT_WR;
 constexpr int SD_BOTH = SHUT_RDWR;
@@ -162,10 +181,6 @@ linger MakeLinger(bool enable, u32 linger_value) {
    return value;
 }

-int LastError() {
-    return errno;
-}
-
 bool EnableNonBlock(int fd, bool enable) {
    int flags = fcntl(fd, F_GETFD);
    if (flags == -1) {
@@ -179,8 +194,43 @@ bool EnableNonBlock(int fd, bool enable) {
    return fcntl(fd, F_SETFD, flags) == 0;
 }

+Errno TranslateNativeError(int e) {
+    switch (e) {
+    case EBADF:
+        return Errno::BADF;
+    case EINVAL:
+        return Errno::INVAL;
+    case EMFILE:
+        return Errno::MFILE;
+    case ENOTCONN:
+        return Errno::NOTCONN;
+    case EAGAIN:
+        return Errno::AGAIN;
+    case ECONNREFUSED:
+        return Errno::CONNREFUSED;
+    case EHOSTUNREACH:
+        return Errno::HOSTUNREACH;
+    case ENETDOWN:
+        return Errno::NETDOWN;
+    case ENETUNREACH:
+        return Errno::NETUNREACH;
+    default:
+        return Errno::OTHER;
+    }
+}
+
 #endif

+Errno GetAndLogLastError() {
+#ifdef _WIN32
+    int e = WSAGetLastError();
+#else
+    int e = errno;
+#endif
+    LOG_ERROR(Network, "Socket operation error: {}", NativeErrorToString(e));
+    return TranslateNativeError(e);
+}
+
 int TranslateDomain(Domain domain) {
    switch (domain) {
    case Domain::INET:
@@ -290,9 +340,7 @@ Errno SetSockOpt(SOCKET fd, int option, T value) {
    if (result != SOCKET_ERROR) {
        return Errno::SUCCESS;
    }
-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return Errno::SUCCESS;
+    return GetAndLogLastError();
 }

 } // Anonymous namespace
@@ -308,14 +356,12 @@ NetworkInstance::~NetworkInstance() {
 std::pair<IPv4Address, Errno> GetHostIPv4Address() {
    std::array<char, 256> name{};
    if (gethostname(name.data(), static_cast<int>(name.size()) - 1) == SOCKET_ERROR) {
-        UNIMPLEMENTED_MSG("Unhandled gethostname error");
-        return {IPv4Address{}, Errno::SUCCESS};
+        return {IPv4Address{}, GetAndLogLastError()};
    }

    hostent* const ent = gethostbyname(name.data());
    if (!ent) {
-        UNIMPLEMENTED_MSG("Unhandled gethostbyname error");
-        return {IPv4Address{}, Errno::SUCCESS};
+        return {IPv4Address{}, GetAndLogLastError()};
    }
    if (ent->h_addr_list == nullptr) {
        UNIMPLEMENTED_MSG("No addr provided in hostent->h_addr_list");
@@ -359,9 +405,7 @@ std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {

    ASSERT(result == SOCKET_ERROR);

-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return {-1, Errno::SUCCESS};
+    return {-1, GetAndLogLastError()};
 }

 Socket::~Socket() {
@@ -380,9 +424,7 @@ Errno Socket::Initialize(Domain domain, Type type, Protocol protocol) {
        return Errno::SUCCESS;
    }

-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return Errno::SUCCESS;
+    return GetAndLogLastError();
 }

 std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
@@ -391,9 +433,7 @@ std::pair<Socket::AcceptResult, Errno> Socket::Accept() {
    const SOCKET new_socket = accept(fd, &addr, &addrlen);

    if (new_socket == INVALID_SOCKET) {
-        const int ec = LastError();
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {AcceptResult{}, Errno::SUCCESS};
+        return {AcceptResult{}, GetAndLogLastError()};
    }

    AcceptResult result;
@@ -412,23 +452,14 @@ Errno Socket::Connect(SockAddrIn addr_in) {
        return Errno::SUCCESS;
    }

-    switch (const int ec = LastError()) {
-    case WSAEWOULDBLOCK:
-        LOG_DEBUG(Service, "EAGAIN generated");
-        return Errno::AGAIN;
-    default:
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return Errno::SUCCESS;
-    }
+    return GetAndLogLastError();
 }

 std::pair<SockAddrIn, Errno> Socket::GetPeerName() {
    sockaddr addr;
    socklen_t addrlen = sizeof(addr);
    if (getpeername(fd, &addr, &addrlen) == SOCKET_ERROR) {
-        const int ec = LastError();
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {SockAddrIn{}, Errno::SUCCESS};
+        return {SockAddrIn{}, GetAndLogLastError()};
    }

    ASSERT(addrlen == sizeof(sockaddr_in));
@@ -439,9 +470,7 @@ std::pair<SockAddrIn, Errno> Socket::GetSockName() {
    sockaddr addr;
    socklen_t addrlen = sizeof(addr);
    if (getsockname(fd, &addr, &addrlen) == SOCKET_ERROR) {
-        const int ec = LastError();
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {SockAddrIn{}, Errno::SUCCESS};
+        return {SockAddrIn{}, GetAndLogLastError()};
    }

    ASSERT(addrlen == sizeof(sockaddr_in));
@@ -454,9 +483,7 @@ Errno Socket::Bind(SockAddrIn addr) {
        return Errno::SUCCESS;
    }

-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return Errno::SUCCESS;
+    return GetAndLogLastError();
 }

 Errno Socket::Listen(s32 backlog) {
@@ -464,9 +491,7 @@ Errno Socket::Listen(s32 backlog) {
        return Errno::SUCCESS;
    }

-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return Errno::SUCCESS;
+    return GetAndLogLastError();
 }

 Errno Socket::Shutdown(ShutdownHow how) {
@@ -489,14 +514,7 @@ Errno Socket::Shutdown(ShutdownHow how) {
        return Errno::SUCCESS;
    }

-    switch (const int ec = LastError()) {
-    case WSAENOTCONN:
-        LOG_ERROR(Service, "ENOTCONN generated");
-        return Errno::NOTCONN;
-    default:
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return Errno::SUCCESS;
-    }
+    return GetAndLogLastError();
 }

 std::pair<s32, Errno> Socket::Recv(int flags, std::vector<u8>& message) {
@@ -509,17 +527,7 @@ std::pair<s32, Errno> Socket::Recv(int flags, std::vector<u8>& message) {
        return {static_cast<s32>(result), Errno::SUCCESS};
    }

-    switch (const int ec = LastError()) {
-    case WSAEWOULDBLOCK:
-        LOG_DEBUG(Service, "EAGAIN generated");
-        return {-1, Errno::AGAIN};
-    case WSAENOTCONN:
-        LOG_ERROR(Service, "ENOTCONN generated");
-        return {-1, Errno::NOTCONN};
-    default:
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {0, Errno::SUCCESS};
-    }
+    return {-1, GetAndLogLastError()};
 }

 std::pair<s32, Errno> Socket::RecvFrom(int flags, std::vector<u8>& message, SockAddrIn* addr) {
@@ -541,17 +549,7 @@ std::pair<s32, Errno> Socket::RecvFrom(int flags, std::vector<u8>& message, Sock
        return {static_cast<s32>(result), Errno::SUCCESS};
    }

-    switch (const int ec = LastError()) {
-    case WSAEWOULDBLOCK:
-        LOG_DEBUG(Service, "EAGAIN generated");
-        return {-1, Errno::AGAIN};
-    case WSAENOTCONN:
-        LOG_ERROR(Service, "ENOTCONN generated");
-        return {-1, Errno::NOTCONN};
-    default:
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {-1, Errno::SUCCESS};
-    }
+    return {-1, GetAndLogLastError()};
 }

 std::pair<s32, Errno> Socket::Send(const std::vector<u8>& message, int flags) {
@@ -564,18 +562,7 @@ std::pair<s32, Errno> Socket::Send(const std::vector<u8>& message, int flags) {
        return {static_cast<s32>(result), Errno::SUCCESS};
    }

-    const int ec = LastError();
-    switch (ec) {
-    case WSAEWOULDBLOCK:
-        LOG_DEBUG(Service, "EAGAIN generated");
-        return {-1, Errno::AGAIN};
-    case WSAENOTCONN:
-        LOG_ERROR(Service, "ENOTCONN generated");
-        return {-1, Errno::NOTCONN};
-    default:
-        UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-        return {-1, Errno::SUCCESS};
-    }
+    return {-1, GetAndLogLastError()};
 }

 std::pair<s32, Errno> Socket::SendTo(u32 flags, const std::vector<u8>& message,
@@ -597,9 +584,7 @@ std::pair<s32, Errno> Socket::SendTo(u32 flags, const std::vector<u8>& message,
        return {static_cast<s32>(result), Errno::SUCCESS};
    }

-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return {-1, Errno::SUCCESS};
+    return {-1, GetAndLogLastError()};
 }

 Errno Socket::Close() {
@@ -642,9 +627,7 @@ Errno Socket::SetNonBlock(bool enable) {
    if (EnableNonBlock(fd, enable)) {
        return Errno::SUCCESS;
    }
-    const int ec = LastError();
-    UNREACHABLE_MSG("Unhandled host socket error={}", ec);
-    return Errno::SUCCESS;
+    return GetAndLogLastError();
 }

 bool Socket::IsOpened() const {
@@ -7,6 +7,7 @@
 #include <array>
 #include <utility>

+#include "common/common_funcs.h"
 #include "common/common_types.h"

 namespace Network {
@@ -21,6 +22,11 @@ enum class Errno {
    MFILE,
    NOTCONN,
    AGAIN,
+    CONNREFUSED,
+    HOSTUNREACH,
+    NETDOWN,
+    NETUNREACH,
+    OTHER,
 };

 /// Address families
@@ -5,6 +5,7 @@
 #include <chrono>
 #include <cstring>
 #include <functional>
+#include <random>
 #include <thread>
 #include <boost/asio.hpp>
 #include "common/logging/log.h"
@@ -26,10 +27,10 @@ class Socket {
 public:
    using clock = std::chrono::system_clock;

-    explicit Socket(const std::string& host, u16 port, std::size_t pad_index_, u32 client_id_,
+    explicit Socket(const std::string& host, u16 port, std::size_t pad_index_,
                    SocketCallback callback_)
        : callback(std::move(callback_)), timer(io_service),
-          socket(io_service, udp::endpoint(udp::v4(), 0)), client_id(client_id_),
+          socket(io_service, udp::endpoint(udp::v4(), 0)), client_id(GenerateRandomClientId()),
          pad_index(pad_index_) {
        boost::system::error_code ec{};
        auto ipv4 = boost::asio::ip::make_address_v4(host, ec);
@@ -63,6 +64,11 @@ public:
    }

 private:
+    u32 GenerateRandomClientId() const {
+        std::random_device device;
+        return device();
+    }
+
    void HandleReceive(const boost::system::error_code&, std::size_t bytes_transferred) {
        if (auto type = Response::Validate(receive_buffer.data(), bytes_transferred)) {
            switch (*type) {
@@ -115,7 +121,7 @@ private:
    boost::asio::basic_waitable_timer<clock> timer;
    udp::socket socket;

-    u32 client_id{};
+    const u32 client_id;
    std::size_t pad_index{};

    static constexpr std::size_t PORT_INFO_SIZE = sizeof(Message<Request::PortInfo>);
@@ -203,7 +209,7 @@ void Client::ReloadSockets() {
                LOG_ERROR(Input, "Duplicated UDP servers found");
                continue;
            }
-            StartCommunication(client++, udp_input_address, udp_input_port, pad, 24872);
+            StartCommunication(client++, udp_input_address, udp_input_port, pad);
        }
    }
 }
@@ -277,7 +283,7 @@ void Client::OnPadData(Response::PadData data, std::size_t client) {
 }

 void Client::StartCommunication(std::size_t client, const std::string& host, u16 port,
-                                std::size_t pad_index, u32 client_id) {
+                                std::size_t pad_index) {
    SocketCallback callback{[this](Response::Version version) { OnVersion(version); },
                            [this](Response::PortInfo info) { OnPortInfo(info); },
                            [this, client](Response::PadData data) { OnPadData(data, client); }};
@@ -287,7 +293,7 @@ void Client::StartCommunication(std::size_t client, const std::string& host, u16
    clients[client].port = port;
    clients[client].pad_index = pad_index;
    clients[client].active = 0;
-    clients[client].socket = std::make_unique<Socket>(host, port, pad_index, client_id, callback);
+    clients[client].socket = std::make_unique<Socket>(host, port, pad_index, callback);
    clients[client].thread = std::thread{SocketLoop, clients[client].socket.get()};
    // Set motion parameters
    // SetGyroThreshold value should be dependent on GyroscopeZeroDriftMode
@@ -416,7 +422,7 @@ const Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() const {
    return pad_queue;
 }

-void TestCommunication(const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
+void TestCommunication(const std::string& host, u16 port, std::size_t pad_index,
                       const std::function<void()>& success_callback,
                       const std::function<void()>& failure_callback) {
    std::thread([=] {
@@ -426,7 +432,7 @@ void TestCommunication(const std::string& host, u16 port, std::size_t pad_index,
            .port_info = [](Response::PortInfo) {},
            .pad_data = [&](Response::PadData) { success_event.Set(); },
        };
-        Socket socket{host, port, pad_index, client_id, std::move(callback)};
+        Socket socket{host, port, pad_index, std::move(callback)};
        std::thread worker_thread{SocketLoop, &socket};
        const bool result = success_event.WaitFor(std::chrono::seconds(5));
        socket.Stop();
@@ -440,7 +446,7 @@ void TestCommunication(const std::string& host, u16 port, std::size_t pad_index,
 }

 CalibrationConfigurationJob::CalibrationConfigurationJob(
-    const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
+    const std::string& host, u16 port, std::size_t pad_index,
    std::function<void(Status)> status_callback,
    std::function<void(u16, u16, u16, u16)> data_callback) {

@@ -485,7 +491,7 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
                                        complete_event.Set();
                                    }
                                }};
-        Socket socket{host, port, pad_index, client_id, std::move(callback)};
+        Socket socket{host, port, pad_index, std::move(callback)};
        std::thread worker_thread{SocketLoop, &socket};
        complete_event.Wait();
        socket.Stop();
@@ -126,7 +126,7 @@ private:
    void OnPortInfo(Response::PortInfo);
    void OnPadData(Response::PadData, std::size_t client);
    void StartCommunication(std::size_t client, const std::string& host, u16 port,
-                            std::size_t pad_index, u32 client_id);
+                            std::size_t pad_index);
    void UpdateYuzuSettings(std::size_t client, const Common::Vec3<float>& acc,
                            const Common::Vec3<float>& gyro);

@@ -165,7 +165,7 @@ public:
     * @param data_callback Called when calibration data is ready
     */
    explicit CalibrationConfigurationJob(const std::string& host, u16 port, std::size_t pad_index,
-                                         u32 client_id, std::function<void(Status)> status_callback,
+                                         std::function<void(Status)> status_callback,
                                         std::function<void(u16, u16, u16, u16)> data_callback);
    ~CalibrationConfigurationJob();
    void Stop();
@@ -174,7 +174,7 @@ private:
    Common::Event complete_event;
 };

-void TestCommunication(const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
+void TestCommunication(const std::string& host, u16 port, std::size_t pad_index,
                       const std::function<void()>& success_callback,
                       const std::function<void()>& failure_callback);

@@ -5,6 +5,7 @@ add_executable(tests
    common/param_package.cpp
    common/ring_buffer.cpp
    core/core_timing.cpp
+    core/network/network.cpp
    tests.cpp
    video_core/buffer_base.cpp
 )
@@ -67,16 +67,15 @@ void TestControl1::DoWork() {
        value++;
    }
    results[id] = value;
-    Fiber::YieldTo(work_fibers[id], thread_fibers[id]);
+    Fiber::YieldTo(work_fibers[id].get(), thread_fibers[id].get());
 }

 void TestControl1::ExecuteThread(u32 id) {
    thread_ids.Register(id);
-    auto thread_fiber = Fiber::ThreadToFiber();
-    thread_fibers[id] = thread_fiber;
+    thread_fibers[id] = Fiber::ThreadToFiber();
    work_fibers[id] = std::make_shared<Fiber>(std::function<void(void*)>{WorkControl1}, this);
    items[id] = rand() % 256;
-    Fiber::YieldTo(thread_fibers[id], work_fibers[id]);
+    Fiber::YieldTo(thread_fibers[id].get(), work_fibers[id].get());
    thread_fibers[id]->Exit();
 }

@@ -117,11 +116,11 @@ public:
        for (u32 i = 0; i < 12000; i++) {
            value1 += i;
        }
-        Fiber::YieldTo(fiber1, fiber3);
+        Fiber::YieldTo(fiber1.get(), fiber3.get());
        const u32 id = thread_ids.Get();
        assert1 = id == 1;
        value2 += 5000;
-        Fiber::YieldTo(fiber1, thread_fibers[id]);
+        Fiber::YieldTo(fiber1.get(), thread_fibers[id].get());
    }

    void DoWork2() {
@@ -129,7 +128,7 @@ public:
            ;
        value2 = 2000;
        trap = false;
-        Fiber::YieldTo(fiber2, fiber1);
+        Fiber::YieldTo(fiber2.get(), fiber1.get());
        assert3 = false;
    }

@@ -137,19 +136,19 @@ public:
        const u32 id = thread_ids.Get();
        assert2 = id == 0;
        value1 += 1000;
-        Fiber::YieldTo(fiber3, thread_fibers[id]);
+        Fiber::YieldTo(fiber3.get(), thread_fibers[id].get());
    }

    void ExecuteThread(u32 id);

    void CallFiber1() {
        const u32 id = thread_ids.Get();
-        Fiber::YieldTo(thread_fibers[id], fiber1);
+        Fiber::YieldTo(thread_fibers[id].get(), fiber1.get());
    }

    void CallFiber2() {
        const u32 id = thread_ids.Get();
-        Fiber::YieldTo(thread_fibers[id], fiber2);
+        Fiber::YieldTo(thread_fibers[id].get(), fiber2.get());
    }

    void Exit();
@@ -185,8 +184,7 @@ static void WorkControl2_3(void* control) {

 void TestControl2::ExecuteThread(u32 id) {
    thread_ids.Register(id);
-    auto thread_fiber = Fiber::ThreadToFiber();
-    thread_fibers[id] = thread_fiber;
+    thread_fibers[id] = Fiber::ThreadToFiber();
 }

 void TestControl2::Exit() {
@@ -241,23 +239,23 @@ public:

    void DoWork1() {
        value1 += 1;
-        Fiber::YieldTo(fiber1, fiber2);
+        Fiber::YieldTo(fiber1.get(), fiber2.get());
        const u32 id = thread_ids.Get();
        value3 += 1;
-        Fiber::YieldTo(fiber1, thread_fibers[id]);
+        Fiber::YieldTo(fiber1.get(), thread_fibers[id].get());
    }

    void DoWork2() {
        value2 += 1;
        const u32 id = thread_ids.Get();
-        Fiber::YieldTo(fiber2, thread_fibers[id]);
+        Fiber::YieldTo(fiber2.get(), thread_fibers[id].get());
    }

    void ExecuteThread(u32 id);

    void CallFiber1() {
        const u32 id = thread_ids.Get();
-        Fiber::YieldTo(thread_fibers[id], fiber1);
+        Fiber::YieldTo(thread_fibers[id].get(), fiber1.get());
    }

    void Exit();
@@ -266,7 +264,7 @@ public:
    u32 value2{};
    u32 value3{};
    ThreadIds thread_ids;
-    std::vector<std::shared_ptr<Common::Fiber>> thread_fibers;
+    std::vector<std::unique_ptr<Common::Fiber>> thread_fibers;
    std::shared_ptr<Common::Fiber> fiber1;
    std::shared_ptr<Common::Fiber> fiber2;
 };
@@ -283,8 +281,7 @@ static void WorkControl3_2(void* control) {

 void TestControl3::ExecuteThread(u32 id) {
    thread_ids.Register(id);
-    auto thread_fiber = Fiber::ThreadToFiber();
-    thread_fibers[id] = thread_fiber;
+    thread_fibers[id] = Fiber::ThreadToFiber();
 }

 void TestControl3::Exit() {
@@ -332,7 +329,7 @@ public:

    void Execute() {
        thread_fiber = Fiber::ThreadToFiber();
-        Fiber::YieldTo(thread_fiber, fiber1);
+        Fiber::YieldTo(thread_fiber.get(), fiber1.get());
        thread_fiber->Exit();
    }

@@ -340,7 +337,7 @@ public:
        fiber1->SetRewindPoint(std::function<void(void*)>{WorkControl4}, this);
        if (rewinded) {
            goal_reached = true;
-            Fiber::YieldTo(fiber1, thread_fiber);
+            Fiber::YieldTo(fiber1.get(), thread_fiber.get());
        }
        rewinded = true;
        fiber1->Rewind();
@@ -0,0 +1,28 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <catch2/catch.hpp>
+
+#include "core/network/network.h"
+#include "core/network/sockets.h"
+
+TEST_CASE("Network::Errors", "[core]") {
+    Network::NetworkInstance network_instance; // initialize network
+
+    Network::Socket socks[2];
+    for (Network::Socket& sock : socks) {
+        REQUIRE(sock.Initialize(Network::Domain::INET, Network::Type::STREAM,
+                                Network::Protocol::TCP) == Network::Errno::SUCCESS);
+    }
+
+    Network::SockAddrIn addr{
+        Network::Domain::INET,
+        {127, 0, 0, 1},
+        1, // hopefully nobody running this test has something listening on port 1
+    };
+    REQUIRE(socks[0].Connect(addr) == Network::Errno::CONNREFUSED);
+
+    std::vector<u8> message{1, 2, 3, 4};
+    REQUIRE(socks[1].Recv(0, message).second == Network::Errno::NOTCONN);
+}
@@ -1785,6 +1785,8 @@ public:
        SSY,
        SYNC,
        BRK,
+        CAL,
+        RET,
        DEPBAR,
        VOTE,
        VOTE_VTG,
@@ -2108,6 +2110,8 @@ private:
            INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
            INST("111000110100----", Id::BRK, Type::Flow, "BRK"),
            INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),
+            INST("111000100110----", Id::CAL, Type::Flow, "CAL"),
+            INST("111000110010----", Id::RET, Type::Flow, "RET"),
            INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
            INST("0101000011011---", Id::VOTE, Type::Warp, "VOTE"),
            INST("0101000011100---", Id::VOTE_VTG, Type::Warp, "VOTE_VTG"),
@@ -459,7 +459,7 @@ void GPU::ProcessSemaphoreAcquire() {
 }

 void GPU::Start() {
-    gpu_thread.StartThread(*renderer, renderer->Context(), *dma_pusher, *cdma_pusher);
+    gpu_thread.StartThread(*renderer, renderer->Context(), *dma_pusher);
    cpu_context = renderer->GetRenderWindow().CreateSharedContext();
    cpu_context->MakeCurrent();
 }
@@ -19,7 +19,7 @@ namespace VideoCommon::GPUThread {
 /// Runs the GPU thread
 static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
                      Core::Frontend::GraphicsContext& context, Tegra::DmaPusher& dma_pusher,
-                      SynchState& state, Tegra::CDmaPusher& cdma_pusher) {
+                      SynchState& state) {
    std::string name = "yuzu:GPU";
    MicroProfileOnThreadCreate(name.c_str());
    SCOPE_EXIT({ MicroProfileOnThreadExit(); });
@@ -46,9 +46,6 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
        if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
            dma_pusher.Push(std::move(submit_list->entries));
            dma_pusher.DispatchCalls();
-        } else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
-            // NVDEC
-            cdma_pusher.ProcessEntries(std::move(command_list->entries));
        } else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
            renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
        } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
@@ -83,20 +80,16 @@ ThreadManager::~ThreadManager() {

 void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
                                Core::Frontend::GraphicsContext& context,
-                                Tegra::DmaPusher& dma_pusher, Tegra::CDmaPusher& cdma_pusher) {
+                                Tegra::DmaPusher& dma_pusher) {
    rasterizer = renderer.ReadRasterizer();
    thread = std::thread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
-                         std::ref(dma_pusher), std::ref(state), std::ref(cdma_pusher));
+                         std::ref(dma_pusher), std::ref(state));
 }

 void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
    PushCommand(SubmitListCommand(std::move(entries)));
 }

-void ThreadManager::SubmitCommandBuffer(Tegra::ChCommandHeaderList&& entries) {
-    PushCommand(SubmitChCommandEntries(std::move(entries)));
-}
-
 void ThreadManager::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
    PushCommand(SwapBuffersCommand(framebuffer ? std::make_optional(*framebuffer) : std::nullopt));
 }
@@ -43,14 +43,6 @@ struct SubmitListCommand final {
    Tegra::CommandList entries;
 };

-/// Command to signal to the GPU thread that a cdma command list is ready for processing
-struct SubmitChCommandEntries final {
-    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries_)
-        : entries{std::move(entries_)} {}
-
-    Tegra::ChCommandHeaderList entries;
-};
-
 /// Command to signal to the GPU thread that a swap buffers is pending
 struct SwapBuffersCommand final {
    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer_)
@@ -91,9 +83,9 @@ struct OnCommandListEndCommand final {};
 struct GPUTickCommand final {};

 using CommandData =
-    std::variant<EndProcessingCommand, SubmitListCommand, SubmitChCommandEntries,
-                 SwapBuffersCommand, FlushRegionCommand, InvalidateRegionCommand,
-                 FlushAndInvalidateRegionCommand, OnCommandListEndCommand, GPUTickCommand>;
+    std::variant<EndProcessingCommand, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
+                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand, OnCommandListEndCommand,
+                 GPUTickCommand>;

 struct CommandDataContainer {
    CommandDataContainer() = default;
@@ -123,14 +115,11 @@ public:

    /// Creates and starts the GPU thread.
    void StartThread(VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context,
-                     Tegra::DmaPusher& dma_pusher, Tegra::CDmaPusher& cdma_pusher);
+                     Tegra::DmaPusher& dma_pusher);

    /// Push GPU command entries to be processed
    void SubmitList(Tegra::CommandList&& entries);

-    /// Push GPU CDMA command buffer entries to be processed
-    void SubmitCommandBuffer(Tegra::ChCommandHeaderList&& entries);
-
    /// Swap buffers (render frame)
    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);

@@ -114,6 +114,25 @@ void MemoryManager::TryUnlockPage(PageEntry page_entry, std::size_t size) {
               .IsSuccess());
 }

+void MemoryManager::UnmapVicFrame(GPUVAddr gpu_addr, std::size_t size) {
+    if (!size) {
+        return;
+    }
+
+    const std::optional<VAddr> cpu_addr = GpuToCpuAddress(gpu_addr);
+    ASSERT(cpu_addr);
+    rasterizer->InvalidateExceptTextureCache(*cpu_addr, size);
+    cache_invalidate_queue.push_back({*cpu_addr, size});
+
+    UpdateRange(gpu_addr, PageEntry::State::Unmapped, size);
+}
+
+void MemoryManager::InvalidateQueuedCaches() {
+    for (const auto& entry : cache_invalidate_queue) {
+        rasterizer->InvalidateTextureCache(entry.first, entry.second);
+    }
+    cache_invalidate_queue.clear();
+}
 PageEntry MemoryManager::GetPageEntry(GPUVAddr gpu_addr) const {
    return page_table[PageEntryIndex(gpu_addr)];
 }
@@ -123,6 +123,14 @@ public:
    [[nodiscard]] GPUVAddr Allocate(std::size_t size, std::size_t align);
    void Unmap(GPUVAddr gpu_addr, std::size_t size);

+    /**
+     * Some Decoded NVDEC frames require that texture cache does not get invalidated.
+     * UnmapVicFrame defers the texture cache invalidation until the stream ends
+     * by invoking InvalidateQueuedCaches to invalidate all frame texture caches.
+     */
+    void UnmapVicFrame(GPUVAddr gpu_addr, std::size_t size);
+    void InvalidateQueuedCaches();
+
 private:
    [[nodiscard]] PageEntry GetPageEntry(GPUVAddr gpu_addr) const;
    void SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size = page_size);
@@ -69,6 +69,12 @@ public:
    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
    virtual void FlushRegion(VAddr addr, u64 size) = 0;

+    /// Notify rasterizer to flush the texture cache to Switch memory
+    virtual void InvalidateExceptTextureCache(VAddr addr, u64 size) = 0;
+
+    /// Notify rasterizer to invalidate the texture cache
+    virtual void InvalidateTextureCache(VAddr addr, u64 size) = 0;
+
    /// Check if the the specified memory area requires flushing to CPU Memory.
    virtual bool MustFlushRegion(VAddr addr, u64 size) = 0;

@@ -491,6 +491,9 @@ private:
    const Registry& registry;
    const ShaderType stage;

+    std::shared_ptr<ShaderFunctionIR> context_func;
+    u32 ast_var_base{};
+
    std::size_t num_temporaries = 0;
    std::size_t max_temporaries = 0;

@@ -807,13 +810,33 @@ ARBDecompiler::ARBDecompiler(const Device& device_, const ShaderIR& ir_, const R
    : device{device_}, ir{ir_}, registry{registry_}, stage{stage_} {
    DefineGlobalMemory();

+    context_func = ir.GetMainFunction();
+    ast_var_base = 0;
+
    AddLine("TEMP RC;");
    AddLine("TEMP FSWZA[4];");
    AddLine("TEMP FSWZB[4];");
-    if (ir.IsDecompiled()) {
+    InitializeVariables();
+    AddLine("main:");
+    if (context_func->IsDecompiled()) {
        DecompileAST();
    } else {
        DecompileBranchMode();
+        AddLine("RET;");
+    }
+
+    const auto& subfunctions = ir.GetSubFunctions();
+    auto it = subfunctions.begin();
+    while (it != subfunctions.end()) {
+        context_func = *it;
+        AddLine("func_{}:", context_func->GetId());
+        if (context_func->IsDecompiled()) {
+            DecompileAST();
+        } else {
+            DecompileBranchMode();
+            AddLine("RET;");
+        }
+        it++;
    }
    AddLine("END");

@@ -1060,41 +1083,38 @@ void ARBDecompiler::InitializeVariables() {
 }

 void ARBDecompiler::DecompileAST() {
-    const u32 num_flow_variables = ir.GetASTNumVariables();
+    const u32 num_flow_variables = context_func->GetASTNumVariables();
    for (u32 i = 0; i < num_flow_variables; ++i) {
-        AddLine("TEMP F{};", i);
+        AddLine("TEMP F{};", i + ast_var_base);
    }
    for (u32 i = 0; i < num_flow_variables; ++i) {
-        AddLine("MOV.U F{}, {{0, 0, 0, 0}};", i);
+        AddLine("MOV.U F{}, {{0, 0, 0, 0}};", i + ast_var_base);
    }

-    InitializeVariables();
-
-    VisitAST(ir.GetASTProgram());
+    VisitAST(context_func->GetASTProgram());
+    ast_var_base += num_flow_variables;
 }

 void ARBDecompiler::DecompileBranchMode() {
    static constexpr u32 FLOW_STACK_SIZE = 20;
-    if (!ir.IsFlowStackDisabled()) {
+    if (!context_func->IsFlowStackDisabled()) {
        AddLine("TEMP SSY[{}];", FLOW_STACK_SIZE);
        AddLine("TEMP PBK[{}];", FLOW_STACK_SIZE);
        AddLine("TEMP SSY_TOP;");
        AddLine("TEMP PBK_TOP;");
    }

-    AddLine("TEMP PC;");
+    AddLine("TEMP PC{};", context_func->GetId());

-    if (!ir.IsFlowStackDisabled()) {
+    if (!context_func->IsFlowStackDisabled()) {
        AddLine("MOV.U SSY_TOP.x, 0;");
        AddLine("MOV.U PBK_TOP.x, 0;");
    }

-    InitializeVariables();
-
-    const auto basic_block_end = ir.GetBasicBlocks().end();
-    auto basic_block_it = ir.GetBasicBlocks().begin();
+    const auto basic_block_end = context_func->GetBasicBlocks().end();
+    auto basic_block_it = context_func->GetBasicBlocks().begin();
    const u32 first_address = basic_block_it->first;
-    AddLine("MOV.U PC.x, {};", first_address);
+    AddLine("MOV.U PC{}.x, {};", context_func->GetId(), first_address);

    AddLine("REP;");

@@ -1103,7 +1123,7 @@ void ARBDecompiler::DecompileBranchMode() {
        const auto& [address, bb] = *basic_block_it;
        ++num_blocks;

-        AddLine("SEQ.S.CC RC.x, PC.x, {};", address);
+        AddLine("SEQ.S.CC RC.x, PC{}.x, {};", context_func->GetId(), address);
        AddLine("IF NE.x;");

        VisitBlock(bb);
@@ -1114,7 +1134,7 @@ void ARBDecompiler::DecompileBranchMode() {
            const auto op = std::get_if<OperationNode>(&*bb[bb.size() - 1]);
            if (!op || op->GetCode() != OperationCode::Branch) {
                const u32 next_address = basic_block_it->first;
-                AddLine("MOV.U PC.x, {};", next_address);
+                AddLine("MOV.U PC{}.x, {};", context_func->GetId(), next_address);
                AddLine("CONT;");
            }
        }
@@ -1152,7 +1172,8 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
    } else if (const auto decoded = std::get_if<ASTBlockDecoded>(&*node->GetInnerData())) {
        VisitBlock(decoded->nodes);
    } else if (const auto var_set = std::get_if<ASTVarSet>(&*node->GetInnerData())) {
-        AddLine("MOV.U F{}, {};", var_set->index, VisitExpression(var_set->condition));
+        AddLine("MOV.U F{}, {};", var_set->index + ast_var_base,
+                VisitExpression(var_set->condition));
        ResetTemporaries();
    } else if (const auto do_while = std::get_if<ASTDoWhile>(&*node->GetInnerData())) {
        const std::string condition = VisitExpression(do_while->condition);
@@ -1172,7 +1193,11 @@ void ARBDecompiler::VisitAST(const ASTNode& node) {
            ResetTemporaries();
        }
        if (ast_return->kills) {
-            AddLine("KIL TR;");
+            if (stage == ShaderType::Fragment) {
+                AddLine("KIL TR;");
+            } else {
+                AddLine("RET;");
+            }
        } else {
            Exit();
        }
@@ -1219,7 +1244,7 @@ std::string ARBDecompiler::VisitExpression(const Expr& node) {
        return Visit(ir.GetConditionCode(expr->cc));
    }
    if (const auto expr = std::get_if<ExprVar>(&*node)) {
-        return fmt::format("F{}.x", expr->var_index);
+        return fmt::format("F{}.x", expr->var_index + ast_var_base);
    }
    if (const auto expr = std::get_if<ExprBoolean>(&*node)) {
        return expr->value ? "0xffffffff" : "0";
@@ -1406,6 +1431,11 @@ std::string ARBDecompiler::Visit(const Node& node) {
        return {};
    }

+    if (const auto func_call = std::get_if<FunctionCallNode>(&*node)) {
+        AddLine("CAL func_{};", func_call->GetFuncId());
+        return {};
+    }
+
    if ([[maybe_unused]] const auto cmt = std::get_if<CommentNode>(&*node)) {
        // Uncommenting this will generate invalid code. GLASM lacks comments.
        // AddLine("// {}", cmt->GetText());
@@ -1479,7 +1509,7 @@ std::string ARBDecompiler::GlobalMemoryPointer(const GmemNode& gmem) {
 }

 void ARBDecompiler::Exit() {
-    if (stage != ShaderType::Fragment) {
+    if (!context_func->IsMain() || stage != ShaderType::Fragment) {
        AddLine("RET;");
        return;
    }
@@ -2021,13 +2051,13 @@ std::string ARBDecompiler::ImageStore(Operation operation) {

 std::string ARBDecompiler::Branch(Operation operation) {
    const auto target = std::get<ImmediateNode>(*operation[0]);
-    AddLine("MOV.U PC.x, {};", target.GetValue());
+    AddLine("MOV.U PC{}.x, {};", context_func->GetId(), target.GetValue());
    AddLine("CONT;");
    return {};
 }

 std::string ARBDecompiler::BranchIndirect(Operation operation) {
-    AddLine("MOV.U PC.x, {};", Visit(operation[0]));
+    AddLine("MOV.U PC{}.x, {};", context_func->GetId(), Visit(operation[0]));
    AddLine("CONT;");
    return {};
 }
@@ -2045,7 +2075,7 @@ std::string ARBDecompiler::PopFlowStack(Operation operation) {
    const auto stack = std::get<MetaStackClass>(operation.GetMeta());
    const std::string_view stack_name = StackName(stack);
    AddLine("SUB.S {}_TOP.x, {}_TOP.x, 1;", stack_name, stack_name);
-    AddLine("MOV.U PC.x, {}[{}_TOP.x].x;", stack_name, stack_name);
+    AddLine("MOV.U PC{}.x, {}[{}_TOP.x].x;", context_func->GetId(), stack_name, stack_name);
    AddLine("CONT;");
    return {};
 }
@@ -2056,6 +2086,10 @@ std::string ARBDecompiler::Exit(Operation) {
 }

 std::string ARBDecompiler::Discard(Operation) {
+    if (stage != ShaderType::Fragment) {
+        AddLine("RET;");
+        return {};
+    }
    AddLine("KIL TR;");
    return {};
 }
@@ -544,6 +544,26 @@ void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
    query_cache.FlushRegion(addr, size);
 }

+void RasterizerOpenGL::InvalidateExceptTextureCache(VAddr addr, u64 size) {
+    if (addr == 0 || size == 0) {
+        return;
+    }
+    shader_cache.InvalidateRegion(addr, size);
+    {
+        std::scoped_lock lock{buffer_cache.mutex};
+        buffer_cache.WriteMemory(addr, size);
+    }
+    query_cache.InvalidateRegion(addr, size);
+}
+
+void RasterizerOpenGL::InvalidateTextureCache(VAddr addr, u64 size) {
+    if (addr == 0 || size == 0) {
+        return;
+    }
+    std::scoped_lock lock{texture_cache.mutex};
+    texture_cache.UnmapMemory(addr, size);
+}
+
 bool RasterizerOpenGL::MustFlushRegion(VAddr addr, u64 size) {
    std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
    if (!Settings::IsGPULevelHigh()) {
@@ -74,6 +74,8 @@ public:
    void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr, u32 size) override;
    void FlushAll() override;
    void FlushRegion(VAddr addr, u64 size) override;
+    void InvalidateExceptTextureCache(VAddr addr, u64 size) override;
+    void InvalidateTextureCache(VAddr addr, u64 size) override;
    bool MustFlushRegion(VAddr addr, u64 size) override;
    void InvalidateRegion(VAddr addr, u64 size) override;
    void OnCPUWrite(VAddr addr, u64 size) override;
@@ -435,6 +435,27 @@ public:
        DeclareCustomVariables();
        DeclarePhysicalAttributeReader();

+        const auto& subfunctions = ir.GetSubFunctions();
+        auto it = subfunctions.rbegin();
+        while (it != subfunctions.rend()) {
+            context_func = *it;
+            code.AddLine("void func_{}() {{", context_func->GetId());
+            ++code.scope;
+
+            if (context_func->IsDecompiled()) {
+                DecompileAST();
+            } else {
+                DecompileBranchMode();
+            }
+
+            --code.scope;
+            code.AddLine("}}");
+
+            it++;
+        }
+
+        context_func = ir.GetMainFunction();
+
        code.AddLine("void main() {{");
        ++code.scope;

@@ -442,7 +463,7 @@ public:
            code.AddLine("gl_Position = vec4(0.0f, 0.0f, 0.0f, 1.0f);");
        }

-        if (ir.IsDecompiled()) {
+        if (context_func->IsDecompiled()) {
            DecompileAST();
        } else {
            DecompileBranchMode();
@@ -462,13 +483,13 @@ private:

    void DecompileBranchMode() {
        // VM's program counter
-        const auto first_address = ir.GetBasicBlocks().begin()->first;
+        const auto first_address = context_func->GetBasicBlocks().begin()->first;
        code.AddLine("uint jmp_to = {}U;", first_address);

        // TODO(Subv): Figure out the actual depth of the flow stack, for now it seems
        // unlikely that shaders will use 20 nested SSYs and PBKs.
        constexpr u32 FLOW_STACK_SIZE = 20;
-        if (!ir.IsFlowStackDisabled()) {
+        if (!context_func->IsFlowStackDisabled()) {
            for (const auto stack : std::array{MetaStackClass::Ssy, MetaStackClass::Pbk}) {
                code.AddLine("uint {}[{}];", FlowStackName(stack), FLOW_STACK_SIZE);
                code.AddLine("uint {} = 0U;", FlowStackTopName(stack));
@@ -480,7 +501,7 @@ private:

        code.AddLine("switch (jmp_to) {{");

-        for (const auto& pair : ir.GetBasicBlocks()) {
+        for (const auto& pair : context_func->GetBasicBlocks()) {
            const auto& [address, bb] = pair;
            code.AddLine("case 0x{:X}U: {{", address);
            ++code.scope;
@@ -1131,6 +1152,11 @@ private:
            return {};
        }

+        if (const auto func_call = std::get_if<FunctionCallNode>(&*node)) {
+            code.AddLine("func_{}();", func_call->GetFuncId());
+            return {};
+        }
+
        if (const auto comment = std::get_if<CommentNode>(&*node)) {
            code.AddLine("// " + comment->GetText());
            return {};
@@ -2267,7 +2293,9 @@ private:
    }

    Expression Exit(Operation operation) {
-        PreExit();
+        if (context_func->IsMain()) {
+            PreExit();
+        }
        code.AddLine("return;");
        return {};
    }
@@ -2277,7 +2305,11 @@ private:
        // about unexecuted instructions that may follow this.
        code.AddLine("if (true) {{");
        ++code.scope;
-        code.AddLine("discard;");
+        if (stage != ShaderType::Fragment) {
+            code.AddLine("return;");
+        } else {
+            code.AddLine("discard;");
+        }
        --code.scope;
        code.AddLine("}}");
        return {};
@@ -2388,7 +2420,7 @@ private:
    }

    Expression Barrier(Operation) {
-        if (!ir.IsDecompiled()) {
+        if (!context_func->IsDecompiled()) {
            LOG_ERROR(Render_OpenGL, "barrier() used but shader is not decompiled");
            return {};
        }
@@ -2755,6 +2787,8 @@ private:
    const Header header;
    std::unordered_map<u8, VaryingTFB> transform_feedback;

+    std::shared_ptr<ShaderFunctionIR> context_func;
+
    ShaderWriter code;

    std::optional<u32> max_input_vertices;
@@ -2902,9 +2936,15 @@ public:
            decomp.code.scope++;
        }
        if (ast.kills) {
-            decomp.code.AddLine("discard;");
+            if (decomp.stage != ShaderType::Fragment) {
+                decomp.code.AddLine("return;");
+            } else {
+                decomp.code.AddLine("discard;");
+            }
        } else {
-            decomp.PreExit();
+            if (decomp.context_func->IsMain()) {
+                decomp.PreExit();
+            }
            decomp.code.AddLine("return;");
        }
        if (!is_true) {
@@ -2937,13 +2977,13 @@ private:
 };

 void GLSLDecompiler::DecompileAST() {
-    const u32 num_flow_variables = ir.GetASTNumVariables();
+    const u32 num_flow_variables = context_func->GetASTNumVariables();
    for (u32 i = 0; i < num_flow_variables; i++) {
        code.AddLine("bool {} = false;", GetFlowVariable(i));
    }

    ASTDecompiler decompiler{*this};
-    decompiler.Visit(ir.GetASTProgram());
+    decompiler.Visit(context_func->GetASTProgram());
 }

 } // Anonymous namespace
@@ -10,7 +10,7 @@

 namespace Vulkan {

-constexpr size_t COMMAND_BUFFER_POOL_SIZE = 0x1000;
+constexpr size_t COMMAND_BUFFER_POOL_SIZE = 4;

 struct CommandPool::Pool {
    vk::CommandPool handle;
@@ -490,6 +490,26 @@ void RasterizerVulkan::FlushRegion(VAddr addr, u64 size) {
    query_cache.FlushRegion(addr, size);
 }

+void Vulkan::RasterizerVulkan::InvalidateExceptTextureCache(VAddr addr, u64 size) {
+    if (addr == 0 || size == 0) {
+        return;
+    }
+    pipeline_cache.InvalidateRegion(addr, size);
+    {
+        std::scoped_lock lock{buffer_cache.mutex};
+        buffer_cache.WriteMemory(addr, size);
+    }
+    query_cache.InvalidateRegion(addr, size);
+}
+
+void Vulkan::RasterizerVulkan::InvalidateTextureCache(VAddr addr, u64 size) {
+    if (addr == 0 || size == 0) {
+        return;
+    }
+    std::scoped_lock lock{texture_cache.mutex};
+    texture_cache.UnmapMemory(addr, size);
+}
+
 bool RasterizerVulkan::MustFlushRegion(VAddr addr, u64 size) {
    std::scoped_lock lock{texture_cache.mutex, buffer_cache.mutex};
    if (!Settings::IsGPULevelHigh()) {
@@ -66,6 +66,8 @@ public:
    void BindGraphicsUniformBuffer(size_t stage, u32 index, GPUVAddr gpu_addr, u32 size) override;
    void FlushAll() override;
    void FlushRegion(VAddr addr, u64 size) override;
+    void InvalidateExceptTextureCache(VAddr addr, u64 size) override;
+    void InvalidateTextureCache(VAddr addr, u64 size) override;
    bool MustFlushRegion(VAddr addr, u64 size) override;
    void InvalidateRegion(VAddr addr, u64 size) override;
    void OnCPUWrite(VAddr addr, u64 size) override;
@@ -406,10 +406,38 @@ private:
        binding = DeclareStorageTexels(binding);
        binding = DeclareImages(binding);

+        const auto& subfunctions = ir.GetSubFunctions();
+
+        labels.resize(subfunctions.size() + 1);
+        other_functions.resize(subfunctions.size());
+
+        auto it = subfunctions.rbegin();
+        while (it != subfunctions.rend()) {
+            context_func = *it;
+            other_functions[context_func->GetId() - 1] =
+                OpFunction(t_void, {}, TypeFunction(t_void));
+            AddLabel();
+
+            if (context_func->IsDecompiled()) {
+                DeclareFlowVariables();
+                DecompileAST();
+            } else {
+                AllocateLabels();
+                DecompileBranchMode();
+            }
+
+            OpReturn();
+            OpFunctionEnd();
+
+            it++;
+        }
+
+        context_func = ir.GetMainFunction();
+
        const Id main = OpFunction(t_void, {}, TypeFunction(t_void));
        AddLabel();

-        if (ir.IsDecompiled()) {
+        if (context_func->IsDecompiled()) {
            DeclareFlowVariables();
            DecompileAST();
        } else {
@@ -441,16 +469,18 @@ private:
    void DecompileAST();

    void DecompileBranchMode() {
-        const u32 first_address = ir.GetBasicBlocks().begin()->first;
-        const Id loop_label = OpLabel("loop");
-        const Id merge_label = OpLabel("merge");
+        const u32 first_address = context_func->GetBasicBlocks().begin()->first;
+        const u32 func_id = context_func->GetId();
+        const std::string func_id_msg = std::to_string(func_id);
+        const Id loop_label = OpLabel("loop_" + func_id_msg);
+        const Id merge_label = OpLabel("merge_" + func_id_msg);
        const Id dummy_label = OpLabel();
        const Id jump_label = OpLabel();
-        continue_label = OpLabel("continue");
+        continue_label = OpLabel("continue_" + func_id_msg);

        std::vector<Sirit::Literal> literals;
        std::vector<Id> branch_labels;
-        for (const auto& [literal, label] : labels) {
+        for (const auto& [literal, label] : labels[func_id]) {
            literals.push_back(literal);
            branch_labels.push_back(label);
        }
@@ -462,11 +492,11 @@ private:
        std::tie(ssy_flow_stack, ssy_flow_stack_top) = CreateFlowStack();
        std::tie(pbk_flow_stack, pbk_flow_stack_top) = CreateFlowStack();

-        Name(jmp_to, "jmp_to");
-        Name(ssy_flow_stack, "ssy_flow_stack");
-        Name(ssy_flow_stack_top, "ssy_flow_stack_top");
-        Name(pbk_flow_stack, "pbk_flow_stack");
-        Name(pbk_flow_stack_top, "pbk_flow_stack_top");
+        Name(jmp_to, "jmp_to_" + func_id_msg);
+        Name(ssy_flow_stack, "ssy_flow_stack_" + func_id_msg);
+        Name(ssy_flow_stack_top, "ssy_flow_stack_top_" + func_id_msg);
+        Name(pbk_flow_stack, "pbk_flow_stack_" + func_id_msg);
+        Name(pbk_flow_stack_top, "pbk_flow_stack_top_" + func_id_msg);

        DefinePrologue();

@@ -484,13 +514,14 @@ private:
        AddLabel(default_branch);
        OpReturn();

-        for (const auto& [address, bb] : ir.GetBasicBlocks()) {
-            AddLabel(labels.at(address));
+        for (const auto& [address, bb] : context_func->GetBasicBlocks()) {
+            AddLabel(labels[func_id].at(address));

            VisitBasicBlock(bb);

-            const auto next_it = labels.lower_bound(address + 1);
-            const Id next_label = next_it != labels.end() ? next_it->second : default_branch;
+            const auto next_it = labels[func_id].lower_bound(address + 1);
+            const Id next_label =
+                next_it != labels[func_id].end() ? next_it->second : default_branch;
            OpBranch(next_label);
        }

@@ -508,9 +539,10 @@ private:
    static constexpr auto INTERNAL_FLAGS_COUNT = static_cast<std::size_t>(InternalFlag::Amount);

    void AllocateLabels() {
-        for (const auto& pair : ir.GetBasicBlocks()) {
+        const u32 func_id = context_func->GetId();
+        for (const auto& pair : context_func->GetBasicBlocks()) {
            const u32 address = pair.first;
-            labels.emplace(address, OpLabel(fmt::format("label_0x{:x}", address)));
+            labels[func_id].emplace(address, OpLabel(fmt::format("label_0x{:x}", address)));
        }
    }

@@ -589,6 +621,14 @@ private:
        DeclareOutputVertex();
    }

+    void SafeKill() {
+        if (stage != ShaderType::Fragment) {
+            OpReturn();
+            return;
+        }
+        OpKill();
+    }
+
    void DeclareFragment() {
        if (stage != ShaderType::Fragment) {
            return;
@@ -656,7 +696,7 @@ private:
    }

    void DeclareFlowVariables() {
-        for (u32 i = 0; i < ir.GetASTNumVariables(); i++) {
+        for (u32 i = 0; i < context_func->GetASTNumVariables(); i++) {
            const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
            Name(id, fmt::format("flow_var_{}", static_cast<u32>(i)));
            flow_variables.emplace(i, AddGlobalVariable(id));
@@ -1333,6 +1373,12 @@ private:
            return {};
        }

+        if (const auto func_call = std::get_if<FunctionCallNode>(&*node)) {
+            const u32 func_id = func_call->GetFuncId();
+            OpFunctionCall(t_void, other_functions[func_id - 1]);
+            return {};
+        }
+
        if (const auto comment = std::get_if<CommentNode>(&*node)) {
            if (device.HasDebuggingToolAttached()) {
                // We should insert comments with OpString instead of using named variables
@@ -2124,7 +2170,7 @@ private:

        OpBranchConditional(condition, true_label, discard_label);
        AddLabel(discard_label);
-        OpKill();
+        SafeKill();
        AddLabel(true_label);
    }

@@ -2175,7 +2221,9 @@ private:
    }

    Expression Exit(Operation operation) {
-        PreExit();
+        if (context_func->IsMain()) {
+            PreExit();
+        }
        inside_branch = true;
        if (conditional_branch_set) {
            OpReturn();
@@ -2192,12 +2240,12 @@ private:
    Expression Discard(Operation operation) {
        inside_branch = true;
        if (conditional_branch_set) {
-            OpKill();
+            SafeKill();
        } else {
            const Id dummy = OpLabel();
            OpBranch(dummy);
            AddLabel(dummy);
-            OpKill();
+            SafeKill();
            AddLabel();
        }
        return {};
@@ -2276,7 +2324,7 @@ private:
    }

    Expression Barrier(Operation) {
-        if (!ir.IsDecompiled()) {
+        if (!context_func->IsDecompiled()) {
            LOG_ERROR(Render_Vulkan, "OpBarrier used by shader is not decompiled");
            return {};
        }
@@ -2770,6 +2818,8 @@ private:
    const Specialization& specialization;
    std::unordered_map<u8, VaryingTFB> transform_feedback;

+    std::shared_ptr<ShaderFunctionIR> context_func;
+
    const Id t_void = Name(TypeVoid(), "void");

    const Id t_bool = Name(TypeBool(), "bool");
@@ -2896,7 +2946,8 @@ private:
    Id ssy_flow_stack{};
    Id pbk_flow_stack{};
    Id continue_label{};
-    std::map<u32, Id> labels;
+    std::vector<std::map<u32, Id>> labels;
+    std::vector<Id> other_functions;

    bool conditional_branch_set{};
    bool inside_branch{};
@@ -3047,9 +3098,11 @@ public:
            decomp.OpBranchConditional(condition, then_label, endif_label);
            decomp.AddLabel(then_label);
            if (ast.kills) {
-                decomp.OpKill();
+                decomp.SafeKill();
            } else {
-                decomp.PreExit();
+                if (decomp.context_func->IsMain()) {
+                    decomp.PreExit();
+                }
                decomp.OpReturn();
            }
            decomp.AddLabel(endif_label);
@@ -3058,9 +3111,11 @@ public:
            decomp.OpBranch(next_block);
            decomp.AddLabel(next_block);
            if (ast.kills) {
-                decomp.OpKill();
+                decomp.SafeKill();
            } else {
-                decomp.PreExit();
+                if (decomp.context_func->IsMain()) {
+                    decomp.PreExit();
+                }
                decomp.OpReturn();
            }
            decomp.AddLabel(decomp.OpLabel());
@@ -3097,7 +3152,7 @@ private:
 };

 void SPIRVDecompiler::DecompileAST() {
-    const u32 num_flow_variables = ir.GetASTNumVariables();
+    const u32 num_flow_variables = context_func->GetASTNumVariables();
    for (u32 i = 0; i < num_flow_variables; i++) {
        const Id id = OpVariable(t_prv_bool, spv::StorageClass::Private, v_false);
        Name(id, fmt::format("flow_var_{}", i));
@@ -3106,7 +3161,7 @@ void SPIRVDecompiler::DecompileAST() {

    DefinePrologue();

-    const ASTNode program = ir.GetASTProgram();
+    const ASTNode program = context_func->GetASTProgram();
    ASTDecompiler decompiler{*this};
    decompiler.Visit(program);

@@ -7,6 +7,7 @@
 #include <set>
 #include <stack>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>

 #include "common/assert.h"
@@ -26,17 +27,29 @@ using Tegra::Shader::OpCode;

 constexpr s32 unassigned_branch = -2;

+enum class JumpLabel : u32 {
+    SSYClass = 0,
+    PBKClass = 1,
+};
+
+struct JumpItem {
+    JumpLabel type;
+    u32 address;
+
+    bool operator==(const JumpItem& other) const {
+        return std::tie(type, address) == std::tie(other.type, other.address);
+    }
+};
+
 struct Query {
    u32 address{};
-    std::stack<u32> ssy_stack{};
-    std::stack<u32> pbk_stack{};
+    std::stack<JumpItem> stack{};
 };

 struct BlockStack {
    BlockStack() = default;
-    explicit BlockStack(const Query& q) : ssy_stack{q.ssy_stack}, pbk_stack{q.pbk_stack} {}
-    std::stack<u32> ssy_stack{};
-    std::stack<u32> pbk_stack{};
+    explicit BlockStack(const Query& q) : stack{q.stack} {}
+    std::stack<JumpItem> stack{};
 };

 template <typename T, typename... Args>
@@ -65,20 +78,36 @@ struct BlockInfo {
    }
 };

-struct CFGRebuildState {
-    explicit CFGRebuildState(const ProgramCode& program_code_, u32 start_, Registry& registry_)
-        : program_code{program_code_}, registry{registry_}, start{start_} {}
+struct ProgramControl {
+    std::unordered_set<u32> found_functions{};
+    std::list<u32> pending_functions{};

+    void RegisterFunction(u32 address) {
+        if (found_functions.count(address) != 0) {
+            return;
+        }
+        found_functions.insert(address);
+        pending_functions.emplace_back(address);
+    }
+};
+
+struct CFGRebuildState {
+    explicit CFGRebuildState(ProgramControl& control_, const ProgramCode& program_code_, u32 start_,
+                             u32 base_start_, Registry& registry_)
+        : control{control_}, program_code{program_code_}, registry{registry_}, start{start_},
+          base_start{base_start_} {}
+
+    ProgramControl& control;
    const ProgramCode& program_code;
    Registry& registry;
    u32 start{};
+    u32 base_start{};
    std::vector<BlockInfo> block_info;
    std::list<u32> inspect_queries;
    std::list<Query> queries;
    std::unordered_map<u32, u32> registered;
    std::set<u32> labels;
-    std::map<u32, u32> ssy_labels;
-    std::map<u32, u32> pbk_labels;
+    std::map<u32, JumpItem> jump_labels;
    std::unordered_map<u32, BlockStack> stacks;
    ASTManager* manager{};
 };
@@ -153,7 +182,7 @@ template <typename Result, typename TestCallable, typename PackCallable>
 std::optional<Result> TrackInstruction(const CFGRebuildState& state, u32& pos, TestCallable test,
                                       PackCallable pack) {
    for (; pos >= state.start; --pos) {
-        if (IsSchedInstruction(pos, state.start)) {
+        if (IsSchedInstruction(pos, state.base_start)) {
            continue;
        }
        const Instruction instr = state.program_code[pos];
@@ -262,7 +291,7 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
            single_branch.ignore = true;
            break;
        }
-        if (IsSchedInstruction(offset, state.start)) {
+        if (IsSchedInstruction(offset, state.base_start)) {
            offset++;
            continue;
        }
@@ -274,6 +303,7 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
        }

        switch (opcode->get().GetId()) {
+        case OpCode::Id::RET:
        case OpCode::Id::EXIT: {
            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
            single_branch.condition.predicate = GetPredicate(pred_index, instr.negate_pred != 0);
@@ -411,13 +441,20 @@ std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address)
        case OpCode::Id::SSY: {
            const u32 target = offset + instr.bra.GetBranchTarget();
            insert_label(state, target);
-            state.ssy_labels.emplace(offset, target);
+            JumpItem it = {JumpLabel::SSYClass, target};
+            state.jump_labels.emplace(offset, it);
            break;
        }
        case OpCode::Id::PBK: {
            const u32 target = offset + instr.bra.GetBranchTarget();
            insert_label(state, target);
-            state.pbk_labels.emplace(offset, target);
+            JumpItem it = {JumpLabel::PBKClass, target};
+            state.jump_labels.emplace(offset, it);
+            break;
+        }
+        case OpCode::Id::CAL: {
+            const u32 target = offset + instr.bra.GetBranchTarget();
+            state.control.RegisterFunction(target);
            break;
        }
        case OpCode::Id::BRX: {
@@ -513,7 +550,7 @@ bool TryInspectAddress(CFGRebuildState& state) {
 }

 bool TryQuery(CFGRebuildState& state) {
-    const auto gather_labels = [](std::stack<u32>& cc, std::map<u32, u32>& labels,
+    const auto gather_labels = [](std::stack<JumpItem>& cc, std::map<u32, JumpItem>& labels,
                                  BlockInfo& block) {
        auto gather_start = labels.lower_bound(block.start);
        const auto gather_end = labels.upper_bound(block.end);
@@ -522,6 +559,19 @@ bool TryQuery(CFGRebuildState& state) {
            ++gather_start;
        }
    };
+    const auto pop_labels = [](JumpLabel type, SingleBranch* branch, Query& query) -> bool {
+        while (!query.stack.empty() && query.stack.top().type != type) {
+            query.stack.pop();
+        }
+        if (query.stack.empty()) {
+            return false;
+        }
+        if (branch->address == unassigned_branch) {
+            branch->address = query.stack.top().address;
+        }
+        query.stack.pop();
+        return true;
+    };
    if (state.queries.empty()) {
        return false;
    }
@@ -534,8 +584,7 @@ bool TryQuery(CFGRebuildState& state) {
    // consumes a label. Schedule new queries accordingly
    if (block.visited) {
        BlockStack& stack = state.stacks[q.address];
-        const bool all_okay = (stack.ssy_stack.empty() || q.ssy_stack == stack.ssy_stack) &&
-                              (stack.pbk_stack.empty() || q.pbk_stack == stack.pbk_stack);
+        const bool all_okay = (stack.stack.empty() || q.stack == stack.stack);
        state.queries.pop_front();
        return all_okay;
    }
@@ -544,8 +593,7 @@ bool TryQuery(CFGRebuildState& state) {

    Query q2(q);
    state.queries.pop_front();
-    gather_labels(q2.ssy_stack, state.ssy_labels, block);
-    gather_labels(q2.pbk_stack, state.pbk_labels, block);
+    gather_labels(q2.stack, state.jump_labels, block);
    if (std::holds_alternative<SingleBranch>(*block.branch)) {
        auto* branch = std::get_if<SingleBranch>(block.branch.get());
        if (!branch->condition.IsUnconditional()) {
@@ -555,16 +603,10 @@ bool TryQuery(CFGRebuildState& state) {

        auto& conditional_query = state.queries.emplace_back(q2);
        if (branch->is_sync) {
-            if (branch->address == unassigned_branch) {
-                branch->address = conditional_query.ssy_stack.top();
-            }
-            conditional_query.ssy_stack.pop();
+            pop_labels(JumpLabel::SSYClass, branch, conditional_query);
        }
        if (branch->is_brk) {
-            if (branch->address == unassigned_branch) {
-                branch->address = conditional_query.pbk_stack.top();
-            }
-            conditional_query.pbk_stack.pop();
+            pop_labels(JumpLabel::PBKClass, branch, conditional_query);
        }
        conditional_query.address = branch->address;
        return true;
@@ -646,25 +688,23 @@ void DecompileShader(CFGRebuildState& state) {
    state.manager->Decompile();
 }

-} // Anonymous namespace
-
-std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code, u32 start_address,
-                                                const CompilerSettings& settings,
-                                                Registry& registry) {
-    auto result_out = std::make_unique<ShaderCharacteristics>();
+ShaderFunction ScanFunction(ProgramControl& control, const ProgramCode& program_code,
+                            u32 start_address, u32 base_start, const CompilerSettings& settings,
+                            Registry& registry) {
+    ShaderFunction result_out{};
    if (settings.depth == CompileDepth::BruteForce) {
-        result_out->settings.depth = CompileDepth::BruteForce;
+        result_out.settings.depth = CompileDepth::BruteForce;
        return result_out;
    }

-    CFGRebuildState state{program_code, start_address, registry};
+    CFGRebuildState state{control, program_code, start_address, base_start, registry};
    // Inspect Code and generate blocks
    state.labels.clear();
    state.labels.emplace(start_address);
    state.inspect_queries.push_back(state.start);
    while (!state.inspect_queries.empty()) {
        if (!TryInspectAddress(state)) {
-            result_out->settings.depth = CompileDepth::BruteForce;
+            result_out.settings.depth = CompileDepth::BruteForce;
            return result_out;
        }
    }
@@ -675,7 +715,7 @@ std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code,

    if (settings.depth != CompileDepth::FlowStack) {
        // Decompile Stacks
-        state.queries.push_back(Query{state.start, {}, {}});
+        state.queries.push_back(Query{state.start, {}});
        decompiled = true;
        while (!state.queries.empty()) {
            if (!TryQuery(state)) {
@@ -705,19 +745,18 @@ std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code,
            state.manager->ShowCurrentState("Of Shader");
            state.manager->Clear();
        } else {
-            auto characteristics = std::make_unique<ShaderCharacteristics>();
-            characteristics->start = start_address;
-            characteristics->settings.depth = settings.depth;
-            characteristics->manager = std::move(manager);
-            characteristics->end = state.block_info.back().end + 1;
-            return characteristics;
+            result_out.start = start_address;
+            result_out.settings.depth = settings.depth;
+            result_out.manager = std::move(manager);
+            result_out.end = state.block_info.back().end + 1;
+            return result_out;
        }
    }

-    result_out->start = start_address;
-    result_out->settings.depth =
+    result_out.start = start_address;
+    result_out.settings.depth =
        use_flow_stack ? CompileDepth::FlowStack : CompileDepth::NoFlowStack;
-    result_out->blocks.clear();
+    result_out.blocks.clear();
    for (auto& block : state.block_info) {
        ShaderBlock new_block{};
        new_block.start = block.start;
@@ -726,20 +765,20 @@ std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code,
        if (!new_block.ignore_branch) {
            new_block.branch = block.branch;
        }
-        result_out->end = std::max(result_out->end, block.end);
-        result_out->blocks.push_back(new_block);
+        result_out.end = std::max(result_out.end, block.end);
+        result_out.blocks.push_back(new_block);
    }
    if (!use_flow_stack) {
-        result_out->labels = std::move(state.labels);
+        result_out.labels = std::move(state.labels);
        return result_out;
    }

-    auto back = result_out->blocks.begin();
+    auto back = result_out.blocks.begin();
    auto next = std::next(back);
-    while (next != result_out->blocks.end()) {
+    while (next != result_out.blocks.end()) {
        if (!state.labels.contains(next->start) && next->start == back->end + 1) {
            back->end = next->end;
-            next = result_out->blocks.erase(next);
+            next = result_out.blocks.erase(next);
            continue;
        }
        back = next;
@@ -748,4 +787,22 @@ std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code,

    return result_out;
 }
+
+} // Anonymous namespace
+
+std::unique_ptr<ShaderProgram> ScanFlow(const ProgramCode& program_code, u32 start_address,
+                                        const CompilerSettings& settings, Registry& registry) {
+    ProgramControl control{};
+    auto result_out = std::make_unique<ShaderProgram>();
+    result_out->main =
+        ScanFunction(control, program_code, start_address, start_address, settings, registry);
+    while (!control.pending_functions.empty()) {
+        u32 address = control.pending_functions.front();
+        auto fun = ScanFunction(control, program_code, address, start_address, settings, registry);
+        result_out->subfunctions.emplace(address, std::move(fun));
+        control.pending_functions.pop_front();
+    }
+    return result_out;
+}
+
 } // namespace VideoCommon::Shader
@@ -5,6 +5,7 @@
 #pragma once

 #include <list>
+#include <map>
 #include <optional>
 #include <set>
 #include <variant>
@@ -101,7 +102,7 @@ struct ShaderBlock {
    }
 };

-struct ShaderCharacteristics {
+struct ShaderFunction {
    std::list<ShaderBlock> blocks{};
    std::set<u32> labels{};
    u32 start{};
@@ -110,8 +111,12 @@ struct ShaderCharacteristics {
    CompilerSettings settings{};
 };

-std::unique_ptr<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code, u32 start_address,
-                                                const CompilerSettings& settings,
-                                                Registry& registry);
+struct ShaderProgram {
+    ShaderFunction main;
+    std::map<u32, ShaderFunction> subfunctions;
+};
+
+std::unique_ptr<ShaderProgram> ScanFlow(const ProgramCode& program_code, u32 start_address,
+                                        const CompilerSettings& settings, Registry& registry);

 } // namespace VideoCommon::Shader
@@ -64,9 +64,52 @@ std::optional<u32> TryDeduceSamplerSize(const SamplerEntry& sampler_to_deduce,

 } // Anonymous namespace

+class ExprDecoder {
+public:
+    explicit ExprDecoder(ShaderIR& ir_) : ir(ir_) {}
+
+    void operator()(const ExprAnd& expr) {
+        Visit(expr.operand1);
+        Visit(expr.operand2);
+    }
+
+    void operator()(const ExprOr& expr) {
+        Visit(expr.operand1);
+        Visit(expr.operand2);
+    }
+
+    void operator()(const ExprNot& expr) {
+        Visit(expr.operand1);
+    }
+
+    void operator()(const ExprPredicate& expr) {
+        const auto pred = static_cast<Tegra::Shader::Pred>(expr.predicate);
+        if (pred != Pred::UnusedIndex && pred != Pred::NeverExecute) {
+            ir.used_predicates.insert(pred);
+        }
+    }
+
+    void operator()(const ExprCondCode& expr) {}
+
+    void operator()(const ExprVar& expr) {}
+
+    void operator()(const ExprBoolean& expr) {}
+
+    void operator()(const ExprGprEqual& expr) {
+        ir.used_registers.insert(expr.gpr);
+    }
+
+    void Visit(const Expr& node) {
+        return std::visit(*this, *node);
+    }
+
+private:
+    ShaderIR& ir;
+};
+
 class ASTDecoder {
 public:
-    explicit ASTDecoder(ShaderIR& ir_) : ir(ir_) {}
+    explicit ASTDecoder(ShaderIR& ir_) : ir(ir_), decoder(ir_) {}

    void operator()(ASTProgram& ast) {
        ASTNode current = ast.nodes.GetFirst();
@@ -77,6 +120,7 @@ public:
    }

    void operator()(ASTIfThen& ast) {
+        decoder.Visit(ast.condition);
        ASTNode current = ast.nodes.GetFirst();
        while (current) {
            Visit(current);
@@ -96,13 +140,18 @@ public:

    void operator()(ASTBlockDecoded& ast) {}

-    void operator()(ASTVarSet& ast) {}
+    void operator()(ASTVarSet& ast) {
+        decoder.Visit(ast.condition);
+    }

    void operator()(ASTLabel& ast) {}

-    void operator()(ASTGoto& ast) {}
+    void operator()(ASTGoto& ast) {
+        decoder.Visit(ast.condition);
+    }

    void operator()(ASTDoWhile& ast) {
+        decoder.Visit(ast.condition);
        ASTNode current = ast.nodes.GetFirst();
        while (current) {
            Visit(current);
@@ -110,9 +159,13 @@ public:
        }
    }

-    void operator()(ASTReturn& ast) {}
+    void operator()(ASTReturn& ast) {
+        decoder.Visit(ast.condition);
+    }

-    void operator()(ASTBreak& ast) {}
+    void operator()(ASTBreak& ast) {
+        decoder.Visit(ast.condition);
+    }

    void Visit(ASTNode& node) {
        std::visit(*this, *node->GetInnerData());
@@ -125,77 +178,113 @@ public:

 private:
    ShaderIR& ir;
+    ExprDecoder decoder;
 };

 void ShaderIR::Decode() {
+    const auto decode_function = ([this](ShaderFunction& shader_info) {
+        coverage_end = std::max<u32>(0, shader_info.end);
+        switch (shader_info.settings.depth) {
+        case CompileDepth::FlowStack: {
+            for (const auto& block : shader_info.blocks) {
+                basic_blocks.insert({block.start, DecodeRange(block.start, block.end + 1)});
+            }
+            break;
+        }
+        case CompileDepth::NoFlowStack: {
+            disable_flow_stack = true;
+            const auto insert_block = [this](NodeBlock& nodes, u32 label) {
+                if (label == static_cast<u32>(exit_branch)) {
+                    return;
+                }
+                basic_blocks.insert({label, nodes});
+            };
+            const auto& blocks = shader_info.blocks;
+            NodeBlock current_block;
+            u32 current_label = static_cast<u32>(exit_branch);
+            for (const auto& block : blocks) {
+                if (shader_info.labels.contains(block.start)) {
+                    insert_block(current_block, current_label);
+                    current_block.clear();
+                    current_label = block.start;
+                }
+                if (!block.ignore_branch) {
+                    DecodeRangeInner(current_block, block.start, block.end);
+                    InsertControlFlow(current_block, block);
+                } else {
+                    DecodeRangeInner(current_block, block.start, block.end + 1);
+                }
+            }
+            insert_block(current_block, current_label);
+            break;
+        }
+        case CompileDepth::DecompileBackwards:
+        case CompileDepth::FullDecompile: {
+            program_manager = std::move(shader_info.manager);
+            disable_flow_stack = true;
+            decompiled = true;
+            ASTDecoder decoder{*this};
+            ASTNode program = program_manager.GetProgram();
+            decoder.Visit(program);
+            break;
+        }
+        default:
+            LOG_CRITICAL(HW_GPU, "Unknown decompilation mode!");
+            [[fallthrough]];
+        case CompileDepth::BruteForce: {
+            const auto shader_end = static_cast<u32>(program_code.size());
+            coverage_begin = main_offset;
+            coverage_end = shader_end;
+            for (u32 label = main_offset; label < shader_end; ++label) {
+                basic_blocks.insert({label, DecodeRange(label, label + 1)});
+            }
+            break;
+        }
+        }
+        if (settings.depth != shader_info.settings.depth) {
+            LOG_WARNING(
+                HW_GPU,
+                "Decompiling to this setting \"{}\" failed, downgrading to this setting \"{}\"",
+                CompileDepthAsString(settings.depth),
+                CompileDepthAsString(shader_info.settings.depth));
+        }
+    });
+    const auto gen_function =
+        ([this](ShaderFunction& shader_info, u32 id) -> std::shared_ptr<ShaderFunctionIR> {
+            std::shared_ptr<ShaderFunctionIR> result;
+            if (decompiled) {
+                result = std::make_shared<ShaderFunctionIR>(std::move(program_manager), id,
+                                                            shader_info.start, shader_info.end);
+            } else {
+                result =
+                    std::make_shared<ShaderFunctionIR>(std::move(basic_blocks), disable_flow_stack,
+                                                       id, shader_info.start, shader_info.end);
+            }
+            decompiled = false;
+            disable_flow_stack = false;
+            basic_blocks.clear();
+            program_manager.Clear();
+            return result;
+        });
    std::memcpy(&header, program_code.data(), sizeof(Tegra::Shader::Header));

    decompiled = false;
    auto info = ScanFlow(program_code, main_offset, settings, registry);
-    auto& shader_info = *info;
-    coverage_begin = shader_info.start;
-    coverage_end = shader_info.end;
-    switch (shader_info.settings.depth) {
-    case CompileDepth::FlowStack: {
-        for (const auto& block : shader_info.blocks) {
-            basic_blocks.insert({block.start, DecodeRange(block.start, block.end + 1)});
-        }
-        break;
+    u32 id_start = 1;
+    for (auto& pair : info->subfunctions) {
+        func_map.emplace(pair.first, id_start);
+        id_start++;
    }
-    case CompileDepth::NoFlowStack: {
-        disable_flow_stack = true;
-        const auto insert_block = [this](NodeBlock& nodes, u32 label) {
-            if (label == static_cast<u32>(exit_branch)) {
-                return;
-            }
-            basic_blocks.insert({label, nodes});
-        };
-        const auto& blocks = shader_info.blocks;
-        NodeBlock current_block;
-        u32 current_label = static_cast<u32>(exit_branch);
-        for (const auto& block : blocks) {
-            if (shader_info.labels.contains(block.start)) {
-                insert_block(current_block, current_label);
-                current_block.clear();
-                current_label = block.start;
-            }
-            if (!block.ignore_branch) {
-                DecodeRangeInner(current_block, block.start, block.end);
-                InsertControlFlow(current_block, block);
-            } else {
-                DecodeRangeInner(current_block, block.start, block.end + 1);
-            }
-        }
-        insert_block(current_block, current_label);
-        break;
-    }
-    case CompileDepth::DecompileBackwards:
-    case CompileDepth::FullDecompile: {
-        program_manager = std::move(shader_info.manager);
-        disable_flow_stack = true;
-        decompiled = true;
-        ASTDecoder decoder{*this};
-        ASTNode program = GetASTProgram();
-        decoder.Visit(program);
-        break;
-    }
-    default:
-        LOG_CRITICAL(HW_GPU, "Unknown decompilation mode!");
-        [[fallthrough]];
-    case CompileDepth::BruteForce: {
-        const auto shader_end = static_cast<u32>(program_code.size());
-        coverage_begin = main_offset;
-        coverage_end = shader_end;
-        for (u32 label = main_offset; label < shader_end; ++label) {
-            basic_blocks.insert({label, DecodeRange(label, label + 1)});
-        }
-        break;
-    }
-    }
-    if (settings.depth != shader_info.settings.depth) {
-        LOG_WARNING(
-            HW_GPU, "Decompiling to this setting \"{}\" failed, downgrading to this setting \"{}\"",
-            CompileDepthAsString(settings.depth), CompileDepthAsString(shader_info.settings.depth));
+    coverage_begin = info->main.start;
+    coverage_end = 0;
+    decode_function(info->main);
+    main_function = gen_function(info->main, 0);
+    subfunctions.resize(info->subfunctions.size());
+    for (auto& pair : info->subfunctions) {
+        auto& func_info = pair.second;
+        decode_function(func_info);
+        u32 id = func_map[pair.first];
+        subfunctions[id - 1] = gen_function(func_info, id);
    }
 }

@@ -33,6 +33,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        // With the previous preconditions, this instruction is a no-operation.
        break;
    }
+    case OpCode::Id::RET:
    case OpCode::Id::EXIT: {
        const ConditionCode cc = instr.flow_condition_code;
        UNIMPLEMENTED_IF_MSG(cc != ConditionCode::T, "EXIT condition code used: {}", cc);
@@ -312,6 +313,16 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        LOG_DEBUG(HW_GPU, "DEPBAR instruction is stubbed");
        break;
    }
+    case OpCode::Id::CAL: {
+        const u32 target = pc + instr.bra.GetBranchTarget();
+        const auto it = func_map.find(target);
+        if (it == func_map.end()) {
+            UNREACHABLE();
+            break;
+        }
+        bb.push_back(FunctionCall(it->second));
+        break;
+    }
    default:
        UNIMPLEMENTED_MSG("Unhandled instruction: {}", opcode->get().GetName());
    }
@@ -267,10 +267,11 @@ class PatchNode;
 class SmemNode;
 class GmemNode;
 class CommentNode;
+class FunctionCallNode;

 using NodeData = std::variant<OperationNode, ConditionalNode, GprNode, CustomVarNode, ImmediateNode,
                              InternalFlagNode, PredicateNode, AbufNode, PatchNode, CbufNode,
-                              LmemNode, SmemNode, GmemNode, CommentNode>;
+                              LmemNode, SmemNode, GmemNode, FunctionCallNode, CommentNode>;
 using Node = std::shared_ptr<NodeData>;
 using Node4 = std::array<Node, 4>;
 using NodeBlock = std::vector<Node>;
@@ -494,6 +495,18 @@ private:
    std::vector<Node> code; ///< Code to execute
 };

+class FunctionCallNode final : public AmendNode {
+public:
+    explicit FunctionCallNode(u32 func_id_) : func_id{func_id_} {}
+
+    [[nodiscard]] u32 GetFuncId() const {
+        return func_id;
+    }
+
+private:
+    u32 func_id; ///< Id of the function to call
+};
+
 /// A general purpose register
 class GprNode final {
 public:
@@ -19,6 +19,11 @@ Node Comment(std::string text) {
    return MakeNode<CommentNode>(std::move(text));
 }

+/// Creates a function call
+Node FunctionCall(u32 func_id) {
+    return MakeNode<FunctionCallNode>(func_id);
+}
+
 Node Immediate(u32 value) {
    return MakeNode<ImmediateNode>(value);
 }
@@ -27,6 +27,9 @@ Node Conditional(Node condition, std::vector<Node> code);
 /// Creates a commentary node
 Node Comment(std::string text);

+/// Creates a function call
+Node FunctionCall(u32 func_id);
+
 /// Creates an u32 immediate
 Node Immediate(u32 value);

@@ -26,7 +26,7 @@ namespace VideoCommon::Shader {

 struct ShaderBlock;

-constexpr u32 MAX_PROGRAM_LENGTH = 0x1000;
+constexpr u32 MAX_PROGRAM_LENGTH = 0x2000;

 struct ConstBuffer {
    constexpr explicit ConstBuffer(u32 max_offset_, bool is_indirect_)
@@ -64,16 +64,68 @@ struct GlobalMemoryUsage {
    bool is_written{};
 };

+class ShaderFunctionIR final {
+public:
+    explicit ShaderFunctionIR(std::map<u32, NodeBlock>&& basic_blocks_, bool disable_flow_stack_,
+                              u32 id_, u32 coverage_begin_, u32 coverage_end_)
+        : basic_blocks{std::move(basic_blocks_)}, decompiled{false},
+          disable_flow_stack{disable_flow_stack_}, id{id_}, coverage_begin{coverage_begin_},
+          coverage_end{coverage_end_} {}
+    explicit ShaderFunctionIR(ASTManager&& program_manager_, u32 id_, u32 coverage_begin_,
+                              u32 coverage_end_)
+        : program_manager{std::move(program_manager_)}, decompiled{true}, disable_flow_stack{true},
+          id{id_}, coverage_begin{coverage_begin_}, coverage_end{coverage_end_} {}
+
+    const std::map<u32, NodeBlock>& GetBasicBlocks() const {
+        return basic_blocks;
+    }
+
+    [[nodiscard]] bool IsFlowStackDisabled() const {
+        return disable_flow_stack;
+    }
+
+    [[nodiscard]] bool IsDecompiled() const {
+        return decompiled;
+    }
+
+    const ASTManager& GetASTManager() const {
+        return program_manager;
+    }
+
+    [[nodiscard]] ASTNode GetASTProgram() const {
+        return program_manager.GetProgram();
+    }
+
+    [[nodiscard]] u32 GetASTNumVariables() const {
+        return program_manager.GetVariables();
+    }
+
+    [[nodiscard]] bool IsMain() const {
+        return id == 0;
+    }
+
+    [[nodiscard]] u32 GetId() const {
+        return id;
+    }
+
+private:
+    std::map<u32, NodeBlock> basic_blocks;
+    ASTManager program_manager{true, true};
+
+    bool decompiled{};
+    bool disable_flow_stack{};
+    u32 id{};
+
+    u32 coverage_begin{};
+    u32 coverage_end{};
+};
+
 class ShaderIR final {
 public:
    explicit ShaderIR(const ProgramCode& program_code_, u32 main_offset_,
                      CompilerSettings settings_, Registry& registry_);
    ~ShaderIR();

-    const std::map<u32, NodeBlock>& GetBasicBlocks() const {
-        return basic_blocks;
-    }
-
    const std::set<u32>& GetRegisters() const {
        return used_registers;
    }
@@ -155,26 +207,6 @@ public:
        return header;
    }

-    bool IsFlowStackDisabled() const {
-        return disable_flow_stack;
-    }
-
-    bool IsDecompiled() const {
-        return decompiled;
-    }
-
-    const ASTManager& GetASTManager() const {
-        return program_manager;
-    }
-
-    ASTNode GetASTProgram() const {
-        return program_manager.GetProgram();
-    }
-
-    u32 GetASTNumVariables() const {
-        return program_manager.GetVariables();
-    }
-
    u32 ConvertAddressToNvidiaSpace(u32 address) const {
        return (address - main_offset) * static_cast<u32>(sizeof(Tegra::Shader::Instruction));
    }
@@ -190,7 +222,16 @@ public:
        return num_custom_variables;
    }

+    std::shared_ptr<ShaderFunctionIR> GetMainFunction() const {
+        return main_function;
+    }
+
+    const std::vector<std::shared_ptr<ShaderFunctionIR>>& GetSubFunctions() const {
+        return subfunctions;
+    }
+
 private:
+    friend class ExprDecoder;
    friend class ASTDecoder;

    struct SamplerInfo {
@@ -453,6 +494,10 @@ private:
    std::vector<Node> amend_code;
    u32 num_custom_variables{};

+    std::shared_ptr<ShaderFunctionIR> main_function;
+    std::vector<std::shared_ptr<ShaderFunctionIR>> subfunctions;
+    std::unordered_map<u32, u32> func_map;
+
    std::set<u32> used_registers;
    std::set<Tegra::Shader::Pred> used_predicates;
    std::set<Tegra::Shader::Attribute::Index> used_input_attributes;
@@ -648,7 +648,7 @@ void Config::ReadDebuggingValues() {
 void Config::ReadServiceValues() {
    qt_config->beginGroup(QStringLiteral("Services"));
    Settings::values.bcat_backend =
-        ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("null"))
+        ReadSetting(QStringLiteral("bcat_backend"), QStringLiteral("none"))
            .toString()
            .toStdString();
    Settings::values.bcat_boxcat_local =
@@ -1239,7 +1239,7 @@ void Config::SaveDebuggingValues() {
 void Config::SaveServiceValues() {
    qt_config->beginGroup(QStringLiteral("Services"));
    WriteSetting(QStringLiteral("bcat_backend"),
-                 QString::fromStdString(Settings::values.bcat_backend), QStringLiteral("null"));
+                 QString::fromStdString(Settings::values.bcat_backend), QStringLiteral("none"));
    WriteSetting(QStringLiteral("bcat_boxcat_local"), Settings::values.bcat_boxcat_local, false);
    qt_config->endGroup();
 }
@@ -24,7 +24,7 @@

 CalibrationConfigurationDialog::CalibrationConfigurationDialog(QWidget* parent,
                                                               const std::string& host, u16 port,
-                                                               u8 pad_index, u16 client_id)
+                                                               u8 pad_index)
    : QDialog(parent) {
    layout = new QVBoxLayout;
    status_label = new QLabel(tr("Communicating with the server..."));
@@ -41,7 +41,7 @@ CalibrationConfigurationDialog::CalibrationConfigurationDialog(QWidget* parent,

    using namespace InputCommon::CemuhookUDP;
    job = std::make_unique<CalibrationConfigurationJob>(
-        host, port, pad_index, client_id,
+        host, port, pad_index,
        [this](CalibrationConfigurationJob::Status status) {
            QString text;
            switch (status) {
@@ -218,7 +218,6 @@ void ConfigureMotionTouch::OnCemuhookUDPTest() {
    udp_test_in_progress = true;
    InputCommon::CemuhookUDP::TestCommunication(
        ui->udp_server->text().toStdString(), static_cast<u16>(ui->udp_port->text().toInt()), 0,
-        24872,
        [this] {
            LOG_INFO(Frontend, "UDP input test success");
            QMetaObject::invokeMethod(this, "ShowUDPTestResult", Q_ARG(bool, true));
@@ -233,8 +232,7 @@ void ConfigureMotionTouch::OnConfigureTouchCalibration() {
    ui->touch_calibration_config->setEnabled(false);
    ui->touch_calibration_config->setText(tr("Configuring"));
    CalibrationConfigurationDialog dialog(this, ui->udp_server->text().toStdString(),
-                                          static_cast<u16>(ui->udp_port->text().toUInt()), 0,
-                                          24872);
+                                          static_cast<u16>(ui->udp_port->text().toUInt()), 0);
    dialog.exec();
    if (dialog.completed) {
        min_x = dialog.min_x;
@@ -30,7 +30,7 @@ class CalibrationConfigurationDialog : public QDialog {
    Q_OBJECT
 public:
    explicit CalibrationConfigurationDialog(QWidget* parent, const std::string& host, u16 port,
-                                            u8 pad_index, u16 client_id);
+                                            u8 pad_index);
    ~CalibrationConfigurationDialog() override;

 private:
@@ -457,7 +457,7 @@ void Config::ReadValues() {
    Settings::values.yuzu_token = sdl2_config->Get("WebService", "yuzu_token", "");

    // Services
-    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "null");
+    Settings::values.bcat_backend = sdl2_config->Get("Services", "bcat_backend", "none");
    Settings::values.bcat_boxcat_local =
        sdl2_config->GetBoolean("Services", "bcat_boxcat_local", false);
 }
Author	SHA1	Message	Date
yuzubot	dc22e6b270	"Merge Tagged PR 1340"	2021-03-05 13:02:40 +00:00
yuzubot	ec2ebe486d	"Merge Tagged PR 4836"	2021-03-05 13:02:37 +00:00
yuzubot	e87c19ad3e	"Merge Tagged PR 5896"	2021-03-05 13:02:36 +00:00
bunnei	34a3ee1631	Merge pull request #6006 from bunnei/fiber-unique-ptr core: Switch to unique_ptr for usage of Common::Fiber.	2021-03-04 23:59:06 -08:00
bunnei	b8b5891585	Merge pull request #5989 from ReinUsesLisp/cmdpool vk_command_pool: Reduce the command pool size from 4096 to 4	2021-03-04 11:07:31 -08:00
bunnei	394475c4e3	Merge pull request #6004 from german77/udprandom InputCommon: Use an unique client id for each udp socket instance	2021-03-03 15:45:32 -08:00
bunnei	f8bfec3109	Merge pull request #5815 from comex/net-error-reform Network error handling reform	2021-03-02 17:08:47 -08:00
LC	4a45012f35	Merge pull request #6020 from bunnei/shutdown-crash-2 core: Shutdown: Move kernel cleanup to later in shutdown.	2021-03-02 09:28:28 -05:00
bunnei	925671071c	core: Shutdown: Move kernel cleanup to later in shutdown. - Fixes a shutdown crash due to a race condition with GPU still accessing memory.	2021-03-01 21:42:06 -08:00
bunnei	cd25817938	Merge pull request #6019 from Kelebek1/bcat [Service::nifm] Fix bcat_backend's default initialisation	2021-03-01 19:27:06 -08:00
Kelebek1	c7a7e47615	Fix default bcat_backend init	2021-03-02 03:20:16 +00:00
german	9b3af0027b	inputCommon: Use an unique client id for each socket instance	2021-03-01 09:19:33 -06:00
Morph	ac8b1445ff	Merge pull request #6016 from ameerj/remove-async-nvdec gpu_thread: Remove Async NVDEC placeholders	2021-03-01 04:22:46 -05:00
ameerj	52e9d7fa49	gpu_thread: Remove Async NVDEC placeholders This commit removes early placeholders for an implementation of async nvdec. With recent changes to the source code, the placeholders are no longer accurate, and can cause a nullptr dereference due to the nature of the cdma_pusher lifetime.	2021-02-28 22:03:00 -05:00
comex	2910aa77b2	[network] Error handling reform `network.cpp` has several error paths which either: - report "Unhandled host socket error=n" and return `SUCCESS`, or - switch on a few possible errors, log them, and translate them to Errno; the same switch statement is copied and pasted in multiple places in the code Convert these paths to use a helper function `GetAndLogLastError`, which is roughly the equivalent of one of the switch statements, but: - handling more cases (both ones that were already in `Errno`, and a few more I added), and - using OS functions to convert the error to a string when logging, so it'll describe the error even if it's not one of the ones in the switch statement. - To handle this, refactor the logic in `GetLastErrorMsg` to expose a new function `NativeErrorToString` which takes the error number explicitly as an argument. And improve the Windows version a bit. Also, add a test which exercises two random error paths.	2021-02-28 17:25:31 -05:00
bunnei	9e9341f4b4	Merge pull request #6007 from bunnei/ldn-error core: hle: ldn: Error out on call to Initialization.	2021-02-28 13:34:20 -08:00
bunnei	ab65cb499d	core: hle: ldn: Error out on call to Initialization. - Since we do not emulate LDN, returning an error here makes more sense.	2021-02-27 11:59:29 -08:00
bunnei	51fb0a6f96	core: Switch to unique_ptr for usage of Common::Fiber. - With using unique_ptr instead of shared_ptr, we have more explicit ownership of the context. - Fixes a memory leak due to circular reference of the shared pointer.	2021-02-27 11:56:04 -08:00
ReinUsesLisp	aae399c1a8	vk_command_pool: Reduce the command pool size from 4096 to 4 This allows drivers to reuse memory more easily and preallocate less. The optimal number has been measured booting Pokémon Sword.	2021-02-23 19:08:24 -03:00