shader_recompiler: Small instruction parsing refactor/bugfixes (#340)

* translator: Implemtn f32 to f16 convert

* shader_recompiler: Add bit instructions

* shader_recompiler: More data share instructions

* shader_recompiler: Remove exec contexts, fix S_MOV_B64

* shader_recompiler: Split instruction parsing into categories

* shader_recompiler: Better BFS search

* shader_recompiler: Constant propagation pass for cmp_class_f32

* shader_recompiler: Partial readfirstlane implementation

* shader_recompiler: Stub readlane/writelane only for non-compute

* hack: Fix swizzle on RDR

* Will properly fix this when merging this

* clang format

* address_space: Bump user area size to full

* shader_recompiler: V_INTERP_MOV_F32

* Should work the same as spirv will emit flat decoration on demand

* kernel: Add MAP_OP_MAP_FLEXIBLE

* image_view: Attempt to apply storage swizzle on format

* vk_scheduler: Barrier attachments on renderpass end

* clang format

* liverpool: cs state backup

* shader_recompiler: More instructions and formats

* vector_alu: Proper V_MBCNT_U32_B32

* shader_recompiler: Port some dark souls things

* file_system: Implement sceKernelRename

* more formats

* clang format

* resource_tracking_pass: Back to assert

* translate: Tracedata

* kernel: Remove tracy lock

* Solves random crashes in Dark Souls

* code: Review comments

src/video_core/amdgpu/liverpool.cpp

@@ -403,9 +403,11 @@ Liverpool::Task Liverpool::ProcessGraphics(std::span<const u32> dcb, std::span<c
                 vo_port->WaitVoLabel([&] { return wait_reg_mem->Test(); });
             }
             while (!wait_reg_mem->Test()) {
+                mapped_queues[GfxQueueId].cs_state = regs.cs_program;
                 TracyFiberLeave;
                 co_yield {};
                 TracyFiberEnter(dcb_task_name);
+                regs.cs_program = mapped_queues[GfxQueueId].cs_state;
             }
             break;
         }
@@ -506,9 +508,11 @@ Liverpool::Task Liverpool::ProcessCompute(std::span<const u32> acb, int vqid) {
             const auto* wait_reg_mem = reinterpret_cast<const PM4CmdWaitRegMem*>(header);
             ASSERT(wait_reg_mem->engine.Value() == PM4CmdWaitRegMem::Engine::Me);
             while (!wait_reg_mem->Test()) {
+                mapped_queues[vqid].cs_state = regs.cs_program;
                 TracyFiberLeave;
                 co_yield {};
                 TracyFiberEnter(acb_task_name);
+                regs.cs_program = mapped_queues[vqid].cs_state;
             }
             break;
         }
