review comments applied

src/core/libraries/gnmdriver/gnmdriver.cpp

@@ -1307,8 +1307,8 @@ static inline s32 PatchFlipRequest(u32* cmdbuf, u32 size, u32 vo_handle, u32 buf
     auto* write_lock = reinterpret_cast<PM4CmdWriteData*>(cmdbuf);
     write_lock->header = PM4Type3Header{PM4ItOpcode::WriteData, 3};
     write_lock->raw = 0x500u;
-    *reinterpret_cast<uintptr_t*>(&write_lock->dst_addr_lo) =
+    const auto addr = (label_addr + buf_idx * sizeof(label_addr)) & ~0x3ull;
-        (label_addr + buf_idx * sizeof(uintptr_t)) & ~0x3ull;
+    write_lock->Address<uintptr_t>(addr);
     write_lock->data[0] = 1;
 
     auto* nop = reinterpret_cast<PM4CmdNop*>(cmdbuf + 5);

src/core/libraries/kernel/event_queue.cpp

@@ -21,8 +21,8 @@ int EqueueInternal::addEvent(const EqueueEvent& event) {
 }
 
 int EqueueInternal::removeEvent(u64 id) {
-    const auto& event_q = std::find_if(m_events.cbegin(), m_events.cend(),
+    const auto& event_q =
-                                       [id](auto& ev) { return ev.event.ident == id; });
+        std::ranges::find_if(m_events, [id](auto& ev) { return ev.event.ident == id; });
     ASSERT(event_q != m_events.cend());
     m_events.erase(event_q);
     return 0;

src/core/platform.h

@@ -38,10 +38,9 @@ struct IrqController {
     void Register(IrqHandler handler) {
         ASSERT_MSG(!persistent_handler.has_value(),
                    "Too many persistent handlers"); // Add a slot map if so
-        {
+
-            std::unique_lock lock{m_lock};
+        std::unique_lock lock{m_lock};
-            persistent_handler.emplace(handler);
+        persistent_handler.emplace(handler);
-        }
     }
 
     void Unregister() {
@@ -50,20 +49,19 @@ struct IrqController {
     }
 
     void Signal(InterruptId irq) {
+        std::unique_lock lock{m_lock};
+
         LOG_TRACE(Core, "IRQ signaled: {}", magic_enum::enum_name(irq));
-        {
-            std::unique_lock lock{m_lock};
 
-            if (persistent_handler) {
+        if (persistent_handler) {
-                persistent_handler.value()(irq);
+            persistent_handler.value()(irq);
-            }
+        }
 
-            while (!one_time_subscribers.empty()) {
+        while (!one_time_subscribers.empty()) {
-                const auto& h = one_time_subscribers.front();
+            const auto& h = one_time_subscribers.front();
-                h(irq);
+            h(irq);
 
-                one_time_subscribers.pop();
+            one_time_subscribers.pop();
-            }
         }
     }
 

src/video_core/amdgpu/liverpool.cpp

@@ -90,8 +90,7 @@ void Liverpool::ProcessCmdList(u32* cmdbuf, u32 size_in_bytes) {
                 ASSERT(write_data->dst_sel.Value() == 2 || write_data->dst_sel.Value() == 5);
                 const u32 data_size = (header->type3.count.Value() - 2) * 4;
                 if (!write_data->wr_one_addr.Value()) {
-                    std::memcpy(reinterpret_cast<void*>(write_data->Address()), write_data->data,
+                    std::memcpy(write_data->Address<void*>(), write_data->data, data_size);
-                                data_size);
                 } else {
                     UNREACHABLE();
                 }

src/video_core/amdgpu/pm4_cmds.h

@@ -428,12 +428,23 @@ struct PM4CmdWriteData {
         BitField<30, 1, u32> engine_sel;
         u32 raw;
     };
-    u32 dst_addr_lo;
+    union {
-    u32 dst_addr_hi;
+        struct {
+            u32 dst_addr_lo;
+            u32 dst_addr_hi;
+        };
+        u64 addr64;
+    };
     u32 data[0];
 
-    uintptr_t Address() const {
+    template <typename T>
-        return (uintptr_t(dst_addr_hi) << 32) | dst_addr_lo;
+    void Address(T addr) {
+        addr64 = reinterpret_cast<u64>(addr);
+    }
+
+    template <typename T>
+    T* Address() const {
+        return reinterpret_cast<T*>(addr64);
     }
 };