Revert "liverpool: Implement PM4 MEM_SEMAPHORE. (shadps4-emu#2235)"

This reverts commit a5a1253.

Revert "shader_recompiler: Fix image write swizzles. (shadps4-emu#2236)"

This reverts commit a51c8c1.

Author: Xcedf

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -569,7 +569,7 @@ void PatchTextureBufferArgs(IR::Block& block, IR::Inst& inst, Info& info) {
     inst.SetArg(1, CalculateBufferAddress(ir, inst, info, buffer, 1U));
 
     if (inst.GetOpcode() == IR::Opcode::StoreBufferFormatF32) {
-        const auto swizzled = ApplySwizzle(ir, inst.Arg(2), buffer.DstSelect().Inverse());
+        const auto swizzled = ApplySwizzle(ir, inst.Arg(2), buffer.DstSelect());
         const auto converted =
             ApplyWriteNumberConversionVec4(ir, swizzled, buffer.GetNumberConversion());
         inst.SetArg(2, converted);
@@ -829,7 +829,7 @@ void PatchImageArgs(IR::Block& block, IR::Inst& inst, Info& info) {
             auto texel = inst.Arg(4);
             if (is_storage) {
                 // Storage image requires shader swizzle.
-                texel = ApplySwizzle(ir, texel, image.DstSelect().Inverse());
+                texel = ApplySwizzle(ir, texel, image.DstSelect());
             }
             const auto converted =
                 ApplyWriteNumberConversionVec4(ir, texel, image.GetNumberConversion());

src/video_core/amdgpu/liverpool.cpp

@@ -641,18 +641,6 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 }
                 break;
             }
-            case PM4ItOpcode::MemSemaphore: {
-                const auto* mem_semaphore = reinterpret_cast<const PM4CmdMemSemaphore*>(header);
-                if (mem_semaphore->IsSignaling()) {
-                    mem_semaphore->Signal();
-                } else {
-                    while (!mem_semaphore->Signaled()) {
-                        YIELD_GFX();
-                    }
-                    mem_semaphore->Decrement();
-                }
-                break;
-            }
             case PM4ItOpcode::AcquireMem: {
                 // const auto* acquire_mem = reinterpret_cast<PM4CmdAcquireMem*>(header);
                 break;
@@ -891,18 +879,6 @@ Liverpool::Task Liverpool::ProcessCompute(const u32* acb, u32 acb_dwords, u32 vq
             }
             break;
         }
-        case PM4ItOpcode::MemSemaphore: {
-            const auto* mem_semaphore = reinterpret_cast<const PM4CmdMemSemaphore*>(header);
-            if (mem_semaphore->IsSignaling()) {
-                mem_semaphore->Signal();
-            } else {
-                while (!mem_semaphore->Signaled()) {
-                    YIELD_ASC(vqid);
-                }
-                mem_semaphore->Decrement();
-            }
-            break;
-        }
         case PM4ItOpcode::WaitRegMem: {
             const auto* wait_reg_mem = reinterpret_cast<const PM4CmdWaitRegMem*>(header);
             ASSERT(wait_reg_mem->engine.Value() == PM4CmdWaitRegMem::Engine::Me);

src/video_core/amdgpu/pm4_cmds.h

@@ -886,65 +886,4 @@ struct PM4CmdDrawIndexIndirectMulti {
     u32 draw_initiator; ///< Draw Initiator Register
 };
 
-struct PM4CmdMemSemaphore {
-    enum class ClientCode : u32 {
-        CommandProcessor = 0u,
-        CommandBuffer = 1u,
-        DataBuffer = 2u,
-    };
-    enum class Select : u32 {
-        SignalSemaphore = 6u,
-        WaitSemaphore = 7u,
-    };
-    enum class SignalType : u32 {
-        Increment = 0u,
-        Write = 1u,
-    };
-
-    PM4Type3Header header; ///< header
-    union {
-        u32 dw1;
-        BitField<3, 29, u32> addr_lo; ///< Semaphore address bits [31:3]
-    };
-    union {
-        u32 dw2;
-        BitField<0, 8, u32> addr_hi;             ///< Semaphore address bits [39:32]
-        BitField<16, 1, u32> use_mailbox;        ///< Enables waiting until mailbox is written to
-        BitField<20, 1, SignalType> signal_type; ///< Indicates the type of signal sent
-        BitField<24, 2, ClientCode> client_code;
-        BitField<29, 3, Select> sem_sel; ///< Indicates whether to do a signal or wait operation
-    };
-
-    template <typename T>
-    [[nodiscard]] T Address() const {
-        return std::bit_cast<T>(u64(addr_lo) << 3 | (u64(addr_hi) << 32));
-    }
-
-    [[nodiscard]] bool IsSignaling() const {
-        return sem_sel == Select::SignalSemaphore;
-    }
-
-    [[nodiscard]] bool Signaled() const {
-        return *Address<u64*>() > 0;
-    }
-
-    void Decrement() const {
-        *Address<u64*>() -= 1;
-    }
-
-    void Signal() const {
-        auto* ptr = Address<u64*>();
-        switch (signal_type) {
-        case SignalType::Increment:
-            *ptr += 1;
-            break;
-        case SignalType::Write:
-            *ptr = 1;
-            break;
-        default:
-            UNREACHABLE_MSG("Unknown signal type {}", static_cast<u32>(signal_type.Value()));
-        }
-    }
-};
-
 } // namespace AmdGpu

src/video_core/amdgpu/types.h

@@ -200,10 +200,10 @@ enum class NumberConversion : u32 {
 };
 
 struct CompMapping {
-    CompSwizzle r;
-    CompSwizzle g;
-    CompSwizzle b;
-    CompSwizzle a;
+    CompSwizzle r : 3;
+    CompSwizzle g : 3;
+    CompSwizzle b : 3;
+    CompSwizzle a : 3;
 
     auto operator<=>(const CompMapping& other) const = default;
 
@@ -217,15 +217,6 @@ struct CompMapping {
         };
     }
 
-    [[nodiscard]] CompMapping Inverse() const {
-        CompMapping result{};
-        InverseSingle(result.r, CompSwizzle::Red);
-        InverseSingle(result.g, CompSwizzle::Green);
-        InverseSingle(result.b, CompSwizzle::Blue);
-        InverseSingle(result.a, CompSwizzle::Alpha);
-        return result;
-    }
-
 private:
     template <typename T>
     T ApplySingle(const std::array<T, 4>& data, const CompSwizzle swizzle) const {
@@ -246,20 +237,6 @@ struct CompMapping {
             UNREACHABLE();
         }
     }
-
-    void InverseSingle(CompSwizzle& dst, const CompSwizzle target) const {
-        if (r == target) {
-            dst = CompSwizzle::Red;
-        } else if (g == target) {
-            dst = CompSwizzle::Green;
-        } else if (b == target) {
-            dst = CompSwizzle::Blue;
-        } else if (a == target) {
-            dst = CompSwizzle::Alpha;
-        } else {
-            dst = CompSwizzle::Zero;
-        }
-    }
 };
 
 inline DataFormat RemapDataFormat(const DataFormat format) {