@@ -529,7 +533,6 @@ Liverpool::Task Liverpool::ProcessCompute(std::span<const u32> acb, int vqid) {
 }
 
 void Liverpool::SubmitGfx(std::span<const u32> dcb, std::span<const u32> ccb) {
-    static constexpr u32 GfxQueueId = 0u;
     auto& queue = mapped_queues[GfxQueueId];
 
     auto task = ProcessGraphics(dcb, ccb);

src/video_core/amdgpu/liverpool.h

@@ -36,6 +36,7 @@ namespace AmdGpu {
     [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
 struct Liverpool {
+    static constexpr u32 GfxQueueId = 0u;
     static constexpr u32 NumGfxRings = 1u;     // actually 2, but HP is reserved by system software
     static constexpr u32 NumComputePipes = 7u; // actually 8, but #7 is reserved by system software
     static constexpr u32 NumQueuesPerPipe = 8u;
@@ -1061,6 +1062,7 @@ private:
     struct GpuQueue {
         std::mutex m_access{};
         std::queue<Task::Handle> submits{};
+        ComputeProgram cs_state{};
     };
     std::array<GpuQueue, NumTotalQueues> mapped_queues{};
 

src/video_core/amdgpu/pixel_format.cpp

@@ -7,6 +7,77 @@
 
 namespace AmdGpu {
 
+std::string_view NameOf(DataFormat fmt) {
+    switch (fmt) {
+    case DataFormat::FormatInvalid:
+        return "FormatInvalid";
+    case DataFormat::Format8:
+        return "Format8";
+    case DataFormat::Format16:
+        return "Format16";
+    case DataFormat::Format8_8:
+        return "Format8_8";
+    case DataFormat::Format32:
+        return "Format32";
+    case DataFormat::Format16_16:
+        return "Format16_16";
+    case DataFormat::Format10_11_11:
+        return "Format10_11_11";
+    case DataFormat::Format11_11_10:
+        return "Format11_11_10";
+    case DataFormat::Format10_10_10_2:
+        return "Format10_10_10_2";
+    case DataFormat::Format2_10_10_10:
+        return "Format2_10_10_10";
+    case DataFormat::Format8_8_8_8:
+        return "Format8_8_8_8";
+    case DataFormat::Format32_32:
+        return "Format32_32";
+    case DataFormat::Format16_16_16_16:
+        return "Format16_16_16_16";
+    case DataFormat::Format32_32_32:
+        return "Format32_32_32";
+    case DataFormat::Format32_32_32_32:
+        return "Format32_32_32_32";
+    case DataFormat::Format5_6_5:
+        return "Format5_6_5";
+    case DataFormat::Format1_5_5_5:
+        return "Format1_5_5_5";
+    case DataFormat::Format5_5_5_1:
+        return "Format5_5_5_1";
+    case DataFormat::Format4_4_4_4:
+        return "Format4_4_4_4";
+    case DataFormat::Format8_24:
+        return "Format8_24";
+    case DataFormat::Format24_8:
+        return "Format24_8";
+    case DataFormat::FormatX24_8_32:
+        return "FormatX24_8_32";
+    case DataFormat::FormatGB_GR:
+        return "FormatGB_GR";
+    case DataFormat::FormatBG_RG:
+        return "FormatBG_RG";
+    case DataFormat::Format5_9_9_9:
+        return "Format5_9_9_9";
+    case DataFormat::FormatBc1:
+        return "FormatBc1";
+    case DataFormat::FormatBc2:
+        return "FormatBc2";
+    case DataFormat::FormatBc3:
+        return "FormatBc3";
+    case DataFormat::FormatBc4:
+        return "FormatBc4";
+    case DataFormat::FormatBc5:
+        return "FormatBc5";
+    case DataFormat::FormatBc6:
+        return "FormatBc6";
+    case DataFormat::FormatBc7:
+        return "FormatBc7";
+    default:
+        UNREACHABLE();
+    }
+}
+
 std::string_view NameOf(NumberFormat fmt) {
     switch (fmt) {
     case NumberFormat::Unorm:

src/video_core/amdgpu/pixel_format.h

@@ -61,6 +61,7 @@ enum class NumberFormat : u32 {
     Ubscaled = 13,
 };
 
+[[nodiscard]] std::string_view NameOf(DataFormat fmt);
 [[nodiscard]] std::string_view NameOf(NumberFormat fmt);
 
 int NumComponents(DataFormat format);
@@ -70,6 +71,16 @@ s32 ComponentOffset(DataFormat format, u32 comp);
 
 } // namespace AmdGpu
 
+template <>
+struct fmt::formatter<AmdGpu::DataFormat> {
+    constexpr auto parse(format_parse_context& ctx) {
+        return ctx.begin();
+    }
+    auto format(AmdGpu::DataFormat fmt, format_context& ctx) const {
+        return fmt::format_to(ctx.out(), "{}", AmdGpu::NameOf(fmt));
+    }
+};
+
 template <>
 struct fmt::formatter<AmdGpu::NumberFormat> {
     constexpr auto parse(format_parse_context& ctx) {

src/video_core/amdgpu/resource.h

@@ -75,7 +75,7 @@ struct Buffer {
 static_assert(sizeof(Buffer) == 16); // 128bits
 
 enum class ImageType : u64 {
-    Buffer = 0,
+    Invalid = 0,
     Color1D = 8,
     Color2D = 9,
     Color3D = 10,
@@ -88,8 +88,8 @@ enum class ImageType : u64 {
 
 constexpr std::string_view NameOf(ImageType type) {
     switch (type) {
-    case ImageType::Buffer:
-        return "Buffer";
+    case ImageType::Invalid:
+        return "Invalid";
     case ImageType::Color1D:
         return "Color1D";
     case ImageType::Color2D:
@@ -179,6 +179,40 @@ struct Image {
         return base_address << 8;
     }
 
+    u32 DstSelect() const {
+        return dst_sel_x | (dst_sel_y << 3) | (dst_sel_z << 6) | (dst_sel_w << 9);
+    }
+
+    static char SelectComp(u32 sel) {
+        switch (sel) {
+        case 0:
+            return '0';
+        case 1:
+            return '1';
+        case 4:
+            return 'R';
+        case 5:
+            return 'G';
+        case 6:
+            return 'B';
+        case 7:
+            return 'A';
+        default:
+            UNREACHABLE();
+        }
+    }
+
+    std::string DstSelectName() const {
+        std::string result = "[";
+        u32 dst_sel = DstSelect();
+        for (u32 i = 0; i < 4; i++) {
+            result += SelectComp(dst_sel & 7);
+            dst_sel >>= 3;
+        }
+        result += ']';
+        return result;
+    }
+
     u32 Pitch() const {
         return pitch + 1;
     }
@@ -290,6 +324,7 @@ enum class BorderColor : u64 {
 // Table 8.12 Sampler Resource Definition
 struct Sampler {
     union {
+        u64 raw0;
         BitField<0, 3, ClampMode> clamp_x;
         BitField<3, 3, ClampMode> clamp_y;
         BitField<6, 3, ClampMode> clamp_z;
@@ -309,6 +344,7 @@ struct Sampler {
         BitField<60, 4, u64> perf_z;
     };
     union {
+        u64 raw1;
         BitField<0, 14, u64> lod_bias;
         BitField<14, 6, u64> lod_bias_sec;
         BitField<20, 2, Filter> xy_mag_filter;
@@ -323,6 +359,10 @@ struct Sampler {
         BitField<62, 2, BorderColor> border_color_type;
     };
 
+    operator bool() const noexcept {
+        return raw0 != 0 || raw1 != 0;
+    }
+
     float LodBias() const noexcept {
         return static_cast<float>(static_cast<int16_t>((lod_bias.Value() ^ 0x2000u) - 0x2000u)) /
                256.0f;