correct place of unknown function & fix clang-format

src/core/hle/kernel/mutex.cpp

@@ -104,6 +104,7 @@ ResultCode Mutex::Release(VAddr address) {
 
     // There are no more threads waiting for the mutex, release it completely.
     if (thread == nullptr) {
+        ASSERT(GetCurrentThread()->wait_mutex_threads.empty());
         Memory::Write32(address, 0);
         return RESULT_SUCCESS;
     }

src/core/hle/kernel/svc.cpp

@@ -145,6 +145,36 @@ static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thr
     return true;
 };
 
+/// Wait for a kernel object to synchronize, timeout after the specified nanoseconds
+static ResultCode WaitSynchronization1(
+    SharedPtr<WaitObject> object, Thread* thread, s64 nano_seconds = -1,
+    std::function<Thread::WakeupCallback> wakeup_callback = DefaultThreadWakeupCallback) {
+
+    if (!object) {
+        return ERR_INVALID_HANDLE;
+    }
+
+    if (object->ShouldWait(thread)) {
+        if (nano_seconds == 0) {
+            return RESULT_TIMEOUT;
+        }
+
+        thread->wait_objects = {object};
+        object->AddWaitingThread(thread);
+        thread->status = THREADSTATUS_WAIT_SYNCH_ANY;
+
+        // Create an event to wake the thread up after the specified nanosecond delay has passed
+        thread->WakeAfterDelay(nano_seconds);
+        thread->wakeup_callback = wakeup_callback;
+
+        Core::System::GetInstance().PrepareReschedule();
+    } else {
+        object->Acquire(thread);
+    }
+
+    return RESULT_SUCCESS;
+}
+
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
 static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64 handle_count,
                                       s64 nano_seconds) {
@@ -202,7 +232,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     thread->WakeAfterDelay(nano_seconds);
     thread->wakeup_callback = DefaultThreadWakeupCallback;
 
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().PrepareReschedule();
 
     return RESULT_TIMEOUT;
 }
@@ -365,7 +395,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
 
     thread->SetPriority(priority);
 
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().PrepareReschedule();
     return RESULT_SUCCESS;
 }
 
@@ -522,7 +552,6 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     *out_handle = thread->guest_handle;
 
     Core::System::GetInstance().PrepareReschedule();
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     NGLOG_TRACE(Kernel_SVC,
                 "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
@@ -541,10 +570,7 @@ static ResultCode StartThread(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    ASSERT(thread->status == THREADSTATUS_DORMANT);
-
     thread->ResumeFromWait();
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
 
     return RESULT_SUCCESS;
 }
@@ -608,78 +634,61 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
     NGLOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
                 condition_variable_addr, target);
 
