perf(vu): reduce FMAC flag packing and initialization work

ps2xRuntime/include/runtime/ps2_vu_flags.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <cstdint>
+
+namespace VUFlags
+{
+    struct Fmac
+    {
+        uint32_t mac;
+        uint32_t status;
+    };
+
+    constexpr Fmac packFmac(const uint8_t *laneFlags, uint8_t dest)
+    {
+        uint32_t packed = 0u;
+        uint32_t status = 0u;
+        for (uint32_t component = 0u; component < 4u; ++component)
+        {
+            if ((dest & (8u >> component)) == 0u)
+                continue;
+            const uint32_t flags = laneFlags[component];
+            packed |= (flags & 0xFu) << (12u - component * 4u);
+            status |= flags;
+        }
+        // Transpose four lane nibbles into the four Z/S/U/O lane masks.
+        uint32_t swap = (packed ^ (packed >> 3u)) & 0x0A0Au;
+        packed ^= swap ^ (swap << 3u);
+        swap = (packed ^ (packed >> 6u)) & 0x00CCu;
+        packed ^= swap ^ (swap << 6u);
+        return {packed, status};
+    }
+}

ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp

@@ -1,4 +1,5 @@
 #include "runtime/ps2_vu1.h"
+#include "runtime/ps2_vu_flags.h"
 #include "runtime/gs/ps2_gif_arbiter.h"
 #include "runtime/gs/gs_frontend.h"
 #include "runtime/ps2_memory.h"
@@ -494,25 +495,7 @@ void VU1Interpreter::updateFmacFlags(const uint8_t laneFlags[4], uint8_t dest,
     if (dest == 0u)
         return;
 
-    uint32_t mac = 0u;
-    uint32_t status = 0u;
-    for (uint32_t component = 0; component < 4u; ++component)
-    {
-        const uint8_t lane = laneForComponent(component);
-        if ((dest & lane) == 0u)
-            continue;
-
-        const uint32_t flags = laneFlags[component];
-        if ((flags & 0x1u) != 0u)
-            mac |= lane;
-        if ((flags & 0x2u) != 0u)
-            mac |= static_cast<uint32_t>(lane) << 4;
-        if ((flags & 0x4u) != 0u)
-            mac |= static_cast<uint32_t>(lane) << 8;
-        if ((flags & 0x8u) != 0u)
-            mac |= static_cast<uint32_t>(lane) << 12;
-        status |= flags;
-    }
+    const auto flags = VUFlags::packFmac(laneFlags, dest);
 
     FlagPipelineEntry *entry = nullptr;
     for (FlagPipelineEntry &candidate : m_flagPipeline)
@@ -529,12 +512,12 @@ void VU1Interpreter::updateFmacFlags(const uint8_t laneFlags[4], uint8_t dest,
         return;
     }
 
-    *entry = {};
+    std::memset(entry, 0, sizeof(*entry));
     entry->valid = true;
     entry->issueCycle = m_cycle;
     entry->readyCycle = m_cycle + kFmacLatency;
-    entry->mac = mac;
-    entry->status = status;
+    entry->mac = flags.mac;
+    entry->status = flags.status;
     entry->extraSticky = extraSticky;
     entry->writesMac = true;
     entry->writesStatus = true;

ps2xTest/src/ps2_vu1_tests.cpp

@@ -4,11 +4,13 @@
 #include "runtime/gs/ps2_gs_psmct32.h"
 #include "runtime/ps2_memory.h"
 #include "runtime/ps2_vu1.h"
+#include "runtime/ps2_vu_flags.h"
 
 #include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <limits>
+#include <string>
 #include <vector>
 
 namespace
@@ -217,6 +219,54 @@ void register_ps2_vu1_tests()
 {
     MiniTest::Case("PS2VU1", [](TestCase &tc)
     {
+        tc.Run("VU FMAC packing preserves every flag combination and destination", [](TestCase &t)
+        {
+            const auto check = [&](const uint8_t *flags, uint8_t dest)
+            {
+                uint32_t mac = 0u;
+                uint32_t status = 0u;
+                for (uint32_t component = 0u; component < 4u; ++component)
+                {
+                    const uint32_t lane = 8u >> component;
+                    if ((dest & lane) == 0u)
+                        continue;
+                    status |= flags[component];
+                    for (uint32_t flag = 0u; flag < 4u; ++flag)
+                        if ((flags[component] & (1u << flag)) != 0u)
+                            mac |= lane << (flag * 4u);
+                }
+                const auto result = VUFlags::packFmac(flags, dest);
+                return result.mac == mac && result.status == status;
+            };
+            for (uint32_t pattern = 0u; pattern < 65536u; ++pattern)
+            {
+                const uint8_t flags[4] = {
+                    static_cast<uint8_t>(pattern & 0xFu),
+                    static_cast<uint8_t>((pattern >> 4u) & 0xFu),
+                    static_cast<uint8_t>((pattern >> 8u) & 0xFu),
+                    static_cast<uint8_t>((pattern >> 12u) & 0xFu)};
+                for (uint8_t dest = 0u; dest < 16u; ++dest)
+                    if (!check(flags, dest))
+                    {
+                        t.IsTrue(false, "FMAC packing mismatch: flags=" + std::to_string(pattern) +
+                            " dest=" + std::to_string(dest));
+                        return;
+                    }
+            }
+            for (uint32_t value = 0u; value < 256u; ++value)
+            {
+                const uint8_t flags[4] = {static_cast<uint8_t>(value),
+                    static_cast<uint8_t>(value ^ 0xA5u), static_cast<uint8_t>(value ^ 0x5Au),
+                    static_cast<uint8_t>(~value)};
+                for (uint8_t dest = 0u; dest < 16u; ++dest)
+                    if (!check(flags, static_cast<uint8_t>(dest | 0xF0u)))
+                    {
+                        t.IsTrue(false, "Inactive high flag/destination bits changed packing");
+                        return;
+                    }
+            }
+            t.IsTrue(true, "All 1,048,576 canonical combinations and high-bit cases match");
+        });
         tc.Run("upper ADD applies the destination mask", [](TestCase &t)
         {
             Vu1Fixture fx;