video_core: Add a few missed things

src/core/libraries/system/userservice.cpp

@@ -104,7 +104,7 @@ int PS4_SYSV_ABI sceUserServiceGetDiscPlayerFlag() {
 }
 
 s32 PS4_SYSV_ABI sceUserServiceGetEvent(OrbisUserServiceEvent* event) {
-    LOG_INFO(Lib_UserService, "(DUMMY) called");
+    LOG_TRACE(Lib_UserService, "(DUMMY) called");
     // fake a loggin event
     static bool logged_in = false;
 

src/core/memory.cpp

@@ -83,6 +83,9 @@ int MemoryManager::MapMemory(void** out_addr, VAddr virtual_addr, size_t size, M
                              MemoryMapFlags flags, VMAType type, std::string_view name,
                              bool is_exec, PAddr phys_addr, u64 alignment) {
     std::scoped_lock lk{mutex};
+    if (total_flexible_usage + size > 448_MB) {
+        return SCE_KERNEL_ERROR_ENOMEM;
+    }
 
     // When virtual addr is zero, force it to virtual_base. The guest cannot pass Fixed
     // flag so we will take the branch that searches for free (or reserved) mappings.
@@ -100,6 +103,9 @@ int MemoryManager::MapMemory(void** out_addr, VAddr virtual_addr, size_t size, M
             new_vma.phys_base = phys_addr;
             MapVulkanMemory(mapped_addr, size);
         }
+        if (type == VMAType::Flexible) {
+            total_flexible_usage += size;
+        }
     };
 
     // Fixed mapping means the virtual address must exactly match the provided one.
@@ -139,6 +145,9 @@ void MemoryManager::UnmapMemory(VAddr virtual_addr, size_t size) {
     if (type == VMAType::Direct) {
         UnmapVulkanMemory(virtual_addr, size);
     }
+    if (type == VMAType::Flexible) {
+        total_flexible_usage -= size;
+    }
 
     // Mark region as free and attempt to coalesce it with neighbours.
     auto& vma = it->second;

src/core/memory.h

@@ -182,6 +182,7 @@ private:
     DMemMap dmem_map;
     VMAMap vma_map;
     std::recursive_mutex mutex;
+    size_t total_flexible_usage{};
 
     struct MappedMemory {
         vk::UniqueBuffer buffer;

src/shader_recompiler/frontend/translate/scalar_alu.cpp

@@ -160,7 +160,7 @@ void Translator::S_OR_B64(bool negate, const GcnInst& inst) {
     }
 }
 
-void Translator::S_AND_B64(const GcnInst& inst) {
+void Translator::S_AND_B64(bool negate, const GcnInst& inst) {
     const auto get_src = [&](const InstOperand& operand) {
         switch (operand.field) {
         case OperandField::VccLo:
@@ -175,7 +175,10 @@ void Translator::S_AND_B64(const GcnInst& inst) {
     };
     const IR::U1 src0{get_src(inst.src[0])};
     const IR::U1 src1{get_src(inst.src[1])};
-    const IR::U1 result = ir.LogicalAnd(src0, src1);
+    IR::U1 result = ir.LogicalAnd(src0, src1);
+    if (negate) {
+        result = ir.LogicalNot(result);
+    }
     ir.SetScc(result);
     switch (inst.dst[0].field) {
     case OperandField::VccLo:

src/shader_recompiler/frontend/translate/translate.cpp

@@ -366,6 +366,9 @@ void Translate(IR::Block* block, std::span<const GcnInst> inst_list, Info& info)
         case Opcode::V_CMP_NLE_F32:
             translator.V_CMP_F32(ConditionOp::GT, false, inst);
             break;
+        case Opcode::V_CMP_NLT_F32:
+            translator.V_CMP_F32(ConditionOp::GE, false, inst);
+            break;
         case Opcode::S_CMP_LG_U32:
             translator.S_CMP(ConditionOp::LG, false, inst);
             break;
@@ -554,7 +557,10 @@ void Translate(IR::Block* block, std::span<const GcnInst> inst_list, Info& info)
             translator.S_OR_B64(true, inst);
             break;
         case Opcode::S_AND_B64:
-            translator.S_AND_B64(inst);
+            translator.S_AND_B64(false, inst);
+            break;
+        case Opcode::S_NAND_B64:
+            translator.S_AND_B64(true, inst);
             break;
         case Opcode::V_LSHRREV_B32:
             translator.V_LSHRREV_B32(inst);

src/shader_recompiler/frontend/translate/translate.h

@@ -41,7 +41,7 @@ public:
     void S_AND_SAVEEXEC_B64(const GcnInst& inst);
     void S_MOV_B64(const GcnInst& inst);
     void S_OR_B64(bool negate, const GcnInst& inst);
-    void S_AND_B64(const GcnInst& inst);
+    void S_AND_B64(bool negate, const GcnInst& inst);
     void S_ADD_I32(const GcnInst& inst);
     void S_AND_B32(const GcnInst& inst);
     void S_LSHR_B32(const GcnInst& inst);

src/shader_recompiler/frontend/translate/vector_alu.cpp

@@ -15,7 +15,7 @@ void Translator::V_SAD(const GcnInst& inst) {
 }
 
 void Translator::V_MAC_F32(const GcnInst& inst) {
-    SetDst(inst.dst[0], ir.FPFma(GetSrc(inst.src[0]), GetSrc(inst.src[1]), GetSrc(inst.dst[0])));
+    SetDst(inst.dst[0], ir.FPFma(GetSrc(inst.src[0], true), GetSrc(inst.src[1], true), GetSrc(inst.dst[0], true)));
 }
 
 void Translator::V_CVT_PKRTZ_F16_F32(const GcnInst& inst) {
@@ -127,13 +127,13 @@ void Translator::V_FLOOR_F32(const GcnInst& inst) {
 }
 
 void Translator::V_SUB_F32(const GcnInst& inst) {
-    const IR::F32 src0{GetSrc(inst.src[0])};
+    const IR::F32 src0{GetSrc(inst.src[0], true)};
-    const IR::F32 src1{GetSrc(inst.src[1])};
+    const IR::F32 src1{GetSrc(inst.src[1], true)};
     SetDst(inst.dst[0], ir.FPSub(src0, src1));
 }
 
 void Translator::V_RCP_F32(const GcnInst& inst) {
-    const IR::F32 src0{GetSrc(inst.src[0])};
+    const IR::F32 src0{GetSrc(inst.src[0], true)};
     SetDst(inst.dst[0], ir.FPRecip(src0));
 }
 

src/video_core/amdgpu/liverpool.h

@@ -479,9 +479,9 @@ struct Liverpool {
     };
 
     struct Scissor {
-        union {
+        struct {
-            BitField<0, 16, s32> top_left_x;
+            s16 top_left_x;
-            BitField<16, 16, s32> top_left_y;
+            s16 top_left_y;
         };
         union {
             BitField<0, 15, u32> bottom_right_x;

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -36,7 +36,8 @@ ComputePipeline::ComputePipeline(const Instance& instance_, Scheduler& scheduler
     for (const auto& image : info.images) {
         bindings.push_back({
             .binding = binding++,
-            .descriptorType = vk::DescriptorType::eSampledImage,
+            .descriptorType = image.is_storage ? vk::DescriptorType::eStorageImage
+                                               : vk::DescriptorType::eSampledImage,
             .descriptorCount = 1,
             .stageFlags = vk::ShaderStageFlagBits::eCompute,
         });

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -289,7 +289,8 @@ void GraphicsPipeline::BuildDescSetLayout() {
         for (const auto& image : stage.images) {
             bindings.push_back({
                 .binding = binding++,
-                .descriptorType = vk::DescriptorType::eSampledImage,
+                .descriptorType = image.is_storage ? vk::DescriptorType::eStorageImage
+                                                   : vk::DescriptorType::eSampledImage,
                 .descriptorCount = 1,
                 .stageFlags = vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment,
             });
@@ -316,8 +317,8 @@ void GraphicsPipeline::BindResources(Core::MemoryManager* memory, StreamBuffer&
     BindVertexBuffers(staging);
 
     // Bind resource buffers and textures.
-    boost::container::static_vector<vk::DescriptorBufferInfo, 4> buffer_infos;
+    boost::container::static_vector<vk::DescriptorBufferInfo, 16> buffer_infos;
-    boost::container::static_vector<vk::DescriptorImageInfo, 8> image_infos;
+    boost::container::static_vector<vk::DescriptorImageInfo, 16> image_infos;
     boost::container::small_vector<vk::WriteDescriptorSet, 16> set_writes;
     u32 binding{};
 

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -8,6 +8,7 @@
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/recompiler.h"
 #include "shader_recompiler/runtime_info.h"
+#include "shader_recompiler/exception.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -88,6 +89,8 @@ void PipelineCache::RefreshGraphicsKey() {
     auto& key = graphics_key;
 
     key.depth = regs.depth_control;
+    key.depth.depth_write_enable.Assign(regs.depth_control.depth_write_enable.Value() &&
+                                        !regs.depth_render_control.depth_clear_enable);
     key.depth_bounds_min = regs.depth_bounds_min;
     key.depth_bounds_max = regs.depth_bounds_max;
     key.depth_bias_enable = regs.polygon_control.enable_polygon_offset_back ||
@@ -180,6 +183,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
         inst_pool.ReleaseContents();
 
         // Recompile shader to IR.
+        LOG_INFO(Render_Vulkan, "Compiling {} shader {:#X}", stage, hash);
         const Shader::Info info = MakeShaderInfo(stage, pgm->user_data, regs);
         programs[i] = Shader::TranslateProgram(inst_pool, block_pool, code, std::move(info));
 

src/video_core/texture_cache/image_view.cpp

@@ -46,18 +46,20 @@ vk::ComponentSwizzle ConvertComponentSwizzle(u32 dst_sel) {
     }
 }
 
-ImageViewInfo::ImageViewInfo(const AmdGpu::Image& image) noexcept {
+ImageViewInfo::ImageViewInfo(const AmdGpu::Image& image, bool is_storage) noexcept : is_storage{is_storage} {
     type = ConvertImageViewType(image.type);
     format = Vulkan::LiverpoolToVK::SurfaceFormat(image.GetDataFmt(), image.GetNumberFmt());
     range.base.level = 0;
     range.base.layer = 0;
     range.extent.levels = image.NumLevels();
     range.extent.layers = image.NumLayers();
+    if (!is_storage) {
         mapping.r = ConvertComponentSwizzle(image.dst_sel_x);
         mapping.g = ConvertComponentSwizzle(image.dst_sel_y);
         mapping.b = ConvertComponentSwizzle(image.dst_sel_z);
         mapping.a = ConvertComponentSwizzle(image.dst_sel_w);
     }
+}
 
 ImageView::ImageView(const Vulkan::Instance& instance, const ImageViewInfo& info_, Image& image,
                      std::optional<vk::ImageUsageFlags> usage_override /*= {}*/)
@@ -74,7 +76,7 @@ ImageView::ImageView(const Vulkan::Instance& instance, const ImageViewInfo& info
     }
 
     const vk::ImageViewCreateInfo image_view_ci = {
-        .pNext = usage_override.has_value() ? &usage_ci : nullptr,
+        .pNext = nullptr,
         .image = image.image,
         .viewType = info.type,
         .format = format,

src/video_core/texture_cache/image_view.h

@@ -18,12 +18,13 @@ namespace VideoCore {
 
 struct ImageViewInfo {
     explicit ImageViewInfo() = default;
-    explicit ImageViewInfo(const AmdGpu::Image& image) noexcept;
+    explicit ImageViewInfo(const AmdGpu::Image& image, bool is_storage) noexcept;
 
     vk::ImageViewType type = vk::ImageViewType::e2D;
     vk::Format format = vk::Format::eR8G8B8A8Unorm;
     SubresourceRange range;
     vk::ComponentMapping mapping{};
+    bool is_storage;
 
     auto operator<=>(const ImageViewInfo&) const = default;
 };

src/video_core/texture_cache/texture_cache.cpp

@@ -169,14 +169,14 @@ ImageView& TextureCache::FindImageView(const AmdGpu::Image& desc, bool is_storag
         image.Transit(vk::ImageLayout::eShaderReadOnlyOptimal, vk::AccessFlagBits::eShaderRead);
     }
 
-    const ImageViewInfo view_info{desc};
+    const ImageViewInfo view_info{desc, is_storage};
     return RegisterImageView(image, view_info);
 }
 
 ImageView& TextureCache::RenderTarget(const AmdGpu::Liverpool::ColorBuffer& buffer,
                                       const AmdGpu::Liverpool::CbDbExtent& hint) {
     const ImageInfo info{buffer, hint};
-    auto& image = FindImage(info, buffer.Address());
+    auto& image = FindImage(info, buffer.Address(), false);
     image.flags &= ~ImageFlagBits::CpuModified;
 
     image.Transit(vk::ImageLayout::eColorAttachmentOptimal,