-    auto RetrieveWaitingThreads =
-        [](size_t core_index, std::vector<SharedPtr<Thread>>& waiting_threads, VAddr condvar_addr) {
-            const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-            auto& thread_list = scheduler->GetThreadList();
+    u32 processed = 0;
 
-            for (auto& thread : thread_list) {
-                if (thread->condvar_wait_address == condvar_addr)
-                    waiting_threads.push_back(thread);
+    auto signal_process_wide_key = [&](size_t core_index) {
+        const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
+        for (auto& thread : scheduler->GetThreadList()) {
+            if (thread->condvar_wait_address != condition_variable_addr)
+                continue;
+
+            // Only process up to 'target' threads, unless 'target' is -1, in which case process
+            // them all.
+            if (target != -1 && processed >= target)
+                break;
+
+            // If the mutex is not yet acquired, acquire it.
+            u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
+
+            if (mutex_val == 0) {
+                // We were able to acquire the mutex, resume this thread.
+                Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
+                ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+                thread->ResumeFromWait();
+
+                auto lock_owner = thread->lock_owner;
+                if (lock_owner)
+                    lock_owner->RemoveMutexWaiter(thread);
+
+                thread->lock_owner = nullptr;
+                thread->mutex_wait_address = 0;
+                thread->condvar_wait_address = 0;
+                thread->wait_handle = 0;
+            } else {
+                // Couldn't acquire the mutex, block the thread.
+                Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
+                auto owner = g_handle_table.Get<Thread>(owner_handle);
+                ASSERT(owner);
+                ASSERT(thread->status != THREADSTATUS_RUNNING);
+                thread->status = THREADSTATUS_WAIT_MUTEX;
+                thread->wakeup_callback = nullptr;
+
+                // Signal that the mutex now has a waiting thread.
+                Memory::Write32(thread->mutex_wait_address, mutex_val | Mutex::MutexHasWaitersFlag);
+
+                owner->AddMutexWaiter(thread);
+
+                Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
             }
-        };
 
-    // Retrieve a list of all threads that are waiting for this condition variable.
-    std::vector<SharedPtr<Thread>> waiting_threads;
-    RetrieveWaitingThreads(0, waiting_threads, condition_variable_addr);
-    RetrieveWaitingThreads(1, waiting_threads, condition_variable_addr);
-    RetrieveWaitingThreads(2, waiting_threads, condition_variable_addr);
-    RetrieveWaitingThreads(3, waiting_threads, condition_variable_addr);
-    // Sort them by priority, such that the highest priority ones come first.
-    std::sort(waiting_threads.begin(), waiting_threads.end(),
-              [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
-                  return lhs->current_priority < rhs->current_priority;
-              });
-
-    // Only process up to 'target' threads, unless 'target' is -1, in which case process
-    // them all.
-    size_t last = waiting_threads.size();
-    if (target != -1)
-        last = target;
-
-    // If there are no threads waiting on this condition variable, just exit
-    if (last > waiting_threads.size())
-        return RESULT_SUCCESS;
-
-    for (size_t index = 0; index < last; ++index) {
-        auto& thread = waiting_threads[index];
-
-        ASSERT(thread->condvar_wait_address == condition_variable_addr);
-
-        // If the mutex is not yet acquired, acquire it.
-        u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
-
-        if (mutex_val == 0) {
-            // We were able to acquire the mutex, resume this thread.
-            Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
-            ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
-            thread->ResumeFromWait();
-
-            auto lock_owner = thread->lock_owner;
-            if (lock_owner)
-                lock_owner->RemoveMutexWaiter(thread);
-
-            thread->lock_owner = nullptr;
-            thread->mutex_wait_address = 0;
-            thread->condvar_wait_address = 0;
-            thread->wait_handle = 0;
-        } else {
-            // Couldn't acquire the mutex, block the thread.
-            Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            auto owner = g_handle_table.Get<Thread>(owner_handle);
-            ASSERT(owner);
-            ASSERT(thread->status != THREADSTATUS_RUNNING);
-            thread->status = THREADSTATUS_WAIT_MUTEX;
-            thread->wakeup_callback = nullptr;
-
-            // Signal that the mutex now has a waiting thread.
-            Memory::Write32(thread->mutex_wait_address, mutex_val | Mutex::MutexHasWaitersFlag);
-
-            owner->AddMutexWaiter(thread);
-
-            Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+            ++processed;
         }
-    }
+    };
+
+    signal_process_wide_key(0);
+    signal_process_wide_key(1);
+    signal_process_wide_key(2);
+    signal_process_wide_key(3);
 
     return RESULT_SUCCESS;
 }

src/core/hle/result.h

@@ -32,8 +32,7 @@ enum class ErrorModule : u32 {
     Common = 0,
     Kernel = 1,
     FS = 2,
-    OS = 3, // used for Memory, Thread, Mutex, Nvidia
-    HTCS = 4,
+    NvidiaTransferMemory = 3,
     NCM = 5,
     DD = 6,
     LR = 8,
@@ -63,7 +62,6 @@ enum class ErrorModule : u32 {
     NFP = 115,
     Time = 116,
     FGM = 117,
-    OE = 118,
     PCIe = 120,
     Friends = 121,
     BCAT = 122,
@@ -91,14 +89,12 @@ enum class ErrorModule : u32 {
     NGC = 146,
     ERPT = 147,
     APM = 148,
-    Profiler = 150,
     ErrorUpload = 151,
     Audio = 153,
     NPNS = 154,
     NPNSHTTPSTREAM = 155,
     ARP = 157,
-    SWKBD = 158,
-    BOOT = 159,
+    BOOT = 158,
     NFCMifare = 161,
     UserlandAssert = 162,
     Fatal = 163,
@@ -107,13 +103,11 @@ enum class ErrorModule : u32 {
     BGTC = 167,
     UserlandCrash = 168,
     SREPO = 180,
-    Dauth = 181,
     HID = 202,
     LDN = 203,
     Irsensor = 205,
     Capture = 206,
     Manu = 208,
-    ATK = 209,
     GRC = 212,
     Migration = 216,
     MigrationLdcServ = 217,

src/core/hle/service/fatal/fatal.cpp

@@ -13,7 +13,7 @@ namespace Service::Fatal {
 Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
     : ServiceFramework(name), module(std::move(module)) {}
 
-void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
+void Module::Interface::FatalSimple(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp(ctx);
     u32 error_code = rp.Pop<u32>();
     NGLOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
@@ -21,7 +21,7 @@ void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx) {
+void Module::Interface::TransitionToFatalError(Kernel::HLERequestContext& ctx) {
     NGLOG_WARNING(Service_Fatal, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);

src/core/hle/service/fatal/fatal.h

@@ -14,8 +14,8 @@ public:
     public:
         Interface(std::shared_ptr<Module> module, const char* name);
 
-        void ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx);
-        void ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx);
+        void FatalSimple(Kernel::HLERequestContext& ctx);
+        void TransitionToFatalError(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;

src/core/hle/service/fatal/fatal_u.cpp

@@ -8,9 +8,8 @@ namespace Service::Fatal {
 
 Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "ThrowFatal"},
-        {1, &Fatal_U::ThrowFatalWithPolicy, "ThrowFatalWithPolicy"},
-        {2, &Fatal_U::ThrowFatalWithCpuContext, "ThrowFatalWithCpuContext"},
+        {1, &Fatal_U::FatalSimple, "FatalSimple"},
+        {2, &Fatal_U::TransitionToFatalError, "TransitionToFatalError"},
     };
     RegisterHandlers(functions);
 }

src/core/hle/service/hid/hid.h

@@ -12,7 +12,7 @@ namespace Service::HID {
 // Begin enums and output structs
 
 constexpr u32 HID_NUM_ENTRIES = 17;
-constexpr u32 HID_NUM_LAYOUTS = 2;
+constexpr u32 HID_NUM_LAYOUTS = 7;
 constexpr s32 HID_JOYSTICK_MAX = 0x8000;
 constexpr s32 HID_JOYSTICK_MIN = -0x8000;
 

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -26,8 +26,6 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vecto
         return BindChannel(input, output);
     case IoctlCommand::IocGetVaRegionsCommand:
         return GetVARegions(input, output);
-    case IoctlCommand::IocUnmapBufferCommand:
-        return UnmapBuffer(input, output);
     }
 
     if (static_cast<IoctlCommand>(command.cmd.Value()) == IoctlCommand::IocRemapCommand)
@@ -127,37 +125,6 @@ u32 nvhost_as_gpu::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& ou
         params.offset = gpu.memory_manager->MapBufferEx(object->addr, object->size);
     }
 
-    // Create a new mapping entry for this operation.
-    ASSERT_MSG(buffer_mappings.find(params.offset) == buffer_mappings.end(),
-               "Offset is already mapped");
-
-    BufferMapping mapping{};
-    mapping.nvmap_handle = params.nvmap_handle;
-    mapping.offset = params.offset;
-    mapping.size = object->size;
-
-    buffer_mappings[params.offset] = mapping;
-
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
-u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlUnmapBuffer params{};
-    std::memcpy(&params, input.data(), input.size());
-
-    NGLOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
-
-    auto& gpu = Core::System::GetInstance().GPU();
-
-    auto itr = buffer_mappings.find(params.offset);
-
-    ASSERT_MSG(itr != buffer_mappings.end(), "Tried to unmap invalid mapping");
-
-    params.offset = gpu.memory_manager->UnmapBuffer(params.offset, itr->second.size);
-
-    buffer_mappings.erase(itr->second.offset);
-
     std::memcpy(output.data(), &params, output.size());
     return 0;
 }

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

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 #include "common/common_types.h"
@@ -31,7 +30,6 @@ private:
         IocMapBufferExCommand = 0xC0284106,
         IocBindChannelCommand = 0x40044101,
         IocGetVaRegionsCommand = 0xC0404108,
-        IocUnmapBufferCommand = 0xC0084105,
     };
 
     struct IoctlInitalizeEx {
@@ -78,11 +76,6 @@ private:
     };
     static_assert(sizeof(IoctlMapBufferEx) == 40, "IoctlMapBufferEx is incorrect size");
 
-    struct IoctlUnmapBuffer {
-        u64_le offset;
-    };
-    static_assert(sizeof(IoctlUnmapBuffer) == 8, "IoctlUnmapBuffer is incorrect size");
-
     struct IoctlBindChannel {
         u32_le fd;
     };
@@ -105,22 +98,12 @@ private:
     static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(IoctlVaRegion) * 2,
                   "IoctlGetVaRegions is incorrect size");
 
-    struct BufferMapping {
-        u64 offset;
-        u64 size;
-        u32 nvmap_handle;
-    };
-
-    /// Map containing the nvmap object mappings in GPU memory.
-    std::unordered_map<u64, BufferMapping> buffer_mappings;
-
     u32 channel{};
 
     u32 InitalizeEx(const std::vector<u8>& input, std::vector<u8>& output);
     u32 AllocateSpace(const std::vector<u8>& input, std::vector<u8>& output);
     u32 Remap(const std::vector<u8>& input, std::vector<u8>& output);
     u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
     u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
 

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

@@ -26,64 +26,12 @@ private:
         IocSyncptIncrCommand = 0x40040015,
         IocSyncptWaitCommand = 0xC00C0016,
         IocModuleMutexCommand = 0x40080017,
-        IocModuleRegRDWRCommand = 0xC0180018,
+        IocModuleRegRDWRCommand = 0xC008010E,
         IocSyncptWaitexCommand = 0xC0100019,
         IocSyncptReadMaxCommand = 0xC008001A,
-        IocGetConfigCommand = 0xC183001B,
-        IocCtrlEventSignalCommand = 0xC004001C,
         IocCtrlEventWaitCommand = 0xC010001D,
-        IocCtrlEventWaitAsyncCommand = 0xC010001E,
-        IocCtrlEventRegisterCommand = 0xC004001F,
-        IocCtrlEventUnregisterCommand = 0xC0040020,
-        IocCtrlEventKillCommand = 0x40080021,
+        IocGetConfigCommand = 0xC183001B,
     };
-    struct IocSyncptReadParams {
-        u32_le id;
-        u32_le value;
-    };
-    static_assert(sizeof(IocSyncptReadParams) == 8, "IocSyncptReadParams is incorrect size");
-
-    struct IocSyncptIncrParams {
-        u32_le id;
-    };
-    static_assert(sizeof(IocSyncptIncrParams) == 4, "IocSyncptIncrParams is incorrect size");
-
-    struct IocSyncptWaitParams {
-        u32_le id;
-        u32_le thresh;
-        s32_le timeout;
-    };
-    static_assert(sizeof(IocSyncptWaitParams) == 12, "IocSyncptWaitParams is incorrect size");
-
-    struct IocModuleMutexParams {
-        u32_le id;
-        u32_le lock; // (0 = unlock and 1 = lock)
-    };
-    static_assert(sizeof(IocModuleMutexParams) == 8, "IocModuleMutexParams is incorrect size");
-
-    struct IocModuleRegRDWRParams {
-        u32_le id;
-        u32_le num_offsets;
-        u32_le block_size;
-        u32_le offsets;
-        u32_le values;
-        u32_le write;
-    };
-    static_assert(sizeof(IocModuleRegRDWRParams) == 24, "IocModuleRegRDWRParams is incorrect size");
-
-    struct IocSyncptWaitexParams {
-        u32_le id;
-        u32_le thresh;
-        s32_le timeout;
-        u32_le value;
-    };
-    static_assert(sizeof(IocSyncptWaitexParams) == 16, "IocSyncptWaitexParams is incorrect size");
-
-    struct IocSyncptReadMaxParams {
-        u32_le id;
-        u32_le value;
-    };
-    static_assert(sizeof(IocSyncptReadMaxParams) == 8, "IocSyncptReadMaxParams is incorrect size");
 
     struct IocGetConfigParams {
         std::array<char, 0x41> domain_str;
@@ -92,12 +40,6 @@ private:
     };
     static_assert(sizeof(IocGetConfigParams) == 387, "IocGetConfigParams is incorrect size");
 
-    struct IocCtrlEventSignalParams {
-        u32_le user_event_id;
-    };
-    static_assert(sizeof(IocCtrlEventSignalParams) == 4,
-                  "IocCtrlEventSignalParams is incorrect size");
-
     struct IocCtrlEventWaitParams {
         u32_le syncpt_id;
         u32_le threshold;
@@ -106,32 +48,6 @@ private:
     };
     static_assert(sizeof(IocCtrlEventWaitParams) == 16, "IocCtrlEventWaitParams is incorrect size");
 
-    struct IocCtrlEventWaitAsyncParams {
-        u32_le syncpt_id;
-        u32_le threshold;
-        u32_le timeout;
-        u32_le value;
-    };
-    static_assert(sizeof(IocCtrlEventWaitAsyncParams) == 16,
-                  "IocCtrlEventWaitAsyncParams is incorrect size");
-
-    struct IocCtrlEventRegisterParams {
-        u32_le user_event_id;
-    };
-    static_assert(sizeof(IocCtrlEventRegisterParams) == 4,
-                  "IocCtrlEventRegisterParams is incorrect size");
-
-    struct IocCtrlEventUnregisterParams {
-        u32_le user_event_id;
-    };
-    static_assert(sizeof(IocCtrlEventUnregisterParams) == 4,
-                  "IocCtrlEventUnregisterParams is incorrect size");
-
-    struct IocCtrlEventKill {
-        u64_le user_events;
-    };
-    static_assert(sizeof(IocCtrlEventKill) == 8, "IocCtrlEventKill is incorrect size");
-
     u32 NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
 
     u32 IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output);

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -32,8 +32,6 @@ u32 nvhost_gpu::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u
         return AllocGPFIFOEx2(input, output);
     case IoctlCommand::IocAllocObjCtxCommand:
         return AllocateObjectContext(input, output);
-    case IoctlCommand::IocChannelGetWaitbaseCommand:
-        return GetWaitbase(input, output);
     }
 
     if (command.group == NVGPU_IOCTL_MAGIC) {
@@ -140,13 +138,4 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
     return 0;
 }
 
-u32 nvhost_gpu::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlGetWaitbase params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
-    NGLOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
-    params.value = 0; // Seems to be hard coded at 0
-    std::memcpy(output.data(), &params, output.size());
-    return 0;
-}
-
 } // namespace Service::Nvidia::Devices

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

@@ -33,7 +33,6 @@ private:
         IocChannelSetPriorityCommand = 0x4004480D,
         IocAllocGPFIFOEx2Command = 0xC020481A,
         IocAllocObjCtxCommand = 0xC0104809,
-        IocChannelGetWaitbaseCommand = 0xC0080003,
     };
 
     enum class CtxObjects : u32_le {
@@ -118,13 +117,7 @@ private:
         IoctlFence fence_out; // returned new fence object for others to wait on
     };
     static_assert(sizeof(IoctlSubmitGpfifo) == 16 + sizeof(IoctlFence),
-                  "IoctlSubmitGpfifo is incorrect size");
-
-    struct IoctlGetWaitbase {
-        u32 unknown; // seems to be ignored? Nintendo added this
-        u32 value;
-    };
-    static_assert(sizeof(IoctlGetWaitbase) == 8, "IoctlGetWaitbase is incorrect size");
+                  "submit_gpfifo is incorrect size");
 
     u32_le nvmap_fd{};
     u64_le user_data{};
@@ -140,7 +133,6 @@ private:
     u32 AllocGPFIFOEx2(const std::vector<u8>& input, std::vector<u8>& output);
     u32 AllocateObjectContext(const std::vector<u8>& input, std::vector<u8>& output);
     u32 SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
 
     std::shared_ptr<nvmap> nvmap_dev;
 };

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -30,8 +30,6 @@ u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& o
         return IocFromId(input, output);
     case IoctlCommand::Param:
         return IocParam(input, output);
-    case IoctlCommand::Free:
-        return IocFree(input, output);
     }
 
     UNIMPLEMENTED_MSG("Unimplemented ioctl");
@@ -47,7 +45,6 @@ u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
     object->id = next_id++;
     object->size = params.size;
     object->status = Object::Status::Created;
-    object->refcount = 1;
 
     u32 handle = next_handle++;
     handles[handle] = std::move(object);
@@ -104,8 +101,6 @@ u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
                             [&](const auto& entry) { return entry.second->id == params.id; });
     ASSERT(itr != handles.end());
 
-    itr->second->refcount++;
-
     // Return the existing handle instead of creating a new one.
     params.handle = itr->first;
 
@@ -119,25 +114,25 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     IocParamParams params;
     std::memcpy(&params, input.data(), sizeof(params));
 
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
+    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.type);
 
     auto object = GetObject(params.handle);
     ASSERT(object);
     ASSERT(object->status == Object::Status::Allocated);
 
-    switch (static_cast<ParamTypes>(params.param)) {
+    switch (static_cast<ParamTypes>(params.type)) {
     case ParamTypes::Size:
-        params.result = object->size;
+        params.value = object->size;
         break;
     case ParamTypes::Alignment:
-        params.result = object->align;
+        params.value = object->align;
         break;
     case ParamTypes::Heap:
         // TODO(Subv): Seems to be a hardcoded value?
-        params.result = 0x40000000;
+        params.value = 0x40000000;
         break;
     case ParamTypes::Kind:
-        params.result = object->kind;
+        params.value = object->kind;
         break;
     default:
         UNIMPLEMENTED();
@@ -147,34 +142,4 @@ u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
     return 0;
 }
 
-u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
-    enum FreeFlags {
-        Freed = 0,
-        NotFreedYet = 1,
-    };
-
-    IocFreeParams params;
-    std::memcpy(&params, input.data(), sizeof(params));
-
-    NGLOG_WARNING(Service_NVDRV, "(STUBBED) called");
-
-    auto itr = handles.find(params.handle);
-    ASSERT(itr != handles.end());
-
-    itr->second->refcount--;
-
-    params.refcount = itr->second->refcount;
-    params.size = itr->second->size;
-
-    if (itr->second->refcount == 0)
-        params.flags = Freed;
-    else
-        params.flags = NotFreedYet;
-
-    handles.erase(params.handle);
-
-    std::memcpy(output.data(), &params, sizeof(params));
-    return 0;
-}
-
 } // namespace Service::Nvidia::Devices

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

@@ -34,7 +34,6 @@ public:
         u8 kind;
         VAddr addr;
         Status status;
-        u32 refcount;
     };
 
     std::shared_ptr<Object> GetObject(u32 handle) const {
@@ -59,25 +58,16 @@ private:
         Create = 0xC0080101,
         FromId = 0xC0080103,
         Alloc = 0xC0200104,
-        Free = 0xC0180105,
         Param = 0xC00C0109,
-        GetId = 0xC008010E,
+        GetId = 0xC008010E
     };
+
     struct IocCreateParams {
         // Input
         u32_le size;
         // Output
         u32_le handle;
     };
-    static_assert(sizeof(IocCreateParams) == 8, "IocCreateParams has wrong size");
-
-    struct IocFromIdParams {
-        // Input
-        u32_le id;
-        // Output
-        u32_le handle;
-    };
-    static_assert(sizeof(IocFromIdParams) == 8, "IocFromIdParams has wrong size");
 
     struct IocAllocParams {
         // Input
@@ -89,25 +79,6 @@ private:
         INSERT_PADDING_BYTES(7);
         u64_le addr;
     };
-    static_assert(sizeof(IocAllocParams) == 32, "IocAllocParams has wrong size");
-
-    struct IocFreeParams {
-        u32_le handle;
-        INSERT_PADDING_BYTES(4);
-        u64_le refcount;
-        u32_le size;
-        u32_le flags;
-    };
-    static_assert(sizeof(IocFreeParams) == 24, "IocFreeParams has wrong size");
-
-    struct IocParamParams {
-        // Input
-        u32_le handle;
-        u32_le param;
-        // Output
-        u32_le result;
-    };
-    static_assert(sizeof(IocParamParams) == 12, "IocParamParams has wrong size");
 
     struct IocGetIdParams {
         // Output
@@ -115,14 +86,27 @@ private:
         // Input
         u32_le handle;
     };
-    static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
+
+    struct IocFromIdParams {
+        // Input
+        u32_le id;
+        // Output
+        u32_le handle;
+    };
+
+    struct IocParamParams {
+        // Input
+        u32_le handle;
+        u32_le type;
+        // Output
+        u32_le value;
+    };
 
     u32 IocCreate(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocAlloc(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocGetId(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocFromId(const std::vector<u8>& input, std::vector<u8>& output);
     u32 IocParam(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 IocFree(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

src/video_core/engines/shader_bytecode.h

@@ -193,11 +193,6 @@ union Instruction {
         BitField<50, 1, u64> abs_d;
         BitField<56, 1, u64> negate_imm;
 
-        union {
-            BitField<39, 3, u64> pred;
-            BitField<42, 1, u64> negate_pred;
-        } fmnmx;
-
         float GetImm20_19() const {
             float result{};
             u32 imm{static_cast<u32>(imm20_19)};
@@ -325,7 +320,6 @@ public:
         ISETP_C,
         ISETP_IMM,
         ISETP_R,
-        PSETP,
     };
 
     enum class Type {
@@ -337,7 +331,6 @@ public:
         FloatSet,
         FloatSetPredicate,
         IntegerSetPredicate,
-        PredicateSetPredicate,
         Conversion,
         Unknown,
     };
@@ -484,7 +477,6 @@ private:
             INST("010010110110----", Id::ISETP_C, Type::IntegerSetPredicate, "ISETP_C"),
             INST("010110110110----", Id::ISETP_R, Type::IntegerSetPredicate, "ISETP_R"),
             INST("0011011-0110----", Id::ISETP_IMM, Type::IntegerSetPredicate, "ISETP_IMM"),
-            INST("0101000010010---", Id::PSETP, Type::PredicateSetPredicate, "PSETP"),
         };
 #undef INST
         std::stable_sort(table.begin(), table.end(), [](const auto& a, const auto& b) {

src/video_core/memory_manager.cpp

@@ -58,25 +58,6 @@ GPUVAddr MemoryManager::MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size)
     return gpu_addr;
 }
 
-GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
-    ASSERT((gpu_addr & PAGE_MASK) == 0);
-
-    for (u64 offset = 0; offset < size; offset += PAGE_SIZE) {
-        ASSERT(PageSlot(gpu_addr + offset) != static_cast<u64>(PageStatus::Allocated) &&
-               PageSlot(gpu_addr + offset) != static_cast<u64>(PageStatus::Unmapped));
-        PageSlot(gpu_addr + offset) = static_cast<u64>(PageStatus::Unmapped);
-    }
-
-    // Delete the region mappings that are contained within the unmapped region
-    mapped_regions.erase(std::remove_if(mapped_regions.begin(), mapped_regions.end(),
-                                        [&](const MappedRegion& region) {
-                                            return region.gpu_addr <= gpu_addr &&
-                                                   region.gpu_addr + region.size < gpu_addr + size;
-                                        }),
-                         mapped_regions.end());
-    return gpu_addr;
-}
-
 boost::optional<GPUVAddr> MemoryManager::FindFreeBlock(u64 size, u64 align) {
     GPUVAddr gpu_addr = 0;
     u64 free_space = 0;

src/video_core/memory_manager.h

@@ -25,7 +25,6 @@ public:
     GPUVAddr AllocateSpace(GPUVAddr gpu_addr, u64 size, u64 align);
     GPUVAddr MapBufferEx(VAddr cpu_addr, u64 size);
     GPUVAddr MapBufferEx(VAddr cpu_addr, GPUVAddr gpu_addr, u64 size);
-    GPUVAddr UnmapBuffer(GPUVAddr gpu_addr, u64 size);
     boost::optional<VAddr> GpuToCpuAddress(GPUVAddr gpu_addr);
     std::vector<GPUVAddr> CpuToGpuAddress(VAddr cpu_addr) const;
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -75,11 +75,14 @@ RasterizerOpenGL::RasterizerOpenGL() {
     // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
     state.clip_distance[0] = true;
 
-    // Generate VAO and UBO
+    // Generate VBO, VAO and UBO
+    vertex_buffer = OGLStreamBuffer::MakeBuffer(GLAD_GL_ARB_buffer_storage, GL_ARRAY_BUFFER);
+    vertex_buffer->Create(VERTEX_BUFFER_SIZE, VERTEX_BUFFER_SIZE / 2);
     sw_vao.Create();
     uniform_buffer.Create();
 
     state.draw.vertex_array = sw_vao.handle;
+    state.draw.vertex_buffer = vertex_buffer->GetHandle();
     state.draw.uniform_buffer = uniform_buffer.handle;
     state.Apply();
 
@@ -87,6 +90,7 @@ RasterizerOpenGL::RasterizerOpenGL() {
     framebuffer.Create();
 
     hw_vao.Create();
+    hw_vao_enabled_attributes.fill(false);
 
     stream_buffer = OGLStreamBuffer::MakeBuffer(has_ARB_buffer_storage, GL_ARRAY_BUFFER);
     stream_buffer->Create(STREAM_BUFFER_SIZE, STREAM_BUFFER_SIZE / 2);
@@ -177,6 +181,8 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
         glVertexAttribFormat(index, attrib.ComponentCount(), MaxwellToGL::VertexType(attrib),
                              attrib.IsNormalized() ? GL_TRUE : GL_FALSE, attrib.offset);
         glVertexAttribBinding(index, attrib.buffer);
+
+        hw_vao_enabled_attributes[index] = true;
     }
 
     return {array_ptr, buffer_offset};

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -134,17 +134,21 @@ private:
     std::unique_ptr<GLShader::ProgramManager> shader_program_manager;
     OGLVertexArray sw_vao;
     OGLVertexArray hw_vao;
+    std::array<bool, 16> hw_vao_enabled_attributes;
 
     std::array<SamplerInfo, GLShader::NumTextureSamplers> texture_samplers;
     std::array<std::array<OGLBuffer, Tegra::Engines::Maxwell3D::Regs::MaxConstBuffers>,
                Tegra::Engines::Maxwell3D::Regs::MaxShaderStage>
         ssbos;
 
-    static constexpr size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
-    std::unique_ptr<OGLStreamBuffer> stream_buffer;
+    static constexpr size_t VERTEX_BUFFER_SIZE = 128 * 1024 * 1024;
+    std::unique_ptr<OGLStreamBuffer> vertex_buffer;
     OGLBuffer uniform_buffer;
     OGLFramebuffer framebuffer;
 
+    static constexpr size_t STREAM_BUFFER_SIZE = 4 * 1024 * 1024;
+    std::unique_ptr<OGLStreamBuffer> stream_buffer;
+
     size_t CalculateVertexArraysSize() const;
 
     std::pair<u8*, GLintptr> SetupVertexArrays(u8* array_ptr, GLintptr buffer_offset);

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -580,63 +580,20 @@ private:
      * @param instr Instruction to generate the if condition for.
      * @returns string containing the predicate condition.
      */
-    std::string GetPredicateCondition(u64 index, bool negate) const {
+    std::string GetPredicateCondition(Instruction instr) const {
         using Tegra::Shader::Pred;
-        std::string variable;
+        ASSERT(instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex));
 
-        // Index 7 is used as an 'Always True' condition.
-        if (index == static_cast<u64>(Pred::UnusedIndex))
-            variable = "true";
-        else
-            variable = 'p' + std::to_string(index);
+        std::string variable =
+            'p' + std::to_string(static_cast<u64>(instr.pred.pred_index.Value()));
 
-        if (negate) {
+        if (instr.negate_pred) {
             return "!(" + variable + ')';
         }
 
         return variable;
     }
 
-    /**
-     * Returns the comparison string to use to compare two values in the 'set' family of
-     * instructions.
-     * @params condition The condition used in the 'set'-family instruction.
-     * @returns String corresponding to the GLSL operator that matches the desired comparison.
-     */
-    std::string GetPredicateComparison(Tegra::Shader::PredCondition condition) const {
-        using Tegra::Shader::PredCondition;
-        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},
-            {PredCondition::Equal, "=="},
-            {PredCondition::LessEqual, "<="},
-            {PredCondition::GreaterThan, ">"},
-        };
-
-        auto comparison = PredicateComparisonStrings.find(condition);
-        ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
-                   "Unknown predicate comparison operation");
-        return comparison->second;
-    }
-
-    /**
-     * Returns the operator string to use to combine two predicates in the 'setp' family of
-     * instructions.
-     * @params operation The operator used in the 'setp'-family instruction.
-     * @returns String corresponding to the GLSL operator that matches the desired operator.
-     */
-    std::string GetPredicateCombiner(Tegra::Shader::PredOperation operation) const {
-        using Tegra::Shader::PredOperation;
-        static const std::unordered_map<PredOperation, const char*> PredicateOperationStrings = {
-            {PredOperation::And, "&&"},
-            {PredOperation::Or, "||"},
-            {PredOperation::Xor, "^^"},
-        };
-
-        auto op = PredicateOperationStrings.find(operation);
-        ASSERT_MSG(op != PredicateOperationStrings.end(), "Unknown predicate operation");
-        return op->second;
-    }
-
     /*
      * Returns whether the instruction at the specified offset is a 'sched' instruction.
      * Sched instructions always appear before a sequence of 3 instructions.
@@ -677,9 +634,7 @@ private:
                    "NeverExecute predicate not implemented");
 
         if (instr.pred.pred_index != static_cast<u64>(Pred::UnusedIndex)) {
-            shader.AddLine("if (" +
-                           GetPredicateCondition(instr.pred.pred_index, instr.negate_pred != 0) +
-                           ')');
+            shader.AddLine("if (" + GetPredicateCondition(instr) + ')');
             shader.AddLine('{');
             ++shader.scope;
         }
@@ -775,16 +730,6 @@ private:
                 }
                 break;
             }
-            case OpCode::Id::FMNMX: {
-                std::string condition =
-                    GetPredicateCondition(instr.alu.fmnmx.pred, instr.alu.fmnmx.negate_pred != 0);
-                std::string parameters = op_a + ',' + op_b;
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        '(' + condition + ") ? min(" + parameters + ") : max(" +
-                                            parameters + ')',
-                                        1, 1);
-                break;
-            }
             case OpCode::Id::RRO: {
                 NGLOG_DEBUG(HW_GPU, "Skipping RRO instruction");
                 break;
@@ -928,25 +873,28 @@ private:
             }
 
             using Tegra::Shader::Pred;
+            ASSERT_MSG(instr.fsetp.pred0 == static_cast<u64>(Pred::UnusedIndex) &&
+                           instr.fsetp.pred39 == static_cast<u64>(Pred::UnusedIndex),
+                       "Compound predicates are not implemented");
+
             // We can't use the constant predicate as destination.
             ASSERT(instr.fsetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
 
-            std::string second_pred =
-                GetPredicateCondition(instr.fsetp.pred39, instr.fsetp.neg_pred != 0);
-
-            std::string comparator = GetPredicateComparison(instr.fsetp.cond);
-            std::string combiner = GetPredicateCombiner(instr.fsetp.op);
-
-            std::string predicate = '(' + op_a + ") " + comparator + " (" + op_b + ')';
-            // Set the primary predicate to the result of Predicate OP SecondPredicate
-            SetPredicate(instr.fsetp.pred3,
-                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
-
-            if (instr.fsetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
-                // Set the secondary predicate to the result of !Predicate OP SecondPredicate, if
-                // enabled
-                SetPredicate(instr.fsetp.pred0,
-                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
+            using Tegra::Shader::PredCondition;
+            switch (instr.fsetp.cond) {
+            case PredCondition::LessThan:
+                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") < (" + op_b + ')');
+                break;
+            case PredCondition::Equal:
+                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") == (" + op_b + ')');
+                break;
+            case PredCondition::LessEqual:
+                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") <= (" + op_b + ')');
+                break;
+            default:
+                NGLOG_CRITICAL(HW_GPU, "Unhandled predicate condition: {} (a: {}, b: {})",
+                               static_cast<unsigned>(instr.fsetp.cond.Value()), op_a, op_b);
+                UNREACHABLE();
             }
             break;
         }
@@ -978,18 +926,35 @@ private:
                 op_b = "abs(" + op_b + ')';
             }
 
+            using Tegra::Shader::Pred;
+            ASSERT_MSG(instr.fset.pred39 == static_cast<u64>(Pred::UnusedIndex),
+                       "Compound predicates are not implemented");
+
             // The fset instruction sets a register to 1.0 if the condition is true, and to 0
             // otherwise.
-            std::string second_pred =
-                GetPredicateCondition(instr.fset.pred39, instr.fset.neg_pred != 0);
-
-            std::string comparator = GetPredicateComparison(instr.fset.cond);
-            std::string combiner = GetPredicateCombiner(instr.fset.op);
-
-            std::string predicate = "(((" + op_a + ") " + comparator + " (" + op_b + ")) " +
-                                    combiner + " (" + second_pred + "))";
-
-            regs.SetRegisterToFloat(instr.gpr0, 0, predicate + " ? 1.0 : 0.0", 1, 1);
+            using Tegra::Shader::PredCondition;
+            switch (instr.fset.cond) {
+            case PredCondition::LessThan:
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        "((" + op_a + ") < (" + op_b + ")) ? 1.0 : 0", 1, 1);
+                break;
+            case PredCondition::Equal:
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        "((" + op_a + ") == (" + op_b + ")) ? 1.0 : 0", 1, 1);
+                break;
+            case PredCondition::LessEqual:
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        "((" + op_a + ") <= (" + op_b + ")) ? 1.0 : 0", 1, 1);
+                break;
+            case PredCondition::GreaterThan:
+                regs.SetRegisterToFloat(instr.gpr0, 0,
+                                        "((" + op_a + ") > (" + op_b + ")) ? 1.0 : 0", 1, 1);
+                break;
+            default:
+                NGLOG_CRITICAL(HW_GPU, "Unhandled predicate condition: {} (a: {}, b: {})",
+                               static_cast<unsigned>(instr.fset.cond.Value()), op_a, op_b);
+                UNREACHABLE();
+            }
             break;
         }
         default: {

src/video_core/renderer_opengl/gl_shader_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <string>
 #include <vector>
 #include <glad/glad.h>
 #include "common/assert.h"
@@ -12,27 +11,6 @@
 
 namespace GLShader {
 
-/**
- * Utility function to log the source code of a list of shaders.
- * @param shaders The OpenGL shaders whose source we will print.
- */
-template <typename... T>
-void LogShaderSource(T... shaders) {
-    auto shader_list = {shaders...};
-
-    for (const auto& shader : shader_list) {
-        if (shader == 0)
-            continue;
-
-        GLint source_length;
-        glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &source_length);
-
-        std::string source(source_length, ' ');
-        glGetShaderSource(shader, source_length, nullptr, &source[0]);
-        NGLOG_INFO(Render_OpenGL, "Shader source {}", source);
-    }
-}
-
 /**
  * Utility function to create and compile an OpenGL GLSL shader
  * @param source String of the GLSL shader program
@@ -77,11 +55,6 @@ GLuint LoadProgram(bool separable_program, T... shaders) {
         }
     }
 
-    if (result == GL_FALSE) {
-        // There was a problem linking the shader, print the source for debugging purposes.
-        LogShaderSource(shaders...);
-    }
-
     ASSERT_MSG(result == GL_TRUE, "Shader not linked");
 
     ((shaders == 0 ? (void)0 : glDetachShader(program_id, shaders)), ...);

src/yuzu/debugger/wait_tree.cpp

@@ -98,30 +98,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeMutexInfo::GetChildren() cons
     return list;
 }
 
-WaitTreeCallstack::WaitTreeCallstack(const Kernel::Thread& thread) : thread(thread) {}
-
-QString WaitTreeCallstack::GetText() const {
-    return tr("Call stack");
-}
-
-std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeCallstack::GetChildren() const {
-    std::vector<std::unique_ptr<WaitTreeItem>> list;
-
-    constexpr size_t BaseRegister = 29;
-    u64 base_pointer = thread.context.cpu_registers[BaseRegister];
-
-    while (base_pointer != 0) {
-        u64 lr = Memory::Read64(base_pointer + sizeof(u64));
-        if (lr == 0)
-            break;
-        list.push_back(
-            std::make_unique<WaitTreeText>(tr("0x%1").arg(lr - sizeof(u32), 16, 16, QChar('0'))));
-        base_pointer = Memory::Read64(base_pointer);
-    }
-
-    return list;
-}
-
 WaitTreeWaitObject::WaitTreeWaitObject(const Kernel::WaitObject& o) : object(o) {}
 
 bool WaitTreeExpandableItem::IsExpandable() const {
@@ -293,8 +269,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
                                                             thread.IsSleepingOnWaitAll()));
     }
 
-    list.push_back(std::make_unique<WaitTreeCallstack>(thread));
-
     return list;
 }
 

src/yuzu/debugger/wait_tree.h

@@ -73,17 +73,6 @@ private:
     Kernel::SharedPtr<Kernel::Thread> owner;
 };
 
-class WaitTreeCallstack : public WaitTreeExpandableItem {
-    Q_OBJECT
-public:
-    explicit WaitTreeCallstack(const Kernel::Thread& thread);
-    QString GetText() const override;
-    std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
-
-private:
-    const Kernel::Thread& thread;
-};
-
 class WaitTreeWaitObject : public WaitTreeExpandableItem {
     Q_OBJECT
 public:

src/yuzu_cmd/yuzu.cpp

@@ -7,19 +7,8 @@
 #include <string>
 #include <thread>
 
-#include "common/logging/backend.h"
-#include "common/logging/filter.h"
-#include "common/logging/log.h"
+// This needs to be included before getopt.h because the latter #defines symbols used by it
 #include "common/microprofile.h"
-#include "common/scm_rev.h"
-#include "common/scope_exit.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/gdbstub/gdbstub.h"
-#include "core/loader/loader.h"
-#include "core/settings.h"
-#include "yuzu_cmd/config.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
 
 #ifdef _MSC_VER
 #include <getopt.h>
@@ -35,6 +24,19 @@
 #include <shellapi.h>
 #endif
 
+#include "common/logging/backend.h"
+#include "common/logging/filter.h"
+#include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "common/scope_exit.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/loader/loader.h"
+#include "core/settings.h"
+#include "yuzu_cmd/config.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
+
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable