graphics: honour DCC fixed clear codes on 16-bit and float colour targets (#471)

* Honour DCC fixed clear codes on 16-bit and float colour targets

* tests: DCC fixed clear codes materialise on an RGBA16F target

* graphics: remove fixed clear format comment

---------

Co-authored-by: nmzik <Nmzik@mail.ru>

CMakeLists.txt

@@ -431,16 +431,15 @@ add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
 )
 target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
 
-add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
-	"${KYTY_TESTS_DIR}/ShaderStageRuntimeTests.cpp"
+add_executable(resource_materialization_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ResourceMaterializationTests.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
-	"${KYTY_SOURCE_DIR}/graphics/shader/shaderStageRuntime.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
 )
-target_link_libraries(shader_stage_runtime_tests fmt::fmt)
-target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})
+target_link_libraries(resource_materialization_tests fmt::fmt)
+target_include_directories(resource_materialization_tests PRIVATE ${inc_headers})
 
 add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/ResourceTrackingTests.cpp"
@@ -542,7 +541,7 @@ if(BUILD_TESTING)
 	add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
 	add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
 	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
-	add_test(NAME shader_stage_runtime COMMAND $<TARGET_FILE:shader_stage_runtime_tests>)
+	add_test(NAME resource_materialization COMMAND $<TARGET_FILE:resource_materialization_tests>)
 	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
 	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
 	add_test(NAME kernel_file_system COMMAND $<TARGET_FILE:kernel_file_system_tests>)
@@ -598,7 +597,7 @@ if(BUILD_TESTING)
 		page_manager_tests
 		bit_array_tests
 		shader_vertex_metadata_tests
-		shader_stage_runtime_tests
+		resource_materialization_tests
 		resource_tracking_tests
 		event_queue_lifetime_tests
 		kernel_file_system_tests

src/graphics/guest_gpu/gpu_format.cpp

@@ -15,6 +15,7 @@ struct FormatInfo {
 	uint32_t           render_target_bytes_per_element;
 	bool               sampled_texture;
 	bool               uint_texture;
+	bool               sint_texture = false;
 };
 
 constexpr FormatInfo kFormatInfo[] = {
@@ -24,19 +25,19 @@ constexpr FormatInfo kFormatInfo[] = {
 	{BufferFormat::k16UNorm, 2, 0, 2, true, false},
 	{BufferFormat::k16SNorm, 2, 0, 2, true, false},
 	{BufferFormat::k16UInt, 2, 0, 2, true, true},
-	{BufferFormat::k16SInt, 2, 0, 2, false, false},
+	{BufferFormat::k16SInt, 2, 0, 2, true, false, true},
 	{BufferFormat::k16Float, 2, 0, 2, true, false},
 	{BufferFormat::k8_8UNorm, 2, 0, 2, true, false},
 	{BufferFormat::k8_8SNorm, 2, 0, 2, true, false},
 	{BufferFormat::k8_8UInt, 2, 0, 2, true, true},
-	{BufferFormat::k8_8SInt, 2, 0, 2, false, false},
+	{BufferFormat::k8_8SInt, 2, 0, 2, true, false, true},
 	{BufferFormat::k32UInt, 4, 0, 4, true, true},
-	{BufferFormat::k32SInt, 4, 0, 4, false, false},
+	{BufferFormat::k32SInt, 4, 0, 4, true, false, true},
 	{BufferFormat::k32Float, 4, 0, 4, true, false},
 	{BufferFormat::k16_16UNorm, 4, 0, 4, true, false},
 	{BufferFormat::k16_16SNorm, 4, 0, 4, true, false},
 	{BufferFormat::k16_16UInt, 4, 0, 4, true, true},
-	{BufferFormat::k16_16SInt, 4, 0, 4, false, false},
+	{BufferFormat::k16_16SInt, 4, 0, 4, true, false, true},
 	{BufferFormat::k16_16Float, 4, 0, 4, true, false},
 	{BufferFormat::k11_11_10UInt, 4, 0, 4, true, true},
 	{BufferFormat::k11_11_10Float, 4, 0, 4, true, false},
@@ -45,20 +46,20 @@ constexpr FormatInfo kFormatInfo[] = {
 	{BufferFormat::k8_8_8_8UNorm, 4, 0, 4, true, false},
 	{BufferFormat::k8_8_8_8SNorm, 4, 0, 4, true, false},
 	{BufferFormat::k8_8_8_8UInt, 4, 0, 4, true, true},
-	{BufferFormat::k8_8_8_8SInt, 4, 0, 4, false, false},
+	{BufferFormat::k8_8_8_8SInt, 4, 0, 4, true, false, true},
 	{BufferFormat::k32_32UInt, 8, 0, 8, true, true},
-	{BufferFormat::k32_32SInt, 8, 0, 8, false, false},
+	{BufferFormat::k32_32SInt, 8, 0, 8, true, false, true},
 	{BufferFormat::k32_32Float, 8, 0, 8, true, false},
 	{BufferFormat::k16_16_16_16UNorm, 8, 0, 8, true, false},
 	{BufferFormat::k16_16_16_16SNorm, 8, 0, 8, true, false},
 	{BufferFormat::k16_16_16_16UInt, 8, 0, 8, true, true},
-	{BufferFormat::k16_16_16_16SInt, 8, 0, 8, false, false},
+	{BufferFormat::k16_16_16_16SInt, 8, 0, 8, true, false, true},
 	{BufferFormat::k16_16_16_16Float, 8, 0, 8, true, false},
 	{BufferFormat::k32_32_32UInt, 12, 0, 12, true, true},
-	{BufferFormat::k32_32_32SInt, 12, 0, 12, false, false},
+	{BufferFormat::k32_32_32SInt, 12, 0, 12, true, false, true},
 	{BufferFormat::k32_32_32Float, 12, 0, 12, true, false},
 	{BufferFormat::k32_32_32_32UInt, 16, 0, 16, true, true},
-	{BufferFormat::k32_32_32_32SInt, 16, 0, 16, false, false},
+	{BufferFormat::k32_32_32_32SInt, 16, 0, 16, true, false, true},
 	{BufferFormat::k32_32_32_32Float, 16, 0, 16, true, false},
 	{BufferFormat::k8Srgb, 1, 0, 0, true, false},
 	{BufferFormat::k8_8Srgb, 2, 0, 0, true, false},
@@ -218,14 +219,15 @@ bool IsFmaskTextureFormat(BufferFormat format) {
 	return format >= BufferFormat::kFmask8_S2_F1 && format <= BufferFormat::kFmask64_S16_F8;
 }
 
-bool IsSampledTextureFormat(BufferFormat format) {
+TextureNumericClass SampledTextureNumericClass(BufferFormat format) {
 	const auto* info = FindFormatInfo(format);
-	return info != nullptr && info->sampled_texture;
-}
-
-bool IsUintTextureFormat(BufferFormat format) {
-	const auto* info = FindFormatInfo(format);
-	return info != nullptr && info->uint_texture;
+	if (info == nullptr || !info->sampled_texture) {
+		return TextureNumericClass::Unsupported;
+	}
+	if (info->sint_texture) {
+		return TextureNumericClass::Sint;
+	}
+	return info->uint_texture ? TextureNumericClass::Uint : TextureNumericClass::Float;
 }
 
 BufferFormat RemapTextureFormat(BufferFormat format) {

src/graphics/guest_gpu/gpu_format.h

@@ -37,13 +37,14 @@ struct RenderTargetFormatEncoding {
 	}
 };
 
+enum class TextureNumericClass { Unsupported, Float, Uint, Sint };
+
 RenderTargetFormatEncoding ResolveRenderTargetFormat(ChannelLayout layout, ChannelType type);
 uint32_t                   NumBytesPerElement(BufferFormat format);
 uint32_t                   BlockCompressedBytesPerBlock(BufferFormat format);
 uint32_t                   RenderTargetBytesPerElement(BufferFormat format);
 bool                       IsFmaskTextureFormat(BufferFormat format);
-bool                       IsSampledTextureFormat(BufferFormat format);
-bool                       IsUintTextureFormat(BufferFormat format);
+TextureNumericClass        SampledTextureNumericClass(BufferFormat format);
 BufferFormat               RemapTextureFormat(BufferFormat format);
 
 } // namespace Libs::Graphics::Prospero

src/graphics/host_gpu/renderer/colorRenderTarget.cpp

@@ -28,12 +28,27 @@ static void ResolveDccClearInfo(RenderColorInfo& info, vk::Format format, bool h
 	info.metadata_clear_supported =
 	    has_dcc && DecodePackedColorClear(format, packed_clear, info.color_clear_value);
 	switch (format) {
+		case vk::Format::eR8Unorm:
+		case vk::Format::eR8G8Unorm:
 		case vk::Format::eR8G8B8A8Unorm:
 		case vk::Format::eR8G8B8A8Srgb:
 		case vk::Format::eB8G8R8A8Unorm:
 		case vk::Format::eB8G8R8A8Srgb:
 		case vk::Format::eA2B10G10R10UnormPack32:
 		case vk::Format::eA2R10G10B10UnormPack32:
+		case vk::Format::eR5G6B5UnormPack16:
+		case vk::Format::eA1R5G5B5UnormPack16:
+		case vk::Format::eR4G4B4A4UnormPack16:
+		case vk::Format::eR16Unorm:
+		case vk::Format::eR16G16Unorm:
+		case vk::Format::eR16G16B16A16Unorm:
+		case vk::Format::eR16Sfloat:
+		case vk::Format::eR16G16Sfloat:
+		case vk::Format::eR16G16B16A16Sfloat:
+		case vk::Format::eR32Sfloat:
+		case vk::Format::eR32G32Sfloat:
+		case vk::Format::eR32G32B32A32Sfloat:
+		case vk::Format::eB10G11R11UfloatPack32:
 			info.metadata_fixed_clear_supported = has_dcc;
 			break;
 		default: info.metadata_fixed_clear_supported = false; break;

src/graphics/host_gpu/renderer/image/image.cpp

@@ -59,16 +59,8 @@ namespace {
 	if (HasFormatFeature(properties, vk::FormatFeatureFlagBits::eColorAttachment)) {
 		usage |= vk::ImageUsageFlagBits::eColorAttachment;
 	}
-	if (info.samples == 1 &&
-	    HasFormatFeature(properties, vk::FormatFeatureFlagBits::eStorageImage)) {
+	if (info.samples == 1) {
 		usage |= vk::ImageUsageFlagBits::eStorage;
-	} else if (info.samples == 1) {
-		const auto compatible = SrgbStorageViewFormat(info.pixel_format);
-		if (compatible != vk::Format::eUndefined &&
-		    HasFormatFeature(graphics.GetFormatProperties(compatible),
-		                     vk::FormatFeatureFlagBits::eStorageImage)) {
-			usage |= vk::ImageUsageFlagBits::eStorage;
-		}
 	}
 	return usage;
 }

src/graphics/host_gpu/renderer/image/imageView.h

@@ -103,11 +103,13 @@ SelectSampledDepthView(vk::Format image_format, vk::Format view_format, uint32_t
 
 [[nodiscard]] inline bool
 IsSupportedSampledDepthResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
-	if (resource.kind != ShaderRecompiler::IR::ResourceKind::Image &&
-	    resource.kind != ShaderRecompiler::IR::ResourceKind::ImageUint) {
+	if (resource.resource_class != ShaderRecompiler::IR::ImageResourceClass::Sampled) {
 		return false;
 	}
-	if (resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint && resource.depth_compare) {
+	if (resource.numeric_class == Prospero::TextureNumericClass::Unsupported) {
+		return false;
+	}
+	if (resource.numeric_class != Prospero::TextureNumericClass::Float && resource.depth_compare) {
 		return false;
 	}
 	return (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D ||
@@ -128,8 +130,9 @@ inline void ValidateStorageColorView(vk::Format image_format, vk::Format view_fo
 
 [[nodiscard]] inline bool
 IsSupportedStorageImageResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
-	return (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
-	        resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint) &&
+	return resource.resource_class == ShaderRecompiler::IR::ImageResourceClass::Storage &&
+	       (resource.numeric_class == Prospero::TextureNumericClass::Float ||
+	        resource.numeric_class == Prospero::TextureNumericClass::Uint) &&
 	       (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim1D ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim1DArray ||
 	        resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D ||
@@ -141,19 +144,19 @@ IsSupportedStorageImageResource(const ShaderRecompiler::IR::ImageResource& resou
 	         resource.mip_count != 0u)) &&
 	       resource.written &&
 	       (!resource.atomic ||
-	        (resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint &&
-	         resource.read)) &&
+	        (resource.numeric_class == Prospero::TextureNumericClass::Uint && resource.read)) &&
 	       !resource.depth_compare;
 }
 
 inline void
 ValidateStorageImageResource(const ShaderRecompiler::IR::ImageResource& resource) noexcept {
 	if (!IsSupportedStorageImageResource(resource)) {
-		EXIT("unsupported storage color image resource: kind=%u dimension=%u mip=%u "
+		EXIT("unsupported storage color image resource: class=%u numeric=%u dimension=%u mip=%u "
 		     "read=%d written=%d atomic=%d depth_compare=%d\n",
-		     static_cast<uint32_t>(resource.kind), static_cast<uint32_t>(resource.dimension),
-		     static_cast<uint32_t>(resource.mip_mode), resource.read, resource.written,
-		     resource.atomic, resource.depth_compare);
+		     static_cast<uint32_t>(resource.resource_class),
+		     static_cast<uint32_t>(resource.numeric_class),
+		     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
+		     resource.read, resource.written, resource.atomic, resource.depth_compare);
 	}
 }
 

src/graphics/host_gpu/renderer/pipeline/descriptors.cpp

@@ -48,60 +48,27 @@ namespace {
 
 using BindingKind = ShaderRecompiler::IR::DescriptorBindingKind;
 
-bool IsSampledImage(BindingKind kind) {
-	switch (kind) {
-		case BindingKind::Sampled1D:
-		case BindingKind::Sampled1DArray:
-		case BindingKind::Sampled2D:
-		case BindingKind::Sampled2DArray:
-		case BindingKind::Sampled2DMsaa:
-		case BindingKind::Sampled2DMsaaArray:
-		case BindingKind::Sampled3D:
-		case BindingKind::SampledUint1D:
-		case BindingKind::SampledUint1DArray:
-		case BindingKind::SampledUint2D:
-		case BindingKind::SampledUint2DArray:
-		case BindingKind::SampledUint2DMsaa:
-		case BindingKind::SampledUint2DMsaaArray:
-		case BindingKind::SampledUint3D: return true;
-		default: return false;
-	}
-}
-
-bool IsStorageImage(BindingKind kind) {
-	switch (kind) {
-		case BindingKind::Storage1D:
-		case BindingKind::Storage1DArray:
-		case BindingKind::Storage2D:
-		case BindingKind::Storage2DArray:
-		case BindingKind::Storage3D:
-		case BindingKind::StorageUint1D:
-		case BindingKind::StorageUint1DArray:
-		case BindingKind::StorageUint2D:
-		case BindingKind::StorageUint2DArray:
-		case BindingKind::StorageUint3D:
-		case BindingKind::StorageAtomic1D:
-		case BindingKind::StorageAtomic1DArray:
-		case BindingKind::StorageAtomic2D:
-		case BindingKind::StorageAtomic2DArray:
-		case BindingKind::StorageAtomic3D: return true;
-		default: return false;
-	}
-}
-
 } // namespace
 
 vk::DescriptorType NativeDescriptorType(BindingKind kind) {
-	if (kind == BindingKind::Samplers) {
-		return vk::DescriptorType::eSampler;
-	}
-	if (IsSampledImage(kind)) {
+	const auto image_class = ShaderRecompiler::IR::ImageBindingResourceClass(kind);
+	if (image_class == ShaderRecompiler::IR::ImageResourceClass::Sampled) {
 		return vk::DescriptorType::eSampledImage;
 	}
-	if (IsStorageImage(kind)) {
+	if (image_class == ShaderRecompiler::IR::ImageResourceClass::Storage) {
 		return vk::DescriptorType::eStorageImage;
 	}
-	return vk::DescriptorType::eStorageBuffer;
+	switch (kind) {
+		case BindingKind::Samplers: return vk::DescriptorType::eSampler;
+		case BindingKind::Buffers:
+		case BindingKind::Gds:
+		case BindingKind::BdaPagetable:
+		case BindingKind::FaultBuffer:
+		case BindingKind::FlattenedSrt:
+		case BindingKind::ShaderData: return vk::DescriptorType::eStorageBuffer;
+		case BindingKind::Count: EXIT("invalid native descriptor binding kind");
+	}
+	EXIT("invalid native descriptor binding kind");
 }
 
 uint32_t NativeDescriptorCount(const ShaderRecompiler::IR::DescriptorBinding& binding) {
@@ -141,12 +108,6 @@ static void BindNullStorageBuffer(RenderContext& context, BufferView& dst) {
 	dst.range  = 16;
 }
 
-static void CopyNativeDescriptor(const ShaderRecompiler::IR::DescriptorValue& source,
-                                 std::span<uint32_t>                          destination) {
-	EXIT_IF(source.dword_count != destination.size());
-	std::copy_n(source.dwords.begin(), destination.size(), destination.begin());
-}
-
 static Prospero::ImageType TextureType(const ShaderTextureResource& descriptor) {
 	const auto type = descriptor.Type();
 	return type == Prospero::ImageType::kCube ? Prospero::ImageType::kColor2DArray : type;
@@ -229,11 +190,10 @@ static bool IsSupportedSampledColorResource(const ShaderRecompiler::IR::ImageRes
 			break;
 		default: break;
 	}
-	const bool sampled_kind = resource.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-	                          resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint;
-	return sampled_kind && supported_dimension &&
-	       resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None && resource.read &&
-	       !resource.written && !resource.atomic && !resource.depth_compare;
+	return resource.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled &&
+	       resource.numeric_class != Prospero::TextureNumericClass::Unsupported &&
+	       supported_dimension && resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None &&
+	       resource.read && !resource.written && !resource.atomic && !resource.depth_compare;
 }
 
 TargetTextureViewInfo ResolveTargetTextureView(const ShaderRecompiler::IR::ImageResource& resource,
@@ -387,15 +347,17 @@ static void ValidateDepthTargetBinding(const ShaderRecompiler::IR::ImageResource
 	    TileGetTexturePitch(descriptor.Format(), static_cast<uint32_t>(descriptor.Width5()) + 1u,
 	                        descriptor.TileMode());
 	EXIT("unsupported sampled depth target: resource=%d descriptor=%d encoding=%d format=%d "
-	     "kind=%u dimension=%u mip_mode=%u read=%d written=%d atomic=%d compare=%d "
+	     "class=%u numeric=%u dimension=%u mip_mode=%u read=%d written=%d atomic=%d compare=%d "
 	     "guest_format=%u swizzle=0x%03x image_format=%d view_format=%d image_layers=%u "
 	     "descriptor_type=%u base_array=%u depth=%u descriptor_pitch=%u target_pitch=%u "
 	     "addr=0x%016" PRIx64 " size=0x%016" PRIx64
 	     " dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
-	     resource_ok, descriptor_ok, encoding_ok, format_ok, static_cast<uint32_t>(resource.kind),
-	     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
-	     resource.read, resource.written, resource.atomic, resource.depth_compare,
-	     static_cast<uint32_t>(descriptor.Format()), descriptor.DstSelXYZW(),
+	     resource_ok, descriptor_ok, encoding_ok, format_ok,
+	     static_cast<uint32_t>(resource.resource_class),
+	     static_cast<uint32_t>(resource.numeric_class), static_cast<uint32_t>(resource.dimension),
+	     static_cast<uint32_t>(resource.mip_mode), resource.read, resource.written, resource.atomic,
+	     resource.depth_compare, static_cast<uint32_t>(descriptor.Format()),
+	     descriptor.DstSelXYZW(),
 	     image == nullptr ? static_cast<int>(vk::Format::eUndefined)
 	                      : static_cast<int>(image->info.pixel_format),
 	     static_cast<int>(view_format), image == nullptr ? 0u : image->info.resources.layers,
@@ -508,29 +470,33 @@ void ValidateStorageTexture(const ShaderRecompiler::IR::ImageResource& resource,
 	const bool resource_ok   = IsSupportedStorageImageResource(resource);
 	const bool descriptor_ok = IsSupportedStorageTextureDescriptor(resource, descriptor);
 	const bool encoding_ok   = IsSupportedStorageTextureEncoding(resource, descriptor);
-	const bool uint_resource =
-	    resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint;
+	const bool uint_resource    = resource.numeric_class == Prospero::TextureNumericClass::Uint;
 	const bool raw_sint_storage = format == Prospero::BufferFormat::k32SInt && uint_resource &&
 	                              resource.written && !resource.read && !resource.atomic;
+	const auto numeric_class = Prospero::SampledTextureNumericClass(format);
 	const bool format_ok =
-	    raw_sint_storage || (Prospero::IsSampledTextureFormat(format) &&
-	                         uint_resource == Prospero::IsUintTextureFormat(format) &&
-	                         (!resource.atomic || format == Prospero::BufferFormat::k32UInt));
+	    raw_sint_storage ||
+	    (numeric_class != Prospero::TextureNumericClass::Unsupported &&
+	     numeric_class != Prospero::TextureNumericClass::Sint &&
+	     uint_resource == (numeric_class == Prospero::TextureNumericClass::Uint) &&
+	     (!resource.atomic || format == Prospero::BufferFormat::k32UInt));
 	if (resource_ok && descriptor_ok && encoding_ok && format_ok && size != 0) {
 		return;
 	}
 	EXIT("unsupported storage texture: resource=%d descriptor=%d encoding=%d format=%d "
-	     "kind=%u dimension=%u mip_mode=%u atomic=%d compare=%d "
+	     "class=%u numeric=%u dimension=%u mip_mode=%u atomic=%d compare=%d "
 	     "base_level=%u last_level=%u max_mip=%u min_lod=%u base_array=%u bc=%u msaa=%d "
 	     "depth_tile_bpe=%u swizzle_ok=%d "
 	     "addr=0x%016" PRIx64 " size=0x%016" PRIx64
 	     " extent=%ux%ux%u type=%u format=%u tile=%u swizzle=0x%03x read=%d written=%d "
 	     "dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
-	     resource_ok, descriptor_ok, encoding_ok, format_ok, static_cast<uint32_t>(resource.kind),
-	     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
-	     resource.atomic, resource.depth_compare, descriptor.BaseLevel(), descriptor.LastLevel(),
-	     descriptor.MaxMip(), descriptor.MinLod(), descriptor.BaseArray5(), descriptor.BCSwizzle(),
-	     descriptor.MsaaDepth(), Prospero::RenderTargetBytesPerElement(format),
+	     resource_ok, descriptor_ok, encoding_ok, format_ok,
+	     static_cast<uint32_t>(resource.resource_class),
+	     static_cast<uint32_t>(resource.numeric_class), static_cast<uint32_t>(resource.dimension),
+	     static_cast<uint32_t>(resource.mip_mode), resource.atomic, resource.depth_compare,
+	     descriptor.BaseLevel(), descriptor.LastLevel(), descriptor.MaxMip(), descriptor.MinLod(),
+	     descriptor.BaseArray5(), descriptor.BCSwizzle(), descriptor.MsaaDepth(),
+	     Prospero::RenderTargetBytesPerElement(format),
 	     IsValidImageSwizzle(descriptor.DstSelXYZW()), descriptor.Base40(), size,
 	     static_cast<uint32_t>(descriptor.Width5()) + 1u,
 	     static_cast<uint32_t>(descriptor.Height5()) + 1u,
@@ -547,10 +513,16 @@ struct NullImageSpec {
 };
 
 static NullImageSpec NullTextureSpec(const ShaderRecompiler::IR::ImageResource& resource) {
-	const bool uint_image = resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint ||
-	                        resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint;
-	return uint_image ? NullImageSpec {vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt}
-	                  : NullImageSpec {vk::Format::eR32Sfloat, Prospero::BufferFormat::k32Float};
+	switch (resource.numeric_class) {
+		case Prospero::TextureNumericClass::Float:
+			return {vk::Format::eR32Sfloat, Prospero::BufferFormat::k32Float};
+		case Prospero::TextureNumericClass::Uint:
+			return {vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt};
+		case Prospero::TextureNumericClass::Sint:
+			return {vk::Format::eR32Sint, Prospero::BufferFormat::k32SInt};
+		case Prospero::TextureNumericClass::Unsupported: break;
+	}
+	EXIT("null image has unsupported numeric class\n");
 }
 
 static TextureCache::ImageDesc NullTextureDesc(const ShaderRecompiler::IR::ImageResource& resource,
@@ -680,8 +652,7 @@ static ImageViewInfo TextureViewInfo(const ShaderRecompiler::IR::ImageResource&
 
 TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageResource&   resource,
                                               const ShaderRecompiler::IR::DescriptorValue& value) {
-	ShaderTextureResource descriptor;
-	CopyNativeDescriptor(value, descriptor.fields);
+	auto descriptor = DecodeNativeDescriptor<ShaderTextureResource>(value);
 	const bool storage = resource.written;
 	if (storage) {
 		ValidateStorageImageResource(resource);
@@ -718,15 +689,16 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 	      !msaa_tile || (descriptor.MsaaDepth() && !depth_tile) ||
 	      (!msaa_array && (descriptor.Depth() != 0 || descriptor.BaseArray5() != 0))))) {
 		EXIT("unsupported texture mip view: base=%u last=%u levels=%u max=%u type=%u tile=%u "
-		     "kind=%u dimension=%u mip_mode=%u read=%d written=%d "
+		     "class=%u numeric=%u dimension=%u mip_mode=%u read=%d written=%d "
 		     "dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
 		     base_level, last_level, levels, descriptor.MaxMip(),
 		     static_cast<uint32_t>(descriptor.Type()), static_cast<uint32_t>(tile),
-		     static_cast<uint32_t>(resource.kind), static_cast<uint32_t>(resource.dimension),
-		     static_cast<uint32_t>(resource.mip_mode), resource.read, resource.written,
-		     descriptor.fields[0], descriptor.fields[1], descriptor.fields[2], descriptor.fields[3],
-		     descriptor.fields[4], descriptor.fields[5], descriptor.fields[6],
-		     descriptor.fields[7]);
+		     static_cast<uint32_t>(resource.resource_class),
+		     static_cast<uint32_t>(resource.numeric_class),
+		     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
+		     resource.read, resource.written, descriptor.fields[0], descriptor.fields[1],
+		     descriptor.fields[2], descriptor.fields[3], descriptor.fields[4], descriptor.fields[5],
+		     descriptor.fields[6], descriptor.fields[7]);
 	}
 	const auto samples = multisampled ? 1u << last_level : 1u;
 	const auto view_levels =
@@ -737,15 +709,11 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 	const bool shader_conversion =
 	    surface_format.conversion_format != Prospero::BufferFormat::kInvalid;
 	const bool sampled_numeric_class =
-	    storage || (Prospero::IsSampledTextureFormat(format) &&
-	                (resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint) ==
-	                    Prospero::IsUintTextureFormat(format));
-	if (!storage &&
-	    (resource.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-	     resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint) &&
+	    storage || resource.numeric_class == Prospero::SampledTextureNumericClass(format);
+	if (!storage && resource.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled &&
 	    !sampled_numeric_class) {
-		EXIT("sampled image numeric class mismatch: kind=%u format=%u addr=0x%016" PRIx64 "\n",
-		     static_cast<uint32_t>(resource.kind), static_cast<uint32_t>(format), address);
+		EXIT("sampled image numeric class mismatch: numeric=%u format=%u addr=0x%016" PRIx64 "\n",
+		     static_cast<uint32_t>(resource.numeric_class), static_cast<uint32_t>(format), address);
 	}
 
 	const bool    volume       = type == Prospero::ImageType::kColor3D;
@@ -827,17 +795,11 @@ TextureBinding RenderExecutor::ResolveTexture(const ShaderRecompiler::IR::ImageR
 }
 
 static vk::Sampler NativeSampler(RenderContext&                       context,
-                                 const ShaderRecompiler::IR::Program& program, uint32_t index,
+                                 const ShaderRecompiler::IR::CompiledShaderInfo& program,
+                                 uint32_t index,
                                  const ShaderRecompiler::IR::DescriptorValue& value) {
-	ShaderSamplerResource descriptor;
-	CopyNativeDescriptor(value, descriptor.fields);
-	const bool depth_compare = std::any_of(program.info.sampled_pairs.begin(),
-	                                       program.info.sampled_pairs.end(), [&](const auto& pair) {
-		                                       return pair.sampler == index &&
-		                                              pair.image < program.info.images.size() &&
-		                                              program.info.images[pair.image].depth_compare;
-	                                       });
-	if (!depth_compare) {
+	auto descriptor = DecodeNativeDescriptor<ShaderSamplerResource>(value);
+	if (!program.info.samplers[index].depth_compare) {
 		descriptor.fields[0] &= ~(0x7u << 12u);
 	}
 	if (program.info.samplers[index].force_point_filtering) {
@@ -894,15 +856,10 @@ PreparedBindings RenderExecutor::PrepareBindings(const ShaderStageRuntime& runti
 	KYTY_PROFILER_FUNCTION();
 	EXIT_IF(!runtime);
 	const auto& program  = *runtime.program;
-	const auto& snapshot = *runtime.resources;
-	if (!ShaderRecompiler::IR::ValidateResourceSpecialization(program, snapshot)) {
-		EXIT("invalid native shader runtime snapshot: hash=0x%016" PRIx64 " stage=%u\n",
-		     program.shader_hash, static_cast<unsigned>(program.stage));
-	}
-
+	const auto& snapshot = runtime.resources;
 	PreparedBindings prepared;
-	prepared.program  = runtime.program.get();
-	prepared.snapshot = runtime.resources.get();
+	prepared.program  = runtime.program;
+	prepared.snapshot = &runtime.resources;
 	auto& descriptors = prepared.resources;
 	descriptors.buffers.reserve(program.info.buffers.size());
 	descriptors.images.reserve(program.info.images.size());
@@ -915,17 +872,11 @@ PreparedBindings RenderExecutor::PrepareBindings(const ShaderStageRuntime& runti
 	for (uint32_t i = 0; i < program.info.samplers.size(); i++) {
 		descriptors.samplers.push_back(NativeSampler(m_context, program, i, snapshot.samplers[i]));
 	}
-	if (ShaderRecompiler::IR::FindBinding(
-	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::FlattenedSrt) !=
-	    nullptr) {
-		prepared.flattened_srt.assign(snapshot.flattened_srt.begin(), snapshot.flattened_srt.end());
-	}
-
-	prepared.user_data.reserve(program.bindings.ShaderDataDwords());
+	prepared.shader_data.reserve(program.bindings.ShaderDataDwords());
 	for (const auto reg: program.bindings.user_data_registers) {
-		prepared.user_data.push_back(snapshot.user_data[reg - program.user_data_base]);
+		prepared.shader_data.push_back(snapshot.user_data[reg - program.user_data_base]);
 	}
-	prepared.user_data.resize(program.bindings.ShaderDataDwords());
+	prepared.shader_data.resize(program.bindings.ShaderDataDwords());
 	if (ShaderRecompiler::IR::FindBinding(
 	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::Gds) != nullptr) {
 		descriptors.gds.buffer = m_context.GetBufferCache().GetGdsBuffer()->Handle();
@@ -940,22 +891,21 @@ void RenderExecutor::FindBuffers(PreparedBindings& prepared) {
 	const auto& snapshot = *prepared.snapshot;
 	auto&       cache    = m_context.GetBufferCache();
 
-	prepared.buffer_ids.clear();
-	prepared.buffer_ids.reserve(program.info.buffers.size());
+	prepared.buffer_sources.clear();
+	prepared.buffer_sources.reserve(program.info.buffers.size());
 	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
-		ShaderBufferResource descriptor;
-		CopyNativeDescriptor(snapshot.buffers[i], descriptor.fields);
+		auto descriptor = DecodeNativeDescriptor<ShaderBufferResource>(snapshot.buffers[i]);
 		const auto address = descriptor.Base48();
 		const auto stride  = descriptor.Stride();
 		const auto records = descriptor.NumRecords();
 		EXIT_IF(stride != 0 && records > UINT64_MAX / stride);
 		const auto requested_size = stride != 0 ? static_cast<uint64_t>(stride) * records : records;
 		if (address == 0 || requested_size == 0) {
-			prepared.buffer_ids.emplace_back();
+			prepared.buffer_sources.emplace_back(descriptor, BufferId {});
 			continue;
 		}
 		const auto size = Libs::LibKernel::Memory::ClampRangeSize(address, requested_size);
-		prepared.buffer_ids.push_back(cache.FindBuffer(address, size));
+		prepared.buffer_sources.emplace_back(descriptor, cache.FindBuffer(address, size));
 	}
 
 }
@@ -967,32 +917,33 @@ void RenderExecutor::RebindBuffers(PreparedBindings& prepared) {
 	const auto& snapshot  = *prepared.snapshot;
 	auto&       resources = prepared.resources;
 	const auto& layout    = program.bindings;
-	EXIT_IF(prepared.buffer_ids.size() != program.info.buffers.size());
+	EXIT_IF(prepared.buffer_sources.size() != program.info.buffers.size());
 
 	resources.buffers.clear();
 	resources.buffers.reserve(program.info.buffers.size());
-	EXIT_IF(prepared.user_data.size() != layout.ShaderDataDwords());
-	std::fill(prepared.user_data.begin() + layout.memory_offset_dword, prepared.user_data.end(), 0);
+	EXIT_IF(prepared.shader_data.size() != layout.ShaderDataDwords());
+	std::fill(prepared.shader_data.begin() + layout.memory_offset_dword,
+	          prepared.shader_data.end(), 0);
 	auto pack_memory_offset = [&](uint32_t index, uint32_t offset) {
 		const auto dword = layout.memory_offset_dword + index / 4u;
 		const auto shift = (index % 4u) * 8u;
-		prepared.user_data[dword] |= offset << shift;
+		prepared.shader_data[dword] |= offset << shift;
 	};
 	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
-		ShaderBufferResource descriptor;
-		CopyNativeDescriptor(snapshot.buffers[i], descriptor.fields);
+		const auto& [descriptor, buffer_id] = prepared.buffer_sources[i];
 		uint32_t buffer_offset = 0;
 		resources.buffers.push_back(NativeStorageBuffer(m_context, descriptor,
 		                                                program.info.buffers[i], program.stage, i,
-		                                                buffer_offset, prepared.buffer_ids[i]));
+		                                                buffer_offset, buffer_id));
 		pack_memory_offset(i, buffer_offset);
 	}
-	if (!prepared.flattened_srt.empty()) {
-		resources.flattened_srt = NativeUpload(m_context, prepared.flattened_srt);
+	if (ShaderRecompiler::IR::FindBinding(
+	        layout, ShaderRecompiler::IR::DescriptorBindingKind::FlattenedSrt) != nullptr) {
+		resources.flattened_srt = NativeUpload(m_context, snapshot.flattened_srt);
 	}
 	if (ShaderRecompiler::IR::FindBinding(
-	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::UserData) != nullptr) {
-		resources.user_data = NativeUpload(m_context, prepared.user_data);
+	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::ShaderData) != nullptr) {
+		resources.shader_data = NativeUpload(m_context, prepared.shader_data);
 	}
 }
 
@@ -1081,14 +1032,13 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 	auto   vk_buffer        = buffer.Handle();
 	size_t descriptor_count = 0;
 	size_t write_count      = 0;
+	ShaderRecompiler::IR::PushData push_data;
+	bool                           has_push_data = false;
 	constexpr auto GraphicsStages =
 	    vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment;
-	const auto push_constant_stages = pipeline_bind_point == vk::PipelineBindPoint::eGraphics
-	                                      ? vk::ShaderStageFlags {GraphicsStages}
-	                                      : vk::ShaderStageFlags {vk::ShaderStageFlagBits::eCompute};
 	for (const auto* prepared: prepared_bindings) {
 		EXIT_IF(prepared == nullptr || prepared->program == nullptr ||
-		        prepared->snapshot == nullptr || prepared->committed);
+		        prepared->snapshot == nullptr);
 		write_count += prepared->program->bindings.descriptors.size();
 		for (const auto& binding: prepared->program->bindings.descriptors) {
 			descriptor_count += NativeDescriptorCount(binding);
@@ -1102,7 +1052,6 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 	m_descriptor_buffers.clear();
 	m_descriptor_images.clear();
 	m_descriptor_writes.clear();
-	m_push_constants.fill(0);
 	m_descriptor_buffers.reserve(descriptor_count);
 	m_descriptor_images.reserve(descriptor_count);
 	m_descriptor_writes.reserve(write_count);
@@ -1166,48 +1115,54 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 			write.descriptorCount   = NativeDescriptorCount(binding);
 			const auto buffer_start = m_descriptor_buffers.size();
 			const auto image_start  = m_descriptor_images.size();
-			switch (binding.kind) {
-				case BindingKind::Buffers:
-					for (const auto resource: binding.resources) {
-						const auto& view = descriptors.buffers.at(resource);
-						EXIT_IF(view.buffer == nullptr);
-						m_descriptor_buffers.emplace_back(view.buffer, view.offset, view.range);
-					}
-					break;
-				case BindingKind::BdaPagetable:
-				case BindingKind::FaultBuffer: {
-					auto& cache = m_context.GetBufferCache();
-					const auto* bda_buffer = binding.kind == BindingKind::BdaPagetable
-					                             ? cache.GetBdaPageTableBuffer()
-					                             : cache.GetFaultBuffer();
-					m_descriptor_buffers.emplace_back(bda_buffer->Handle(), 0, bda_buffer->Size());
-					break;
+			if (ShaderRecompiler::IR::ImageBindingResourceClass(binding.kind) !=
+			    ShaderRecompiler::IR::ImageResourceClass::None) {
+				for (const auto resource: binding.resources) {
+					m_descriptor_images.push_back(MakeImageInfo(
+					    descriptors.images.at(resource), m_image_occurrences.at(resource)++));
 				}
-				case BindingKind::FlattenedSrt:
-				case BindingKind::UserData:
-				case BindingKind::Gds: {
-					const auto& view =
-					    binding.kind == BindingKind::FlattenedSrt ? descriptors.flattened_srt
-					    : binding.kind == BindingKind::UserData   ? descriptors.user_data
-					                                              : descriptors.gds;
-					EXIT_IF(view.buffer == nullptr);
-					m_descriptor_buffers.emplace_back(view.buffer, view.offset, view.range);
-					break;
+			} else {
+				switch (binding.kind) {
+					case BindingKind::Buffers:
+						for (const auto resource: binding.resources) {
+							const auto& view = descriptors.buffers.at(resource);
+							EXIT_IF(view.buffer == nullptr);
+							m_descriptor_buffers.emplace_back(view.buffer, view.offset, view.range);
+						}
+						break;
+					case BindingKind::BdaPagetable:
+					case BindingKind::FaultBuffer: {
+						auto&       cache      = m_context.GetBufferCache();
+						const auto* bda_buffer = binding.kind == BindingKind::BdaPagetable
+						                             ? cache.GetBdaPageTableBuffer()
+						                             : cache.GetFaultBuffer();
+						m_descriptor_buffers.emplace_back(bda_buffer->Handle(), 0,
+						                                  bda_buffer->Size());
+						break;
+					}
+					case BindingKind::FlattenedSrt:
+					case BindingKind::ShaderData:
+					case BindingKind::Gds: {
+						const BufferView* view = &descriptors.gds;
+						if (binding.kind == BindingKind::FlattenedSrt) {
+							view = &descriptors.flattened_srt;
+						} else if (binding.kind == BindingKind::ShaderData) {
+							view = &descriptors.shader_data;
+						}
+						EXIT_IF(view->buffer == nullptr);
+						m_descriptor_buffers.emplace_back(view->buffer, view->offset, view->range);
+						break;
+					}
+					case BindingKind::Samplers:
+						for (const auto resource: binding.resources) {
+							const auto sampler = descriptors.samplers.at(resource);
+							EXIT_IF(sampler == nullptr);
+							m_descriptor_images.emplace_back(sampler, nullptr,
+							                                 vk::ImageLayout::eUndefined);
+						}
+						break;
+					case BindingKind::Count: EXIT("invalid descriptor binding kind");
 				}
-				case BindingKind::Samplers:
-					for (const auto resource: binding.resources) {
-						const auto sampler = descriptors.samplers.at(resource);
-						EXIT_IF(sampler == nullptr);
-						m_descriptor_images.emplace_back(sampler, nullptr,
-						                                 vk::ImageLayout::eUndefined);
-					}
-					break;
-				default:
-					for (const auto resource: binding.resources) {
-						m_descriptor_images.push_back(MakeImageInfo(
-						    descriptors.images.at(resource), m_image_occurrences.at(resource)++));
-					}
-					break;
 			}
 			if (m_descriptor_buffers.size() != buffer_start) {
 				write.pBufferInfo = m_descriptor_buffers.data() + buffer_start;
@@ -1225,20 +1180,22 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 			EXIT_IF(m_image_occurrences[i] != expected);
 		}
 
-		if (program.bindings.push_constant_size != 0) {
-			const auto offset = program.bindings.push_constant_offset;
-			EXIT_IF(offset % sizeof(uint32_t) != 0 ||
-			        program.bindings.push_constant_size !=
-			            prepared->user_data.size() * sizeof(uint32_t) ||
-			        offset + program.bindings.push_constant_size >
-			            ShaderRecompiler::IR::NativePushConstantSize);
-			std::copy(prepared->user_data.begin(), prepared->user_data.end(),
-			          m_push_constants.begin() + offset / sizeof(uint32_t));
+		const auto shader_data_dwords = program.bindings.ShaderDataDwords();
+		EXIT_IF(prepared->shader_data.size() != shader_data_dwords);
+		if (program.bindings.UsesPushData()) {
+			std::ranges::copy(prepared->shader_data,
+			                  push_data.dwords.begin() + program.bindings.push_data_start_dword);
+			has_push_data = true;
 		}
 	}
-	vk_buffer.pushConstants(pipeline.pipeline_layout, push_constant_stages, 0,
-	                        ShaderRecompiler::IR::NativePushConstantSize,
-	                        m_push_constants.data());
+
+	if (has_push_data) {
+		const auto stages = pipeline_bind_point == vk::PipelineBindPoint::eGraphics
+		                        ? vk::ShaderStageFlags {GraphicsStages}
+		                        : vk::ShaderStageFlags {vk::ShaderStageFlagBits::eCompute};
+		vk_buffer.pushConstants(pipeline.pipeline_layout, stages, 0, sizeof(push_data),
+		                        push_data.dwords.data());
+	}
 
 	if (!m_descriptor_writes.empty()) {
 		EXIT_IF(pipeline.descriptor_set_layout == nullptr);
@@ -1258,9 +1215,6 @@ void RenderExecutor::CommitBindings(CommandBuffer&                     buffer,
 			                             0, nullptr);
 		}
 	}
-	for (auto* prepared: prepared_bindings) {
-		prepared->committed = true;
-	}
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/pipeline/descriptors.h

@@ -40,17 +40,15 @@ struct NativeDescriptors {
 	std::vector<vk::Sampler>    samplers;
 	BufferView                  gds;
 	BufferView                  flattened_srt;
-	BufferView                  user_data;
+	BufferView                  shader_data;
 };
 
 struct PreparedBindings {
-	const ShaderRecompiler::IR::Program*          program  = nullptr;
+	const ShaderRecompiler::IR::CompiledShaderInfo* program  = nullptr;
 	const ShaderRecompiler::IR::ResourceSnapshot* snapshot = nullptr;
 	NativeDescriptors                             resources;
-	std::vector<BufferId>                         buffer_ids;
-	std::vector<uint32_t>                         flattened_srt;
-	std::vector<uint32_t>                         user_data;
-	bool                                          committed = false;
+	std::vector<std::pair<ShaderBufferResource, BufferId>> buffer_sources;
+	std::vector<uint32_t>                         shader_data;
 };
 
 [[nodiscard]] vk::DescriptorType

src/graphics/host_gpu/renderer/pipeline/pipelineCache.cpp

@@ -1,6 +1,7 @@
 #include "graphics/host_gpu/renderer/pipeline/pipelineCache.h"
 
 #include "common/assert.h"
+#include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
@@ -11,7 +12,9 @@
 #include "graphics/host_gpu/renderer/image/imageView.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
+#include "graphics/shader/recompiler/ShaderRecompiler.h"
 #include "graphics/shader/shaderCompiler.h"
+#include "kernel/memory.h"
 #include "kytyGitVersion.h"
 #include "loader/systemContent.h"
 
@@ -20,13 +23,14 @@
 #include <cctype>
 #include <cstdio>
 #include <cstring>
+#include <fmt/format.h>
 #include <limits>
 #include <span>
+#include <spirv-tools/libspirv.hpp>
 #include <string_view>
+#include <tuple>
 #include <utility>
 #include <vector>
-
-#include <fmt/format.h>
 #include <xxhash.h>
 
 namespace Libs::Graphics {
@@ -84,42 +88,188 @@ void NormalizeStaticParamsForDynamicState(PipelineStaticParameters& static_param
 	static_params.scissor_ltrb[3] = 1;
 }
 
+bool ReadShaderGuestMemory(void*, uint64_t address, uint32_t* value) {
+	return value != nullptr &&
+	       Libs::LibKernel::Memory::TryReadGpuCleanBacking(address, value, sizeof(*value));
+}
+
+void DumpShaderSpirv(const char* stage_name, uint64_t shader_hash,
+                     const std::vector<uint32_t>& spirv) {
+	if (!Config::GraphicsDebugDumpEnabled()) {
+		return;
+	}
+	static std::atomic_int id = 0;
+	const auto path = Config::GetShaderLogFolder() / fmt::format("{:04d}_new_shader_{}_{:016x}.spv",
+	                                                             id++, stage_name, shader_hash);
+	Common::File::CreateDirectories(path.parent_path());
+	Common::File file(path, Common::File::Mode::Write);
+	if (file.IsInvalid()) {
+		const auto path_text = Common::PathToString(path);
+		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", path_text.c_str());
+		return;
+	}
+	file.Write(spirv.data(), spirv.size() * sizeof(uint32_t));
+}
+
+void DumpShaderOriginal(const char* stage_name, uint64_t shader_hash,
+                        std::span<const uint32_t> code, const std::string& decoded_dump) {
+	if (!Config::GraphicsDebugDumpEnabled()) {
+		return;
+	}
+	EXIT_IF(code.empty());
+	static std::atomic_int id = 0;
+	const auto base = Config::GetShaderLogFolder() / "original" /
+	                  fmt::format("{:04d}_new_shader_{}_{:016x}", id++, stage_name, shader_hash);
+	Common::File::CreateDirectories(base.parent_path());
+	for (const auto& [suffix, data, size]: {
+	         std::tuple {".bin", static_cast<const void*>(code.data()), code.size_bytes()},
+	         std::tuple {".rdna2", static_cast<const void*>(decoded_dump.data()),
+	                     decoded_dump.size()},
+	     }) {
+		if (size == 0) {
+			continue;
+		}
+		auto path = base;
+		path += suffix;
+		Common::File file(path, Common::File::Mode::Write);
+		if (file.IsInvalid()) {
+			const auto path_text = Common::PathToString(path);
+			LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", path_text.c_str());
+		} else {
+			file.Write(data, size);
+		}
+	}
+}
+
+bool ValidateShaderSpirv(const char* label, uint64_t shader_hash,
+                         const std::vector<uint32_t>& spirv) {
+	if (!Config::ShaderValidationEnabled()) {
+		return true;
+	}
+	spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_3);
+	std::string          messages;
+	tools.SetMessageConsumer([&messages](spv_message_level_t, const char*,
+	                                     const spv_position_t& position, const char* message) {
+		messages += fmt::format("{}: {} ({}) {}\n", static_cast<int>(position.line),
+		                        static_cast<int>(position.column), static_cast<int>(position.index),
+		                        message);
+	});
+	if (tools.Validate(spirv)) {
+		return true;
+	}
+	spvtools::SpirvTools disassembler(SPV_ENV_VULKAN_1_2);
+	std::string          text;
+	disassembler.Disassemble(spirv, &text,
+	                         static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER) |
+	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) |
+	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COMMENT) |
+	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_INDENT) |
+	                             static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COLOR));
+	LOGF_COLOR(Log::Color::BrightRed, "%s SPIR-V validation failed hash=0x%016" PRIx64 ":\n%s",
+	           label, shader_hash, messages.c_str());
+	LOGF("%s\n", text.c_str());
+	return false;
+}
+
 } // namespace
 
 struct PipelineCache::ProgramCache {
-	struct SourceKey {
-		ShaderType stage = ShaderType::Unknown;
-		uint64_t   hash  = 0;
+	struct ProgramKey {
+		ShaderType            stage           = ShaderType::Unknown;
+		uint64_t              hash            = 0;
+		uint32_t              user_data_count = 0;
+		uint32_t              code_size       = 0;
+		std::vector<uint32_t> static_state;
 
-		bool operator==(const SourceKey&) const = default;
+		bool operator==(const ProgramKey&) const = default;
 	};
 
 	struct Permutation {
-		std::vector<uint32_t>                               static_key;
-		std::shared_ptr<const ShaderRecompiler::IR::Program> program;
-		ShaderProgram                                       handle;
+		ShaderRecompiler::IR::ResourceSpecialization specialization;
+		ShaderRecompiler::IR::CompiledShaderInfo     program;
+		ShaderProgram                                handle;
 	};
 
-	struct SourceKeyHash {
-		std::size_t operator()(const SourceKey& key) const {
+	struct SourceEntry {
+		explicit SourceEntry(ShaderRecompiler::IR::ResourcePlan plan)
+		    : resource_plan(std::move(plan)) {
+			permutations.reserve(8);
+		}
+
+		ShaderRecompiler::IR::ResourcePlan resource_plan;
+		std::vector<Permutation>           permutations;
+	};
+
+	struct ProgramKeyHash {
+		std::size_t operator()(const ProgramKey& key) const {
 			std::size_t hash = static_cast<std::size_t>(key.stage);
 			PipelineKeyHash::Mix(hash, static_cast<std::size_t>(key.hash));
 			if constexpr (sizeof(std::size_t) < sizeof(uint64_t)) {
 				PipelineKeyHash::Mix(hash, static_cast<std::size_t>(key.hash >> 32u));
 			}
+			PipelineKeyHash::Mix(hash, key.user_data_count);
+			PipelineKeyHash::Mix(hash, key.code_size);
+			PipelineKeyHash::Mix(hash, key.static_state.size());
+			// Bucket same-shape static variants by source. ProgramKey equality performs the one
+			// exact state comparison needed on a stable hit without hashing up to 429 words first.
 			return hash;
 		}
 	};
 
-	static uint64_t MixId(uint64_t hash, uint64_t value) {
-		return hash ^ (value + 0x9e3779b97f4a7c15ull + (hash << 6u) + (hash >> 2u));
+	static constexpr std::size_t MaxStaticKeyWords = 13 + ShaderVertexInputInfo::RES_MAX * 13;
+
+	template <ShaderType Stage>
+	Permutation CompilePermutation(const ShaderParams&                          params,
+	                               const ShaderRecompiler::CompileOptions&      options,
+	                               ShaderRecompiler::TranslateResult            translated,
+	                               ShaderRecompiler::IR::ResourceSpecialization specialization,
+	                               uint32_t push_data_start_dword) {
+		constexpr const char* stage_name = [] {
+			if constexpr (Stage == ShaderType::Vertex) {
+				return "vs";
+			} else if constexpr (Stage == ShaderType::Pixel) {
+				return "ps";
+			} else {
+				static_assert(Stage == ShaderType::Compute);
+				return "cs";
+			}
+		}();
+		auto result = ShaderRecompiler::CompileProgram(std::move(translated), options,
+		                                               specialization, push_data_start_dword);
+		DumpShaderOriginal(stage_name, options.shader_hash, params.code, result.decoded_dump);
+		if (!ValidateShaderSpirv(options.dump_label, options.shader_hash, result.spirv)) {
+			DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);
+			EXIT("%s failed hash=0x%016" PRIx64 ": SPIR-V validation failed\n", options.dump_label,
+			     options.shader_hash);
+		}
+		DumpShaderSpirv(stage_name, options.shader_hash, result.spirv);
+
+		vk::ShaderModuleCreateInfo create_info {};
+		create_info.sType       = vk::StructureType::eShaderModuleCreateInfo;
+		create_info.codeSize    = result.spirv.size() * sizeof(uint32_t);
+		create_info.pCode       = result.spirv.data();
+		vk::ShaderModule module = nullptr;
+		RequireVulkanSuccess(device.createShaderModule(&create_info, nullptr, &module),
+		                     "create recompiled shader module");
+		EXIT_IF(module == nullptr);
+		if (options.dump_ir) {
+			if (!options.early_dump) {
+				LOGF("%s decoded RDNA2:\n%s", options.dump_label, result.decoded_dump.c_str());
+				LOGF("%s IR:\n%s", options.dump_label, result.ir_dump.c_str());
+			}
+			LOGF("%s SPIR-V words=%" PRIu64 " wave_size=%u\n", options.dump_label,
+			     static_cast<uint64_t>(result.spirv.size()), options.wave_size);
+		}
+		return {
+		    .specialization = std::move(specialization),
+		    .program        = std::move(result.program).TakeCompiledInfo(),
+		    .handle         = {.id = ++next_shader_id, .module = module},
+		};
 	}
 
-	static constexpr std::size_t MaxStaticKeyWords =
-	    12 + ShaderVertexInputInfo::RES_MAX * 17;
-
 	template <typename InputInfo>
-	ShaderProgram Get(const ShaderParams& params, InputInfo& input_info) {
+	ShaderProgram Get(const ShaderParams& params, InputInfo& input_info,
+	                  uint32_t& push_data_cursor) {
 		constexpr ShaderType stage = [] {
 			if constexpr (std::is_same_v<InputInfo, ShaderVertexInputInfo>) {
 				return ShaderType::Vertex;
@@ -131,36 +281,106 @@ struct PipelineCache::ProgramCache {
 			}
 		}();
 
-		BuildStageStaticKey(input_info, key_scratch);
-		auto& permutations = programs[{stage, params.hash}];
-		for (const auto& permutation: permutations) {
-			if (permutation.static_key == key_scratch &&
-			    MaterializeProgram(permutation.program, params, input_info)) {
-				return permutation.handle;
+		lookup_key.stage           = stage;
+		lookup_key.hash            = params.hash;
+		lookup_key.user_data_count = static_cast<uint32_t>(params.user_data.size());
+		lookup_key.code_size       = static_cast<uint32_t>(params.code.size());
+		BuildStageStaticKey(input_info, lookup_key.static_state);
+		auto                                         entry = programs.find(lookup_key);
+		ShaderRecompiler::IR::ResourceSnapshot       resources;
+		ShaderRecompiler::IR::ResourceSpecialization specialization;
+		const ShaderRecompiler::IR::SrtRuntime       runtime {
+		    .user_data                  = params.user_data,
+		    .shader_base                = params.Base(),
+		    .read_specialization_memory = ReadShaderGuestMemory,
+		};
+		if (entry != programs.end()) {
+			EXIT_IF(!ShaderRecompiler::IR::MaterializeResources(
+			    entry->second.resource_plan, runtime, resources, specialization));
+			if (const auto permutation = std::ranges::find_if(
+			        entry->second.permutations, [&](const Permutation& candidate) {
+				        const auto& layout = candidate.program.bindings;
+				        return layout.push_data_start_dword ==
+				                   ShaderRecompiler::IR::PushData::StartFor(
+				                       push_data_cursor, layout.ShaderDataDwords()) &&
+				               candidate.specialization == specialization;
+			        });
+			    permutation != entry->second.permutations.end()) {
+				input_info.stage = {.program   = &permutation->program,
+				                    .resources = std::move(resources)};
+				permutation->program.bindings.AdvancePushData(push_data_cursor);
+				return permutation->handle;
 			}
 		}
 
-		const auto module = CompileProgram(device, params, input_info);
-		EXIT_IF(module == nullptr || !input_info.stage);
-		uint64_t id = MixId(MixId(params.hash, static_cast<uint64_t>(stage)), permutations.size());
-		if (id == 0) {
-			id = 1;
+		ShaderStageInputInfo stage_input {};
+		if constexpr (std::is_same_v<InputInfo, ShaderVertexInputInfo>) {
+			stage_input.vertex = &input_info;
+		} else if constexpr (std::is_same_v<InputInfo, ShaderPixelInputInfo>) {
+			stage_input.pixel = &input_info;
+		} else {
+			stage_input.compute = &input_info;
 		}
-		const ShaderProgram handle {.id = id, .module = module};
-		permutations.push_back({key_scratch, input_info.stage.program, handle});
+		constexpr const char* label = [] {
+			if constexpr (stage == ShaderType::Vertex) {
+				return "ShaderRecompiler VS";
+			} else if constexpr (stage == ShaderType::Pixel) {
+				return "ShaderRecompiler PS";
+			} else {
+				return "ShaderRecompiler CS";
+			}
+		}();
+		ShaderRecompiler::CompileOptions options;
+		options.stage       = stage;
+		options.shader_hash = params.hash;
+		options.user_data   = params.user_data;
+		options.dump_ir     = Config::GetShaderLogDirection() != Config::ShaderLogDirection::Silent;
+		options.early_dump  = options.dump_ir;
+		options.dump_label  = label;
+		options.input_info  = stage_input;
+		if constexpr (stage == ShaderType::Vertex) {
+			options.user_data_base = 8;
+			options.scratch_dwords = input_info.scratch_size_dwords;
+		} else if constexpr (stage == ShaderType::Pixel) {
+			options.scratch_dwords = input_info.scratch_size_dwords;
+		} else {
+			options.scratch_dwords = input_info.scratch_size_dwords;
+			options.wave_size      = input_info.wave_size;
+		}
+		auto translated = ShaderRecompiler::TranslateProgram(params.code, options);
+		if (entry == programs.end()) {
+			auto resource_plan = ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
+			EXIT_IF(!ShaderRecompiler::IR::MaterializeResources(resource_plan, runtime, resources,
+			                                                    specialization));
+			entry = programs.try_emplace(lookup_key, std::move(resource_plan)).first;
+		}
+		entry->second.permutations.push_back(CompilePermutation<stage>(
+		    params, options, std::move(translated), std::move(specialization), push_data_cursor));
+		const auto& permutation = entry->second.permutations.back();
+		input_info.stage = {.program = &permutation.program, .resources = std::move(resources)};
+		permutation.program.bindings.AdvancePushData(push_data_cursor);
 
 		std::printf("Num compiled %u shaders\n", ++num_compiled);
-		return handle;
+		return permutation.handle;
 	}
 
 	explicit ProgramCache(vk::Device device): device(device) {
-		key_scratch.reserve(MaxStaticKeyWords);
+		lookup_key.static_state.reserve(MaxStaticKeyWords);
+	}
+	~ProgramCache() {
+		for (const auto& [key, entry]: programs) {
+			(void)key;
+			for (const auto& permutation: entry.permutations) {
+				device.destroyShaderModule(permutation.handle.module, nullptr);
+			}
+		}
 	}
 
-	std::unordered_map<SourceKey, std::vector<Permutation>, SourceKeyHash> programs;
-	std::vector<uint32_t> key_scratch;
-	vk::Device device;
-	uint32_t   num_compiled = 0;
+	std::unordered_map<ProgramKey, SourceEntry, ProgramKeyHash> programs;
+	ProgramKey                                                  lookup_key;
+	vk::Device                                                  device;
+	uint32_t                                                    num_compiled   = 0;
+	uint64_t                                                    next_shader_id = 0;
 };
 
 PipelineCache::PipelineCache(GraphicContext& graphics)
@@ -181,12 +401,6 @@ PipelineCache::~PipelineCache() {
 	};
 	destroy(m_graphics_pipelines);
 	destroy(m_compute_pipelines);
-	for (const auto& [key, permutations]: m_program_cache->programs) {
-		(void)key;
-		for (const auto& permutation: permutations) {
-			m_graphics.device.destroyShaderModule(permutation.handle.module, nullptr);
-		}
-	}
 	if (m_driver_cache != nullptr) {
 		m_graphics.device.destroyPipelineCache(m_driver_cache, nullptr);
 	}
@@ -212,7 +426,7 @@ void PipelineCache::InitializeDriverCache() {
 		return;
 	}
 
-	m_driver_cache_path = std::filesystem::path("_PipelineCache") / (title_id + ".bin");
+	m_driver_cache_path     = std::filesystem::path("_PipelineCache") / (title_id + ".bin");
 	const auto path         = Common::PathToString(m_driver_cache_path);
 	const bool cache_exists = Common::File::IsFileExisting(m_driver_cache_path);
 	if (cache_exists) {
@@ -224,7 +438,7 @@ void PipelineCache::InitializeDriverCache() {
 	if (cache_exists) {
 		Common::File file(m_driver_cache_path, Common::File::Mode::Read);
 		const auto   file_size = file.IsInvalid() ? 0 : file.Size();
-		const auto signature = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
+		const auto   signature = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
 		if (file_size >= signature.size() + sizeof(uint64_t) &&
 		    file_size <= std::numeric_limits<uint32_t>::max()) {
 			std::string cached_signature(signature.size(), '\0');
@@ -236,7 +450,8 @@ void PipelineCache::InitializeDriverCache() {
 			file.Read(cached_signature.data(), static_cast<uint32_t>(cached_signature.size()),
 			          &signature_read);
 			file.Read(&payload_hash, sizeof(payload_hash), &hash_read);
-			file.Read(initial_data.data(), static_cast<uint32_t>(initial_data.size()), &payload_read);
+			file.Read(initial_data.data(), static_cast<uint32_t>(initial_data.size()),
+			          &payload_read);
 			file.Close();
 			if (signature_read != cached_signature.size() || hash_read != sizeof(payload_hash) ||
 			    payload_read != initial_data.size() || cached_signature != signature ||
@@ -248,8 +463,7 @@ void PipelineCache::InitializeDriverCache() {
 			}
 		} else {
 			file.Close();
-			PipelineCacheLog("Vulkan pipeline cache: invalidating {} (invalid file size)",
-			                 path);
+			PipelineCacheLog("Vulkan pipeline cache: invalidating {} (invalid file size)", path);
 		}
 	}
 
@@ -308,7 +522,7 @@ void PipelineCache::Save() {
 		return;
 	}
 	payload.resize(size);
-	auto prefix = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
+	auto       prefix       = DriverCacheSignature(m_graphics.GetPhysicalDeviceProperties());
 	const auto payload_hash = XXH3_64bits(payload.data(), payload.size());
 	prefix.append(reinterpret_cast<const char*>(&payload_hash), sizeof(payload_hash));
 	if (!Common::File::CreateDirectories(m_driver_cache_path.parent_path())) {
@@ -338,15 +552,20 @@ void PipelineCache::Save() {
 	m_driver_cache = nullptr;
 }
 
-ShaderProgram PipelineCache::GetVertexProgram(const HW::VertexShaderInfo& regs,
-                                              const HW::ShaderRegisters&  sh,
-                                              const HW::Context&          context,
-                                              ShaderVertexInputInfo&      input_info) {
-	const auto params = PrepareProgram(regs, sh, input_info);
+PipelineCache::GraphicsPrograms PipelineCache::GetGraphicsPrograms(
+    const HW::VertexShaderInfo& vertex_regs, const HW::PixelShaderInfo& pixel_regs,
+    const HW::ShaderRegisters& sh, const HW::Context& context,
+    std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
+    bool pixel_active, ShaderVertexInputInfo& vertex_info, ShaderPixelInputInfo& pixel_info) {
+	const auto vertex_params = PrepareProgram(vertex_regs, sh, vertex_info);
+	ShaderParams pixel_params;
+	if (pixel_active) {
+		pixel_params = PrepareProgram(pixel_regs, sh, target_export_mapping, pixel_info);
+	}
 	if (context.GetClipControl().clip_disable) {
 		const auto& viewport = context.GetScreenViewport().viewports[0];
 		const auto& limits   = m_graphics.GetPhysicalDeviceProperties().limits;
-		auto&       clip     = input_info.clip_space;
+		auto&       clip     = vertex_info.clip_space;
 		clip.scale[0]        = viewport.xscale;
 		clip.scale[1]        = viewport.yscale;
 		clip.offset[0]       = viewport.xoffset;
@@ -358,26 +577,23 @@ ShaderProgram PipelineCache::GetVertexProgram(const HW::VertexShaderInfo& regs,
 		clip.enabled = true;
 	}
 	Common::LockGuard lock(m_mutex);
-	return m_program_cache->Get(params, input_info);
-}
-
-ShaderProgram PipelineCache::GetPixelProgram(
-    const HW::PixelShaderInfo& regs, const HW::ShaderRegisters& sh,
-    const ShaderVertexInputInfo&                        vertex_info,
-    std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
-    ShaderPixelInputInfo&                               input_info) {
-	const auto params = PrepareProgram(regs, sh, vertex_info, target_export_mapping, input_info);
-	Common::LockGuard lock(m_mutex);
-	return m_program_cache->Get(params, input_info);
+	uint32_t          push_data_cursor = 0;
+	GraphicsPrograms  result;
+	if (pixel_active) {
+		result.pixel = m_program_cache->Get(pixel_params, pixel_info, push_data_cursor);
+	}
+	result.vertex = m_program_cache->Get(vertex_params, vertex_info, push_data_cursor);
+	return result;
 }
 
 ShaderProgram PipelineCache::GetComputeProgram(const HW::ComputeShaderInfo& regs,
                                                const HW::ShaderRegisters&   sh,
                                                ShaderComputeInputInfo&      input_info) {
 	input_info.needs_lds_barriers = !m_graphics.compute_wave64_supported;
-	const auto params             = PrepareProgram(regs, sh, input_info);
+	const auto        params      = PrepareProgram(regs, sh, input_info);
 	Common::LockGuard lock(m_mutex);
-	return m_program_cache->Get(params, input_info);
+	uint32_t          push_data_cursor = 0;
+	return m_program_cache->Get(params, input_info, push_data_cursor);
 }
 
 bool PipelineStaticParameters::operator==(const PipelineStaticParameters& other) const noexcept {
@@ -401,8 +617,7 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	Common::LockGuard lock(m_mutex);
 	auto&             ctx = command.GetRegisters();
 
-	const HW::BlendColor& bclr                                     = ctx.GetBlendColor();
-	uint32_t              color_mask[RENDER_COLOR_ATTACHMENTS_MAX] = {};
+	uint32_t color_mask[RENDER_COLOR_ATTACHMENTS_MAX] = {};
 	for (uint32_t i = 0; i < color_count; i++) {
 		color_mask[i] =
 		    (colors[i].image_id ? colors[i].export_mapping.ApplyMask(render_target_mask_slot(
@@ -506,11 +721,6 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 		static_params.blend_enable[i]         = bc.enable;
 		static_params.blend_bypass[i]         = rt.info.blend_bypass;
 	}
-	static_params.blend_color_red   = bclr.red;
-	static_params.blend_color_green = bclr.green;
-	static_params.blend_color_blue  = bclr.blue;
-	static_params.blend_color_alpha = bclr.alpha;
-
 	NormalizeStaticParamsForDynamicState(static_params);
 
 	GraphicsPipelineKey key {};
@@ -518,6 +728,30 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 	key.vs_shader_id  = p.vs_shader_id;
 	key.ps_shader_id  = p.ps_shader_id;
 	key.static_params = static_params;
+	EXIT_IF(vs_input_info.buffers_num < 0 ||
+	        vs_input_info.buffers_num > ShaderVertexInputInfo::RES_MAX ||
+	        vs_input_info.resources_num < 0 ||
+	        vs_input_info.resources_num > ShaderVertexInputInfo::RES_MAX);
+	key.vertex_input.binding_count   = static_cast<uint8_t>(vs_input_info.buffers_num);
+	key.vertex_input.attribute_count = static_cast<uint8_t>(vs_input_info.resources_num);
+	uint32_t attributes_num          = 0;
+	for (int binding = 0; binding < vs_input_info.buffers_num; binding++) {
+		const auto& buffer = vs_input_info.buffers[binding];
+		EXIT_IF(buffer.attr_num < 0 || buffer.attr_num > ShaderVertexInputBuffer::ATTR_MAX);
+		attributes_num += static_cast<uint32_t>(buffer.attr_num);
+		EXIT_IF(attributes_num > static_cast<uint32_t>(vs_input_info.resources_num));
+		key.vertex_input.bindings[binding] = {.stride   = buffer.stride,
+		                                      .instance = buffer.fetch_index != 0};
+		for (int attribute = 0; attribute < buffer.attr_num; attribute++) {
+			const auto index = buffer.attr_indices[attribute];
+			EXIT_IF(index < 0 || index >= vs_input_info.resources_num);
+			key.vertex_input.attributes[index] = {
+			    .offset  = buffer.attr_offsets[attribute],
+			    .binding = static_cast<uint8_t>(binding),
+			};
+		}
+	}
+	EXIT_IF(attributes_num != static_cast<uint32_t>(vs_input_info.resources_num));
 
 	if (auto iter = m_graphics_pipelines.find(key); iter != m_graphics_pipelines.end()) {
 		return *iter->second;
@@ -528,16 +762,16 @@ PipelineCache::GraphicsPipeline& PipelineCache::CreateGraphicsPipeline(
 		if (ps_active) {
 			ShaderDbgDumpInputInfo(*ps_input_info);
 		}
-		LOGF("PipelineTrace: shader modules VS=%" PRIu64 " module=%p PS=%" PRIu64
-		     " module=%p\n",
+		LOGF("PipelineTrace: shader modules VS=%" PRIu64 " module=%p PS=%" PRIu64 " module=%p\n",
 		     vs_id, static_cast<void*>(vertex_program.module), ps_id,
 		     static_cast<void*>(pixel_program.module));
 	}
 
 	auto cached = std::make_unique<GraphicsPipeline>(p);
 	LogPipelineTrace("CreatePipelineInternal begin", vs_id, ps_id);
-	CreatePipelineInternal(m_graphics, *cached, rendering, vs_input_info, vertex_program.module,
-	                       ps_input_info, pixel_program.module, static_params, m_driver_cache);
+	CreatePipelineInternal(m_graphics, *cached, rendering, key.vertex_input, vs_input_info,
+	                       vertex_program.module, ps_input_info, pixel_program.module,
+	                       static_params, m_driver_cache);
 	LogPipelineTrace("CreatePipelineInternal done", vs_id, ps_id);
 
 	EXIT_NOT_IMPLEMENTED(cached->pipeline == nullptr);

src/graphics/host_gpu/renderer/pipeline/pipelineCache.h

@@ -65,10 +65,6 @@ struct PipelineStaticParameters {
 	bool                       separate_alpha_blend[RENDER_COLOR_ATTACHMENTS_MAX] = {};
 	bool                       blend_enable[RENDER_COLOR_ATTACHMENTS_MAX]         = {};
 	bool                       blend_bypass[RENDER_COLOR_ATTACHMENTS_MAX]         = {};
-	float                      blend_color_red                                    = 0.0f;
-	float                      blend_color_green                                  = 0.0f;
-	float                      blend_color_blue                                   = 0.0f;
-	float                      blend_color_alpha                                  = 0.0f;
 
 	bool operator==(const PipelineStaticParameters& other) const noexcept;
 };
@@ -85,7 +81,7 @@ static_assert(sizeof(PipelineStaticParameters) ==
                   sizeof(bool) + sizeof(PipelineStencilStaticState) * 2 + sizeof(uint32_t) +
                   sizeof(uint32_t[RENDER_COLOR_ATTACHMENTS_MAX]) + sizeof(bool) * 3 +
                   sizeof(uint8_t[RENDER_COLOR_ATTACHMENTS_MAX]) * 6 +
-                  sizeof(bool[RENDER_COLOR_ATTACHMENTS_MAX]) * 3 + sizeof(float) * 4);
+                  sizeof(bool[RENDER_COLOR_ATTACHMENTS_MAX]) * 3);
 
 struct PipelineRenderingState {
 	std::array<vk::Format, RENDER_COLOR_ATTACHMENTS_MAX> color_formats {};
@@ -96,13 +92,31 @@ struct PipelineRenderingState {
 	bool operator==(const PipelineRenderingState&) const = default;
 };
 
+struct PipelineVertexInputState {
+	struct Binding {
+		uint32_t stride                           = 0;
+		bool     instance                         = false;
+		bool     operator==(const Binding&) const = default;
+	};
+	struct Attribute {
+		uint32_t offset                             = 0;
+		uint8_t  binding                            = 0;
+		bool     operator==(const Attribute&) const = default;
+	};
+
+	std::array<Binding, ShaderVertexInputInfo::RES_MAX>   bindings {};
+	std::array<Attribute, ShaderVertexInputInfo::RES_MAX> attributes {};
+	uint8_t                                               binding_count   = 0;
+	uint8_t                                               attribute_count = 0;
+
+	bool operator==(const PipelineVertexInputState&) const = default;
+};
+
 struct ShaderProgram {
 	uint64_t         id     = 0;
 	vk::ShaderModule module = nullptr;
 
-	explicit operator bool() const {
-		return id != 0 && module != nullptr;
-	}
+	explicit operator bool() const { return id != 0 && module != nullptr; }
 };
 
 class PipelineCache {
@@ -128,25 +142,26 @@ public:
 		uint64_t cs_shader_id = 0;
 	};
 
-	ShaderProgram GetVertexProgram(const HW::VertexShaderInfo& regs,
-	                               const HW::ShaderRegisters&  sh,
-	                               const HW::Context&          context,
-	                               ShaderVertexInputInfo&      input_info);
-	ShaderProgram
-	GetPixelProgram(const HW::PixelShaderInfo& regs, const HW::ShaderRegisters& sh,
-	                const ShaderVertexInputInfo&                        vertex_info,
-	                std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
-	                ShaderPixelInputInfo&                               input_info);
-	ShaderProgram GetComputeProgram(const HW::ComputeShaderInfo& regs,
-	                                const HW::ShaderRegisters& sh,
-	                                ShaderComputeInputInfo& input_info);
+	struct GraphicsPrograms {
+		ShaderProgram vertex;
+		ShaderProgram pixel;
+	};
 
-	GraphicsPipeline& CreateGraphicsPipeline(
-	    std::span<const RenderColorInfo> colors, const RenderDepthInfo& depth,
-	    const ShaderVertexInputInfo& vs_input_info, CommandBuffer& command,
-	    const ShaderPixelInputInfo* ps_input_info, vk::PrimitiveTopology topology,
-	    bool primitive_restart_enable, const ShaderProgram& vertex_program,
-	    const ShaderProgram& pixel_program);
+	GraphicsPrograms GetGraphicsPrograms(
+	    const HW::VertexShaderInfo& vertex_regs, const HW::PixelShaderInfo& pixel_regs,
+	    const HW::ShaderRegisters& sh, const HW::Context& context,
+	    std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
+	    bool pixel_active, ShaderVertexInputInfo& vertex_info, ShaderPixelInputInfo& pixel_info);
+	ShaderProgram GetComputeProgram(const HW::ComputeShaderInfo& regs,
+	                                const HW::ShaderRegisters&   sh,
+	                                ShaderComputeInputInfo&      input_info);
+
+	GraphicsPipeline&
+	CreateGraphicsPipeline(std::span<const RenderColorInfo> colors, const RenderDepthInfo& depth,
+	                       const ShaderVertexInputInfo& vs_input_info, CommandBuffer& command,
+	                       const ShaderPixelInputInfo* ps_input_info,
+	                       vk::PrimitiveTopology topology, bool primitive_restart_enable,
+	                       const ShaderProgram& vertex_program, const ShaderProgram& pixel_program);
 	ComputePipeline& CreateComputePipeline(ShaderComputeInputInfo& input_info,
 	                                       const ShaderProgram&    compute_program);
 
@@ -157,11 +172,13 @@ private:
 		PipelineRenderingState   rendering;
 		uint64_t                 vs_shader_id = 0;
 		uint64_t                 ps_shader_id = 0;
+		PipelineVertexInputState vertex_input;
 		PipelineStaticParameters static_params;
 
 		bool operator==(const GraphicsPipelineKey& other) const {
 			return rendering == other.rendering && vs_shader_id == other.vs_shader_id &&
-			       ps_shader_id == other.ps_shader_id && static_params == other.static_params;
+			       ps_shader_id == other.ps_shader_id && vertex_input == other.vertex_input &&
+			       static_params == other.static_params;
 		}
 	};
 
@@ -202,6 +219,16 @@ private:
 			PipelineKeyHash::MixRendering(hash, key.rendering);
 			PipelineKeyHash::Mix(hash, key.vs_shader_id);
 			PipelineKeyHash::Mix(hash, key.ps_shader_id);
+			PipelineKeyHash::Mix(hash, key.vertex_input.binding_count);
+			for (uint32_t i = 0; i < key.vertex_input.binding_count; i++) {
+				PipelineKeyHash::Mix(hash, key.vertex_input.bindings[i].stride);
+				PipelineKeyHash::Mix(hash, key.vertex_input.bindings[i].instance);
+			}
+			PipelineKeyHash::Mix(hash, key.vertex_input.attribute_count);
+			for (uint32_t i = 0; i < key.vertex_input.attribute_count; i++) {
+				PipelineKeyHash::Mix(hash, key.vertex_input.attributes[i].offset);
+				PipelineKeyHash::Mix(hash, key.vertex_input.attributes[i].binding);
+			}
 			PipelineKeyHash::MixStaticParams(hash, key.static_params);
 			return hash;
 		}
@@ -215,7 +242,7 @@ private:
 		}
 	};
 
-	GraphicContext&                m_graphics;
+	GraphicContext&               m_graphics;
 	std::unique_ptr<ProgramCache> m_program_cache;
 	vk::PipelineCache             m_driver_cache = nullptr;
 	std::filesystem::path         m_driver_cache_path;
@@ -232,13 +259,13 @@ private:
 void LogPipelineTrace(const char* phase, uint64_t vertex_program_id, uint64_t pixel_program_id);
 void CreatePipelineInternal(
     GraphicContext& graphics, PipelineCache::GraphicsPipeline& pipeline,
-    const PipelineRenderingState& rendering, const ShaderVertexInputInfo& vs_input_info,
-    vk::ShaderModule vertex_module, const ShaderPixelInputInfo* ps_input_info,
-	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params,
-	vk::PipelineCache driver_cache);
+    const PipelineRenderingState& rendering, const PipelineVertexInputState& vertex_input,
+    const ShaderVertexInputInfo& vs_input_info, vk::ShaderModule vertex_module,
+    const ShaderPixelInputInfo* ps_input_info, vk::ShaderModule pixel_module,
+    const PipelineStaticParameters& static_params, vk::PipelineCache driver_cache);
 void CreatePipelineInternal(GraphicContext& graphics, PipelineCache::ComputePipeline& pipeline,
                             const ShaderComputeInputInfo& input_info,
-	vk::ShaderModule compute_module, vk::PipelineCache driver_cache);
+                            vk::ShaderModule compute_module, vk::PipelineCache driver_cache);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/renderer/pipeline/shaderResourceBarrier.cpp

@@ -69,7 +69,7 @@ vk::BufferMemoryBarrier MakeGdsDependency(vk::Buffer buffer) {
 }
 
 std::vector<ShaderBufferWriteRange>
-CollectShaderBufferWrites(const ShaderRecompiler::IR::Program&          program,
+CollectShaderBufferWrites(const ShaderRecompiler::IR::CompiledShaderInfo& program,
                           const ShaderRecompiler::IR::ResourceSnapshot& resources) {
 	EXIT_IF(resources.buffers.size() != program.info.buffers.size());
 	std::vector<ShaderBufferWriteRange> writes;
@@ -97,7 +97,7 @@ CollectShaderBufferWrites(const ShaderRecompiler::IR::Program&          program,
 
 bool HasShaderBufferWrites(const ShaderStageRuntime& runtime) {
 	EXIT_IF(!runtime);
-	return !CollectShaderBufferWrites(*runtime.program, *runtime.resources).empty();
+	return !CollectShaderBufferWrites(*runtime.program, runtime.resources).empty();
 }
 
 void ShaderAccessBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages) {

src/graphics/host_gpu/renderer/pipeline/shaderResourceBarrier.h

@@ -23,7 +23,7 @@ VulkanMemoryBarrier     MakeShaderWriteHazardDependency();
 VulkanMemoryBarrier     MakeShaderWriteDependency();
 vk::BufferMemoryBarrier MakeGdsDependency(vk::Buffer buffer);
 std::vector<ShaderBufferWriteRange>
-CollectShaderBufferWrites(const ShaderRecompiler::IR::Program&          program,
+CollectShaderBufferWrites(const ShaderRecompiler::IR::CompiledShaderInfo& program,
                           const ShaderRecompiler::IR::ResourceSnapshot& resources);
 bool HasShaderBufferWrites(const ShaderStageRuntime& runtime);
 void ShaderAccessBarrier(vk::CommandBuffer vk_buffer, vk::PipelineStageFlags source_stages);

src/graphics/host_gpu/renderer/pipeline/shaders.cpp

@@ -390,7 +390,7 @@ static vk::BlendOp GetBlendOp(uint32_t op) {
 }
 
 static void AddLayoutBindings(std::vector<vk::DescriptorSetLayoutBinding>& descriptor_bindings,
-                              const ShaderRecompiler::IR::Program& program,
+                              const ShaderRecompiler::IR::CompiledShaderInfo& program,
                               vk::ShaderStageFlagBits              stage) {
 	for (const auto& binding: program.bindings.descriptors) {
 		descriptor_bindings.push_back(
@@ -421,10 +421,10 @@ static void CreateDescriptorLayout(GraphicContext& graphics, PipelineCache::Pipe
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
 void CreatePipelineInternal(
     GraphicContext& graphics, PipelineCache::GraphicsPipeline& pipeline,
-    const PipelineRenderingState& rendering, const ShaderVertexInputInfo& vs_input_info,
-    vk::ShaderModule vertex_module, const ShaderPixelInputInfo* ps_input_info,
-	vk::ShaderModule pixel_module, const PipelineStaticParameters& static_params,
-	vk::PipelineCache driver_cache) {
+    const PipelineRenderingState& rendering, const PipelineVertexInputState& vertex_input,
+    const ShaderVertexInputInfo& vs_input_info, vk::ShaderModule vertex_module,
+    const ShaderPixelInputInfo* ps_input_info, vk::ShaderModule pixel_module,
+    const PipelineStaticParameters& static_params, vk::PipelineCache driver_cache) {
 	const bool ps_active = ps_input_info != nullptr;
 	EXIT_IF(vertex_module == nullptr || (ps_active && pixel_module == nullptr));
 
@@ -505,135 +505,131 @@ void CreatePipelineInternal(
 		shader_stages[shader_stage_count++] = frag_shader_stage_info;
 	}
 
-	vk::VertexInputAttributeDescription input_attr[ShaderVertexInputInfo::RES_MAX];
-	vk::VertexInputBindingDescription   input_desc[ShaderVertexInputInfo::RES_MAX];
+	vk::VertexInputAttributeDescription input_attr[ShaderVertexInputInfo::RES_MAX] {};
+	vk::VertexInputBindingDescription   input_desc[ShaderVertexInputInfo::RES_MAX] {};
 
-	for (int bi = 0; bi < vs_input_info.buffers_num; bi++) {
-		const auto& b          = vs_input_info.buffers[bi];
-		input_desc[bi].binding = bi;
-		input_desc[bi].stride  = b.stride;
-		input_desc[bi].inputRate =
-		    (b.fetch_index == 0 ? vk::VertexInputRate::eVertex : vk::VertexInputRate::eInstance);
+	for (uint32_t binding = 0; binding < vertex_input.binding_count; binding++) {
+		input_desc[binding].binding   = binding;
+		input_desc[binding].stride    = vertex_input.bindings[binding].stride;
+		input_desc[binding].inputRate = vertex_input.bindings[binding].instance
+		                                    ? vk::VertexInputRate::eInstance
+		                                    : vk::VertexInputRate::eVertex;
+	}
+	for (uint32_t index = 0; index < vertex_input.attribute_count; index++) {
+		input_attr[index].binding  = vertex_input.attributes[index].binding;
+		input_attr[index].location = index;
+		input_attr[index].offset   = vertex_input.attributes[index].offset;
 
-		for (int ai = 0; ai < b.attr_num; ai++) {
-			auto index                 = b.attr_indices[ai];
-			input_attr[index].binding  = bi;
-			input_attr[index].location = index;
-			input_attr[index].offset   = b.attr_offsets[ai];
+		uint32_t   attr_size     = 4;
+		const auto registers_num = vs_input_info.resources_dst[index].registers_num;
+		const auto compiled_components =
+		    vs_input_info.stage.program->info.vertex_fetch_components[index];
+		const auto used_components =
+		    compiled_components > 0 ? static_cast<int>(compiled_components) : registers_num;
+		GetInputFormat(vs_input_info.resources[index], input_attr[index].format, attr_size,
+		               static_cast<uint32_t>(used_components));
 
-			uint32_t attr_size       = 4;
-			auto     registers_num   = vs_input_info.resources_dst[index].registers_num;
-			const auto compiled_components =
-			    vs_input_info.stage.program->info.vertex_fetch_components[index];
-			auto used_components =
-			    compiled_components > 0 ? static_cast<int>(compiled_components) : registers_num;
-			GetInputFormat(vs_input_info.resources[index], input_attr[index].format, attr_size,
-			               static_cast<uint32_t>(used_components));
-
-			if (graphics_debug_dump_enabled()) {
-				static std::atomic_uint log_count = 0;
-				const auto              log_id = log_count.fetch_add(1, std::memory_order_relaxed);
-				if (log_id < 128) {
-					LOGF("VertexInputState[%u]: attr=%u binding=%u offset=%u stride=%u fmt=%d "
-					     "src_fmt=%u dst=v%u regs=%u"
-					     " fetched_components=%u attr_size=%u swizzle=%u,%u,%u,%u\n",
-					     log_id, index, input_attr[index].binding, input_attr[index].offset,
-					     input_desc[bi].stride, static_cast<int>(input_attr[index].format),
-					     static_cast<uint32_t>(vs_input_info.resources[index].Format()),
-					     static_cast<uint32_t>(vs_input_info.resources_dst[index].register_start),
-					     static_cast<uint32_t>(registers_num),
-					     static_cast<uint32_t>(used_components), attr_size,
-					     static_cast<uint32_t>(vs_input_info.resources[index].DstSelX()),
-					     static_cast<uint32_t>(vs_input_info.resources[index].DstSelY()),
-					     static_cast<uint32_t>(vs_input_info.resources[index].DstSelZ()),
-					     static_cast<uint32_t>(vs_input_info.resources[index].DstSelW()));
-				}
+		if (graphics_debug_dump_enabled()) {
+			static std::atomic_uint log_count = 0;
+			const auto              log_id    = log_count.fetch_add(1, std::memory_order_relaxed);
+			if (log_id < 128) {
+				LOGF("VertexInputState[%u]: attr=%u binding=%u offset=%u stride=%u fmt=%d "
+				     "src_fmt=%u dst=v%u regs=%u"
+				     " fetched_components=%u attr_size=%u swizzle=%u,%u,%u,%u\n",
+				     log_id, index, input_attr[index].binding, input_attr[index].offset,
+				     input_desc[input_attr[index].binding].stride,
+				     static_cast<int>(input_attr[index].format),
+				     static_cast<uint32_t>(vs_input_info.resources[index].Format()),
+				     static_cast<uint32_t>(vs_input_info.resources_dst[index].register_start),
+				     static_cast<uint32_t>(registers_num), static_cast<uint32_t>(used_components),
+				     attr_size, static_cast<uint32_t>(vs_input_info.resources[index].DstSelX()),
+				     static_cast<uint32_t>(vs_input_info.resources[index].DstSelY()),
+				     static_cast<uint32_t>(vs_input_info.resources[index].DstSelZ()),
+				     static_cast<uint32_t>(vs_input_info.resources[index].DstSelW()));
 			}
+		}
 
-			if (vs_input_info.resources[index].OutOfBounds() != 0) {
-				static bool logged = false;
-				if (!logged) {
-					LOGF("VertexInput: temporary: accepting PS5 out-of-bounds behavior %" PRIu8
-					     "\n",
-					     vs_input_info.resources[index].OutOfBounds());
-					logged = true;
-				}
+		if (vs_input_info.resources[index].OutOfBounds() != 0) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("VertexInput: temporary: accepting PS5 out-of-bounds behavior %" PRIu8 "\n",
+				     vs_input_info.resources[index].OutOfBounds());
+				logged = true;
 			}
+		}
 
-			EXIT_NOT_IMPLEMENTED(vs_input_info.resources[index].AddTid());
-			EXIT_NOT_IMPLEMENTED(vs_input_info.resources[index].SwizzleEnabled());
+		EXIT_NOT_IMPLEMENTED(vs_input_info.resources[index].AddTid());
+		EXIT_NOT_IMPLEMENTED(vs_input_info.resources[index].SwizzleEnabled());
 
-			auto log_unsupported_vertex_swizzle = [index, attr_size, registers_num](
-			                                          uint32_t swizzle, uint32_t expected) {
-				static bool logged = false;
-				if (!logged) {
-					LOGF(
-					    "VertexInput: temporary: accepting unsupported dst swizzle at attr %" PRIu32
-					    " (attr_size=%" PRIu32 ", regs=%" PRIu32 ", swizzle=0x%03" PRIx32
-					    ", expected=0x%03" PRIx32 ")\n",
-					    static_cast<uint32_t>(index), attr_size, registers_num, swizzle, expected);
-					logged = true;
-				}
-			};
-
-			switch (registers_num) {
-				case 1: {
-					auto swizzle = vs_input_info.resources[index].DstSelX();
-					if (swizzle != DstSel(4)) {
-						log_unsupported_vertex_swizzle(swizzle, DstSel(4));
-					}
-					break;
-				}
-				case 2: {
-					auto swizzle  = vs_input_info.resources[index].DstSelXY();
-					auto expected = (attr_size == 1 ? DstSel(4, 0) : DstSel(4, 5));
-					if (swizzle != expected) {
-						log_unsupported_vertex_swizzle(swizzle, expected);
-					}
-					break;
-				}
-				case 3: {
-					auto swizzle  = vs_input_info.resources[index].DstSelXYZ();
-					auto expected = DstSel(4, 5, 6);
-					switch (attr_size) {
-						case 1: expected = DstSel(4, 0, 0); break;
-						case 2: expected = DstSel(4, 5, 0); break;
-						default: break;
-					}
-					if (swizzle != expected) {
-						log_unsupported_vertex_swizzle(swizzle, expected);
-					}
-					break;
-				}
-				case 4: {
-					auto swizzle   = vs_input_info.resources[index].DstSelXYZW();
-					auto expected  = DstSel(4, 5, 6, 7);
-					bool supported = false;
-					switch (attr_size) {
-						case 1:
-							expected  = DstSel(4, 0, 0, 1);
-							supported = (swizzle == expected);
-							break;
-						case 2:
-							expected  = DstSel(4, 5, 0, 1);
-							supported = (swizzle == expected);
-							break;
-						case 3:
-							expected  = DstSel(4, 5, 6, 1);
-							supported = (swizzle == expected || swizzle == DstSel(4, 5, 6, 0));
-							break;
-						default:
-							supported = (swizzle == expected || swizzle == DstSel(4, 5, 6, 1) ||
-							             swizzle == DstSel(4, 5, 6, 0));
-							break;
-					}
-					if (!supported) {
-						log_unsupported_vertex_swizzle(swizzle, expected);
-					}
-					break;
-				}
-				default: EXIT("invalid registers_num");
+		auto log_unsupported_vertex_swizzle = [index, attr_size, registers_num](uint32_t swizzle,
+		                                                                        uint32_t expected) {
+			static bool logged = false;
+			if (!logged) {
+				LOGF("VertexInput: temporary: accepting unsupported dst swizzle at attr %" PRIu32
+				     " (attr_size=%" PRIu32 ", regs=%" PRIu32 ", swizzle=0x%03" PRIx32
+				     ", expected=0x%03" PRIx32 ")\n",
+				     static_cast<uint32_t>(index), attr_size, registers_num, swizzle, expected);
+				logged = true;
 			}
+		};
+
+		switch (registers_num) {
+			case 1: {
+				auto swizzle = vs_input_info.resources[index].DstSelX();
+				if (swizzle != DstSel(4)) {
+					log_unsupported_vertex_swizzle(swizzle, DstSel(4));
+				}
+				break;
+			}
+			case 2: {
+				auto swizzle  = vs_input_info.resources[index].DstSelXY();
+				auto expected = (attr_size == 1 ? DstSel(4, 0) : DstSel(4, 5));
+				if (swizzle != expected) {
+					log_unsupported_vertex_swizzle(swizzle, expected);
+				}
+				break;
+			}
+			case 3: {
+				auto swizzle  = vs_input_info.resources[index].DstSelXYZ();
+				auto expected = DstSel(4, 5, 6);
+				switch (attr_size) {
+					case 1: expected = DstSel(4, 0, 0); break;
+					case 2: expected = DstSel(4, 5, 0); break;
+					default: break;
+				}
+				if (swizzle != expected) {
+					log_unsupported_vertex_swizzle(swizzle, expected);
+				}
+				break;
+			}
+			case 4: {
+				auto swizzle   = vs_input_info.resources[index].DstSelXYZW();
+				auto expected  = DstSel(4, 5, 6, 7);
+				bool supported = false;
+				switch (attr_size) {
+					case 1:
+						expected  = DstSel(4, 0, 0, 1);
+						supported = (swizzle == expected);
+						break;
+					case 2:
+						expected  = DstSel(4, 5, 0, 1);
+						supported = (swizzle == expected);
+						break;
+					case 3:
+						expected  = DstSel(4, 5, 6, 1);
+						supported = (swizzle == expected || swizzle == DstSel(4, 5, 6, 0));
+						break;
+					default:
+						supported = (swizzle == expected || swizzle == DstSel(4, 5, 6, 1) ||
+						             swizzle == DstSel(4, 5, 6, 0));
+						break;
+				}
+				if (!supported) {
+					log_unsupported_vertex_swizzle(swizzle, expected);
+				}
+				break;
+			}
+			default: EXIT("invalid registers_num");
 		}
 	}
 
@@ -641,9 +637,9 @@ void CreatePipelineInternal(
 	vertex_input_info.sType = vk::StructureType::ePipelineVertexInputStateCreateInfo;
 	vertex_input_info.pNext = nullptr;
 	vertex_input_info.flags = {};
-	vertex_input_info.vertexBindingDescriptionCount   = vs_input_info.buffers_num;
+	vertex_input_info.vertexBindingDescriptionCount   = vertex_input.binding_count;
 	vertex_input_info.pVertexBindingDescriptions      = input_desc;
-	vertex_input_info.vertexAttributeDescriptionCount = vs_input_info.resources_num;
+	vertex_input_info.vertexAttributeDescriptionCount = vertex_input.attribute_count;
 	vertex_input_info.pVertexAttributeDescriptions    = input_attr;
 
 	vk::PipelineInputAssemblyStateCreateInfo input_assembly {};
@@ -792,15 +788,11 @@ void CreatePipelineInternal(
 #else
 	color_blending.pNext = &color_write;
 #endif
-	color_blending.flags             = {};
-	color_blending.logicOpEnable     = VK_FALSE;
-	color_blending.logicOp           = vk::LogicOp::eCopy;
-	color_blending.attachmentCount   = static_params.color_count;
-	color_blending.pAttachments      = color_blend_attachment;
-	color_blending.blendConstants[0] = static_params.blend_color_red;
-	color_blending.blendConstants[1] = static_params.blend_color_green;
-	color_blending.blendConstants[2] = static_params.blend_color_blue;
-	color_blending.blendConstants[3] = static_params.blend_color_alpha;
+	color_blending.flags           = {};
+	color_blending.logicOpEnable   = VK_FALSE;
+	color_blending.logicOp         = vk::LogicOp::eCopy;
+	color_blending.attachmentCount = static_params.color_count;
+	color_blending.pAttachments    = color_blend_attachment;
 
 	EXIT_IF(!vs_input_info.stage);
 	std::vector<vk::DescriptorSetLayoutBinding> descriptor_bindings;
@@ -814,8 +806,8 @@ void CreatePipelineInternal(
 	CreateDescriptorLayout(graphics, pipeline, descriptor_bindings);
 	constexpr auto GraphicsStages =
 	    vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment;
-	const vk::PushConstantRange push_constants {
-	    GraphicsStages, 0, ShaderRecompiler::IR::NativePushConstantSize};
+	const vk::PushConstantRange push_constants {GraphicsStages, 0,
+	                                            ShaderRecompiler::IR::NativePushConstantSize};
 
 	vk::PipelineLayoutCreateInfo pipeline_layout_info {};
 	pipeline_layout_info.sType                  = vk::StructureType::ePipelineLayoutCreateInfo;
@@ -877,6 +869,7 @@ void CreatePipelineInternal(
 	    vk::DynamicState::eStencilCompareMask,
 	    vk::DynamicState::eStencilReference,
 	    vk::DynamicState::eStencilWriteMask,
+	    vk::DynamicState::eBlendConstants,
 #if !defined(__APPLE__)
 	    // Keep last so depth-only pipelines can omit this dynamic state.
 	    vk::DynamicState::eColorWriteEnableEXT, // unsupported by MoltenVK; static mask instead

src/graphics/host_gpu/renderer/render.h

@@ -190,8 +190,6 @@ private:
 	std::vector<vk::DescriptorImageInfo>  m_descriptor_images;
 	std::vector<vk::WriteDescriptorSet>   m_descriptor_writes;
 	std::vector<uint32_t>                 m_image_occurrences;
-	std::array<uint32_t, ShaderRecompiler::IR::NativePushConstantSize / sizeof(uint32_t)>
-	    m_push_constants {};
 
 	friend struct RenderExecutorTestAccess;
 };

src/graphics/host_gpu/renderer/renderCompute.cpp

@@ -46,7 +46,7 @@ static uint64_t BufferDescriptorSize(const ShaderBufferResource& descriptor) {
 bool RenderExecutor::TryConsumeComputeMetaClear(const ShaderComputeInputInfo& input,
                                                 const CommandBuffer&          buffer) {
 	const auto& program   = *input.stage.program;
-	const auto& resources = *input.stage.resources;
+	const auto& resources = input.stage.resources;
 	if (resources.buffers.size() != program.info.buffers.size()) {
 		EXIT("compute runtime buffer count does not match shader metadata\n");
 	}
@@ -81,7 +81,7 @@ bool ResolveComputeImageClear(const ShaderComputeInputInfo& input, uint32_t grou
                               ShaderBufferResource& resolved_descriptor, uint32_t& resolved_clear,
                               uint64_t& resolved_size) {
 	const auto& program   = *input.stage.program;
-	const auto& resources = *input.stage.resources;
+	const auto& resources = input.stage.resources;
 	if (program.info.buffers.size() != 1 || resources.buffers.size() != 1 ||
 	    !program.info.images.empty() || !program.info.samplers.empty() || program.info.uses_dma ||
 	    !resources.images.empty() || !resources.samplers.empty()) {
@@ -224,7 +224,7 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 	const bool     large_workgroup =
 	    (input_info.threads_num[0] * input_info.threads_num[1] * input_info.threads_num[2] >= 512);
 	const auto& program   = *input_info.stage.program;
-	const auto& resources = *input_info.stage.resources;
+	const auto& resources = input_info.stage.resources;
 	if (TryConsumeComputeMetaClear(input_info, buffer)) {
 		ResetBindings();
 		return;
@@ -236,8 +236,7 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 	}
 	const auto sampled_images = std::count_if(
 	    program.info.images.begin(), program.info.images.end(), [](const auto& image) {
-		    return image.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-		           image.kind == ShaderRecompiler::IR::ResourceKind::ImageUint;
+		    return image.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled;
 	    });
 	const bool                   has_sampler = !program.info.samplers.empty();
 	static std::atomic<uint32_t> dispatch_log_count {0};
@@ -250,7 +249,10 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 		     thread_group_z, mode, input_info.threads_num[0], input_info.threads_num[1],
 		     input_info.threads_num[2], program.info.buffers.size(), program.info.images.size(),
 		     sampled_images, program.info.images.size() - sampled_images,
-		     program.info.samplers.size(), program.bindings.push_constant_size);
+		     program.info.samplers.size(),
+		     program.bindings.UsesPushData()
+		         ? static_cast<uint32_t>(sizeof(ShaderRecompiler::IR::PushData))
+		         : 0u);
 		for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
 			const auto& buffer = program.info.buffers[i];
 			const auto  r      = DecodeNativeDescriptor<ShaderBufferResource>(resources.buffers[i]);
@@ -265,8 +267,7 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 			LOGF("  CS texture[%u]: source=%u usage=%s sampled=%s addr=0x%010" PRIx64
 			     " type=%u fmt=%u extent=%ux%u depth=%u levels=%u tile=%u\n",
 			     i, image.source, image.written ? "read-write" : "read-only",
-			     (image.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-			      image.kind == ShaderRecompiler::IR::ResourceKind::ImageUint)
+			     image.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled
 			         ? "true"
 			         : "false",
 			     r.Base40(), static_cast<uint32_t>(r.Type()), static_cast<uint32_t>(r.Format()),
@@ -347,8 +348,8 @@ void RenderExecutor::DispatchDirect(uint64_t submit_id, CommandBuffer& buffer,
 	    std::any_of(program.info.images.begin(), program.info.images.end(),
 	                [](const auto& image) {
 		                return image.written &&
-		                       (image.kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
-		                        image.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint);
+		                       image.resource_class ==
+		                           ShaderRecompiler::IR::ImageResourceClass::Storage;
 	                }) ||
 	    has_storage_writes;
 	if (has_storage_writes) {

src/graphics/host_gpu/renderer/renderDraw.cpp

@@ -52,7 +52,7 @@ int32_t ResolveVertexOffset(uint32_t index_offset, const ShaderVertexInputInfo&
 
 	EXIT_IF(!vs_input_info.stage);
 	const auto& program   = *vs_input_info.stage.program;
-	const auto& resources = *vs_input_info.stage.resources;
+	const auto& resources = vs_input_info.stage.resources;
 	if (program.info.vertex_offset_sgpr >= static_cast<int32_t>(program.user_data_base)) {
 		const auto index =
 		    static_cast<uint32_t>(program.info.vertex_offset_sgpr) - program.user_data_base;
@@ -199,8 +199,7 @@ static void LogDrawTargetState(const char* draw_name, const RenderColorInfo& col
 	const auto& ps_resources   = ps_input_info.stage.program->info;
 	const auto  sampled_images = std::count_if(
 	    ps_resources.images.begin(), ps_resources.images.end(), [](const auto& image) {
-		    return image.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-		           image.kind == ShaderRecompiler::IR::ResourceKind::ImageUint;
+		    return image.resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled;
 	    });
 
 	vk::Extent2D extent = color.image_id ? color.extent : vk::Extent2D {};
@@ -365,6 +364,9 @@ static void SetGraphicsDynamicParams(const CommandBuffer& buffer, vk::CommandBuf
 		line_width = 1.0f;
 	}
 	vk_buffer.setLineWidth(line_width);
+	const auto&      blend = ctx.GetBlendColor();
+	const std::array blend_constants {blend.red, blend.green, blend.blue, blend.alpha};
+	vk_buffer.setBlendConstants(blend_constants.data());
 
 	const auto& mode              = ctx.GetModeControl();
 	const auto& poly_offset       = ctx.GetPolyOffset();
@@ -496,8 +498,7 @@ struct DrawRenderState {
 	RenderState           rendering;
 	ShaderVertexInputInfo vs_input_info;
 	ShaderPixelInputInfo  ps_input_info;
-	ShaderProgram         vertex_program;
-	ShaderProgram         pixel_program;
+	PipelineCache::GraphicsPrograms programs;
 };
 
 struct DrawCallInfo {
@@ -1009,30 +1010,20 @@ static void RefreshShaders(CommandBuffer& buffer, const DrawCallInfo& draw, bool
 	const auto& pixel_shader_info  = sh_ctx.GetPs();
 	const auto& shader_regs        = ctx.GetShaderRegisters();
 
-	state.vertex_program = {};
-	state.pixel_program  = {};
-	state.ps_input_info  = {};
+	state.programs      = {};
+	state.ps_input_info = {};
 	std::array<Prospero::ColorComponentMapping, RENDER_COLOR_ATTACHMENTS_MAX>
 	    target_export_mapping {};
 	for (uint32_t i = 0; i < state.color_count; i++) {
 		target_export_mapping[state.color_info[i].target_slot] = state.color_info[i].export_mapping;
 	}
-	if (log_phases) {
-		LogDrawPhase(draw.name, "GetVertexProgram");
-	}
 	auto& pipeline_cache = buffer.GetContext().GetPipelineCache();
-	state.vertex_program = pipeline_cache.GetVertexProgram(vertex_shader_info, shader_regs, ctx,
-	                                                         state.vs_input_info);
-
-	if (!state.ps_active) {
-		return;
-	}
 	if (log_phases) {
-		LogDrawPhase(draw.name, "GetPixelProgram");
+		LogDrawPhase(draw.name, "GetGraphicsPrograms");
 	}
-	state.pixel_program =
-	    pipeline_cache.GetPixelProgram(pixel_shader_info, shader_regs, state.vs_input_info,
-	                                   target_export_mapping, state.ps_input_info);
+	state.programs = pipeline_cache.GetGraphicsPrograms(
+	    vertex_shader_info, pixel_shader_info, shader_regs, ctx, target_export_mapping,
+	    state.ps_active, state.vs_input_info, state.ps_input_info);
 }
 
 static PreparedVertexBuffers PrepareVertexBuffers(uint64_t submit_id, CommandBuffer& buffer,
@@ -1186,7 +1177,7 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, CommandBuffer& buff
 	auto& pipeline = m_context.GetPipelineCache().CreateGraphicsPipeline(
 	    std::span {state.color_info, state.color_count}, state.depth_info, state.vs_input_info, buffer,
 	    state.ps_active ? &state.ps_input_info : nullptr, topology, primitive_restart_enable,
-	    state.vertex_program, state.pixel_program);
+	    state.programs.vertex, state.programs.pixel);
 
 	// Resource preparation above may synchronously finish and restart the scheduler. From this
 	// point onward, every operation targets the current command buffer and cannot touch guest
@@ -1453,7 +1444,8 @@ void RenderExecutor::DrawAuto(uint64_t submit_id, CommandBuffer& buffer, uint32_
 
 	const bool rect_list = topology == vk::PrimitiveTopology::ePatchList;
 	if (rect_list && state.vs_input_info.buffers_num == 0 &&
-	    state.vs_input_info.param_export_mask == 0 && state.ps_input_info.input_num != 0) {
+	    state.vs_input_info.stage.program->param_export_mask == 0 &&
+	    state.ps_input_info.input_num != 0) {
 		if (graphics_debug_dump_enabled()) {
 			LOGF("DrawIndexAuto: skipping rect-list draw with no VS param exports and PS inputs: "
 			     "ps_inputs=%u ps=0x%016" PRIx64 " es=0x%016" PRIx64 " gs=0x%016" PRIx64 "\n",

src/graphics/presentation/imeOverlay.cpp

@@ -209,7 +209,7 @@ void RefreshVisibility() {
 	}
 	const bool was_controller = std::exchange(g_controller_captured, capture_controller);
 	if (capture_controller || was_controller) {
-		Controller::ControllerResetInputState();
+		Controller::ResetInputState();
 	}
 	g_active = visible;
 
@@ -404,7 +404,7 @@ void ShutdownImeInput() {
 		g_input_lifecycle_active = false;
 		g_active                 = false;
 		if (std::exchange(g_controller_captured, false)) {
-			Controller::ControllerResetInputState();
+			Controller::ResetInputState();
 		}
 		g_visibility_event.store(static_cast<Uint32>(-1), std::memory_order_release);
 	}

src/graphics/presentation/window/hostInput.cpp

@@ -194,18 +194,18 @@ const InputMap& GetInputMap() {
 
 void SetButton(uint32_t button, bool down) {
 	if (button == Controller::PAD_BUTTON_L2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerLeft, down ? 255 : 0);
+		Controller::SetAxis(Controller::HOST_INPUT_CONTROLLER_ID, Controller::Axis::TriggerLeft,
+		                    down ? 255 : 0);
 	} else if (button == Controller::PAD_BUTTON_R2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerRight, down ? 255 : 0);
+		Controller::SetAxis(Controller::HOST_INPUT_CONTROLLER_ID, Controller::Axis::TriggerRight,
+		                    down ? 255 : 0);
 	} else if (button != 0) {
-		Controller::ControllerButton(Controller::HOST_INPUT_CONTROLLER_ID, button, down);
+		Controller::SetButton(Controller::HOST_INPUT_CONTROLLER_ID, button, down);
 	}
 }
 
 void SetTouchPad(float x, bool down) {
-	Controller::ControllerTouchPad(Controller::HOST_INPUT_CONTROLLER_ID, 0, down, x, 0.5f);
+	Controller::SetTouchPad(Controller::HOST_INPUT_CONTROLLER_ID, 0, down, x, 0.5f);
 }
 
 uint32_t DefaultKeyboardButton(int key_code) {
@@ -242,7 +242,7 @@ void SetStickAxis(Controller::Axis axis, bool negative, bool positive) {
 	} else if (positive && !negative) {
 		value = 255;
 	}
-	Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID, axis, value);
+	Controller::SetAxis(Controller::HOST_INPUT_CONTROLLER_ID, axis, value);
 }
 
 void SetControl(std::size_t control, bool down) {
@@ -326,15 +326,15 @@ void MouseToJoystick(int delta_x, int delta_y) {
 	const auto map_axis = [scale](int delta) {
 		return std::clamp(128 + static_cast<int>(std::lround(delta * scale)), 0, 255);
 	};
-	Controller::ControllerRightStick(Controller::HOST_INPUT_CONTROLLER_ID, map_axis(delta_x),
-	                                 map_axis(delta_y));
+	Controller::SetRightStick(Controller::HOST_INPUT_CONTROLLER_ID, map_axis(delta_x),
+	                          map_axis(delta_y));
 }
 
 void CenterMouseStick() {
 	if (!g_mouse.output) {
 		return;
 	}
-	Controller::ControllerRightStick(Controller::HOST_INPUT_CONTROLLER_ID, 128, 128);
+	Controller::SetRightStick(Controller::HOST_INPUT_CONTROLLER_ID, 128, 128);
 	g_mouse.output = false;
 }
 

src/graphics/presentation/window/window.cpp

@@ -351,26 +351,26 @@ static void GameEventController([[maybe_unused]] const EventController& f) {
 		auto* pad = SDL_GameControllerOpen(f.id);
 		EXIT_NOT_IMPLEMENTED(pad == nullptr);
 		int id = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(pad));
-		Controller::ControllerConnect(id);
+		Controller::Connect(id);
 	}
 
 	if (f.removed) {
-		Controller::ControllerDisconnect(f.id);
+		Controller::Disconnect(f.id);
 		SDL_GameControllerClose(SDL_GameControllerFromInstanceID(f.id));
 	}
 
 	if (f.down || f.up) {
 		const auto button = ControllerButtonToPadButton(f.button);
 		if (button != 0) {
-			Controller::ControllerButton(f.id, button, f.down);
+			Controller::SetButton(f.id, button, f.down);
 		}
 	}
 
 	if (f.axis) {
 		const auto axis = ControllerAxisFromSdl(f.axis_id);
 		if (axis != Controller::Axis::AxisMax) {
-			Controller::ControllerAxis(f.id, axis,
-			                           ControllerAxisValueFromSdl(f.axis_id, f.axis_value));
+			Controller::SetAxis(f.id, axis,
+			                    ControllerAxisValueFromSdl(f.axis_id, f.axis_value));
 		}
 	}
 }
@@ -708,9 +708,9 @@ void WindowContext::ProcessEvent(double time_s) {
 		case SDL_CONTROLLERTOUCHPADMOTION:
 		case SDL_CONTROLLERTOUCHPADUP:
 			if (event->ctouchpad.touchpad == 0) {
-				Controller::ControllerTouchPad(event->ctouchpad.which, event->ctouchpad.finger,
-				                               event->ctouchpad.type != SDL_CONTROLLERTOUCHPADUP,
-				                               event->ctouchpad.x, event->ctouchpad.y);
+				Controller::SetTouchPad(event->ctouchpad.which, event->ctouchpad.finger,
+				                        event->ctouchpad.type != SDL_CONTROLLERTOUCHPADUP,
+				                        event->ctouchpad.x, event->ctouchpad.y);
 			}
 			break;
 
@@ -814,6 +814,7 @@ static void WindowCreate(WindowContext& context) {
 	int width  = static_cast<int>(context.graphic_ctx.screen_width);
 	int height = static_cast<int>(context.graphic_ctx.screen_height);
 
+	SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	SDL_SetHint(SDL_HINT_WINDOWS_DPI_SCALING, "0");
 #endif

src/graphics/shader/recompiler/ShaderRecompiler.cpp

@@ -34,9 +34,9 @@ const char* GetDumpLabel(const CompileOptions& options) {
 	return options.dump_label != nullptr ? options.dump_label : "ShaderRecompiler";
 }
 
-std::string MakeIrDump(const CFG::Graph& cfg, const IR::Program& ir) {
+std::string MakeIrDump(std::string_view cfg, const IR::Program& ir) {
 	std::string dump = "CFG:\n";
-	dump += CFG::GraphToString(cfg);
+	dump += cfg;
 	dump += "\nIR:\n";
 	dump += fmt::format("mode={} scratch_dwords={}\n",
 	                    ir.dispatcher_fallback ? "dispatcher" : "structured", ir.scratch_dwords);
@@ -464,7 +464,7 @@ EmbeddedFetchData DetectEmbeddedVertexFetch(const Decoder::Program&      decoded
 
 } // namespace
 
-CompileResult Recompile(std::span<const uint32_t> code, const CompileOptions& options) {
+TranslateResult TranslateProgram(std::span<const uint32_t> code, const CompileOptions& options) {
 	if (code.empty()) {
 		EXIT("shader recompiler input is empty\n");
 	}
@@ -618,30 +618,42 @@ CompileResult Recompile(std::span<const uint32_t> code, const CompileOptions& op
 		ir.info.vertex_offset_sgpr = embedded_fetch.vertex_offset_sgpr;
 	}
 
-	const IR::SrtRuntime runtime {
-	    .user_data                  = options.user_data,
-	    .shader_base                = reinterpret_cast<uint64_t>(code.data()),
-	    .read_memory                = options.read_memory,
-	    .userdata                   = options.read_memory_data,
-	    .read_specialization_memory = options.read_specialization_memory,
-	};
-	IR::ResourceSnapshot resources;
-	if (!IR::MaterializeResources(ir, runtime, resources)) {
-		EXIT("shader resource materialization failed: stage=%s hash=0x%016" PRIx64 "\n",
-		     StageName(options.stage), options.shader_hash);
+	TranslateResult result;
+	result.program = std::move(ir);
+	if (options.dump_ir) {
+		result.decoded_dump = std::move(decoded_dump);
+		result.cfg_dump     = CFG::GraphToString(cfg);
+	}
+	return result;
+}
+
+CompileResult CompileProgram(TranslateResult translated, const CompileOptions& options,
+                             const IR::ResourceSpecialization& specialization,
+                             uint32_t push_data_start_dword) {
+	const auto emit_begin = std::chrono::steady_clock::now();
+	auto& ir = translated.program;
+	IR::ApplyResourceSpecialization(ir, specialization);
+
+	const ShaderVertexInputInfo*  vertex  = nullptr;
+	const ShaderPixelInputInfo*   pixel   = nullptr;
+	const ShaderComputeInputInfo* compute = nullptr;
+	switch (options.stage) {
+		case ShaderType::Vertex: vertex = options.input_info.vertex; break;
+		case ShaderType::Pixel: pixel = options.input_info.pixel; break;
+		case ShaderType::Compute: compute = options.input_info.compute; break;
+		default: EXIT("invalid shader stage\n");
 	}
-	IR::SpecializeResources(ir, resources);
 
 	IR::ShaderInfoOptions info_options;
 	info_options.vertex  = vertex;
 	info_options.pixel   = pixel;
 	info_options.compute = compute;
 	IR::CollectShaderInfo(ir, info_options);
-	IR::AllocateBindings(ir, options.push_constant_offset);
+	IR::AllocateBindings(ir, push_data_start_dword);
 	Spirv::AnalyzeProgramRequirements(ir);
 	std::string ir_dump;
 	if (options.dump_ir) {
-		ir_dump = MakeIrDump(cfg, ir);
+		ir_dump = MakeIrDump(translated.cfg_dump, ir);
 		if (options.early_dump) {
 			LOGF("%s native IR and bindings (early):\n%s", GetDumpLabel(options), ir_dump.c_str());
 		}
@@ -649,17 +661,19 @@ CompileResult Recompile(std::span<const uint32_t> code, const CompileOptions& op
 
 	LOGF("%s phase begin: stage=%s hash=0x%016" PRIx64 " SPIR-V EmitProgram\n",
 	     GetDumpLabel(options), StageName(options.stage), options.shader_hash);
-	auto spirv = Spirv::EmitProgram(ir, resources, options.input_info);
+	auto spirv = Spirv::EmitProgram(ir, options.input_info);
 	LOGF("%s phase end: stage=%s hash=0x%016" PRIx64 " SPIR-V EmitProgram words=%" PRIu64
 	     " elapsed_ms=%" PRIu64 "\n",
 	     GetDumpLabel(options), StageName(options.stage), options.shader_hash,
-	     static_cast<uint64_t>(spirv.size()), phase_ms());
+	     static_cast<uint64_t>(spirv.size()),
+	     static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
+	                               std::chrono::steady_clock::now() - emit_begin)
+	                               .count()));
 	CompileResult result;
-	result.spirv     = std::move(spirv);
-	result.program   = std::move(ir);
-	result.resources = std::move(resources);
+	result.spirv   = std::move(spirv);
+	result.program = std::move(ir);
 	if (options.dump_ir) {
-		result.decoded_dump = std::move(decoded_dump);
+		result.decoded_dump = std::move(translated.decoded_dump);
 		result.ir_dump      = std::move(ir_dump);
 	}
 	return result;

src/graphics/shader/recompiler/ShaderRecompiler.h

@@ -17,27 +17,32 @@ struct CompileOptions {
 	uint32_t                    user_data_base  = 0;
 	uint32_t                    scratch_dwords  = 0;
 	uint64_t                    shader_hash     = 0;
-	uint32_t                    push_constant_offset      = 0;
 	bool                        dump_ir                    = true;
 	bool                        early_dump                 = false;
 	const char*                 dump_label                 = nullptr;
 	std::span<const uint32_t>   user_data;
-	IR::SrtMemoryReader         read_memory                = nullptr;
-	IR::SrtMemoryReader         read_specialization_memory = nullptr;
-	void*                       read_memory_data           = nullptr;
 	ShaderStageInputInfo        input_info;
 };
 
-struct CompileResult {
-	std::vector<uint32_t> spirv;
-	std::string           decoded_dump;
-	std::string           ir_dump;
-	IR::Program           program;
-	IR::ResourceSnapshot  resources;
+struct TranslateResult {
+	IR::Program program;
+	std::string decoded_dump;
+	std::string cfg_dump;
 };
 
-[[nodiscard]] CompileResult Recompile(std::span<const uint32_t> code,
-                                      const CompileOptions& options);
+struct CompileResult {
+	std::vector<uint32_t>  spirv;
+	std::string            decoded_dump;
+	std::string            ir_dump;
+	IR::Program            program;
+};
+
+[[nodiscard]] TranslateResult TranslateProgram(std::span<const uint32_t> code,
+                                               const CompileOptions& options);
+[[nodiscard]] CompileResult CompileProgram(TranslateResult translated,
+                                           const CompileOptions& options,
+                                           const IR::ResourceSpecialization& specialization,
+	                                       uint32_t push_data_start_dword = 0);
 
 } // namespace Libs::Graphics::ShaderRecompiler
 

src/graphics/shader/recompiler/backend/spirv/SpirvEmitter.cpp

@@ -81,13 +81,13 @@ void ValidateNativeProgram(const IR::Program& program) {
 	const bool uses_flattened_runtime =
 	    !program.srt_reads.empty() ||
 	     std::ranges::any_of(program.info.images, [](const IR::ImageResource& image) {
-		     return image.indirect_mapping_capacity != 0u;
+		     return image.indirect_search_iterations != 0u;
 	     });
 	if (uses_flattened_runtime) {
 		Expect(Kind::FlattenedSrt);
 	}
-	if (program.bindings.ShaderDataDwords() != 0 && program.bindings.push_constant_size == 0) {
-		Expect(Kind::UserData);
+	if (program.bindings.ShaderDataDwords() != 0 && !program.bindings.UsesPushData()) {
+		Expect(Kind::ShaderData);
 	}
 
 	std::array<bool, KindCount> seen {};
@@ -104,21 +104,19 @@ void ValidateNativeProgram(const IR::Program& program) {
 			Fail(program, "native shader plan is missing a required descriptor group");
 		}
 	}
-	const auto has_user_storage = present[static_cast<size_t>(Kind::UserData)];
-	if (program.bindings.push_constant_offset % sizeof(uint32_t) != 0 ||
-	    program.bindings.push_constant_offset + program.bindings.push_constant_size >
-	        IR::NativePushConstantSize ||
+	const auto has_shader_data_storage = present[static_cast<size_t>(Kind::ShaderData)];
+	const auto shader_data_dwords = program.bindings.ShaderDataDwords();
+	if ((program.bindings.UsesPushData() &&
+	     !IR::PushData::CanFit(program.bindings.push_data_start_dword, shader_data_dwords)) ||
 	    program.bindings.memory_offset_dword != program.bindings.user_data_registers.size() ||
 	    program.bindings.memory_offset_count != program.info.buffers.size() ||
-	    (!has_user_storage &&
-	     program.bindings.push_constant_size != program.bindings.ShaderDataDwords() * 4u) ||
-	    (has_user_storage && program.bindings.push_constant_size != 0) ||
+	    has_shader_data_storage != (shader_data_dwords != 0 && !program.bindings.UsesPushData()) ||
 	    !std::is_sorted(program.bindings.user_data_registers.begin(),
 	                    program.bindings.user_data_registers.end()) ||
 	    std::adjacent_find(program.bindings.user_data_registers.begin(),
 	                       program.bindings.user_data_registers.end()) !=
 	        program.bindings.user_data_registers.end()) {
-		Fail(program, "native user-data layout is inconsistent");
+		Fail(program, "native shader-data layout is inconsistent");
 	}
 
 	const auto planning_only_handle = [&](const IR::Inst& handle) {
@@ -302,7 +300,6 @@ void AnalyzeProgramRequirements(IR::Program& program) {
 }
 
 std::vector<uint32_t> EmitProgram(const IR::Program& program,
-                                  const IR::ResourceSnapshot& resources,
                                   ShaderStageInputInfo input_info) {
 	using namespace Emitter;
 
@@ -315,15 +312,9 @@ std::vector<uint32_t> EmitProgram(const IR::Program& program,
 	    !program.spirv_requirements.has_value()) {
 		Fail(program, "SPIR-V emitter requires a fully planned native shader program");
 	}
-	if (!IR::ValidateResourceSnapshot(program, resources)) {
-		Fail(program, "resource snapshot is inconsistent with the native shader plan");
-	}
-	if (!IR::ValidateResourceSpecialization(program, resources)) {
-		Fail(program, "resource specialization is inconsistent with the native shader plan");
-	}
 	ValidateNativeProgram(program);
 	IR::ValidateProgram(program, true);
-	EmitterState state(program, resources, input_info);
+	EmitterState state(program, input_info);
 	state.stage     = program.stage;
 	state.wave_size = program.wave_size;
 	state.inputs.reserve(program.info.inputs.size());

src/graphics/shader/recompiler/backend/spirv/SpirvEmitter.h

@@ -3,7 +3,7 @@
 
 #include "common/common.h"
 #include "common/stringUtils.h"
-#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
+#include "graphics/shader/recompiler/ir/ShaderIR.h"
 
 #include <vector>
 
@@ -12,7 +12,6 @@ namespace Libs::Graphics::ShaderRecompiler::Spirv {
 void AnalyzeProgramRequirements(IR::Program& program);
 
 std::vector<uint32_t> EmitProgram(const IR::Program& program,
-                                  const IR::ResourceSnapshot& resources,
                                   ShaderStageInputInfo input_info);
 
 } // namespace Libs::Graphics::ShaderRecompiler::Spirv

src/graphics/shader/recompiler/backend/spirv/spirvEmitterAnalysis.cpp

@@ -86,8 +86,8 @@ uint32_t          ConstantU32(EmitterState& state, uint32_t value);
 	std::abort();
 }
 
-DescriptorResourceBinding ResourceForDescriptor(const EmitterState&       state,
-                                                IR::DescriptorBindingKind kind, uint32_t resource) {
+uint32_t ResourceForDescriptor(const EmitterState& state, IR::DescriptorBindingKind kind,
+                               uint32_t resource) {
 	const auto* descriptor = IR::FindBinding(state.program.bindings, kind);
 	if (descriptor == nullptr) {
 		ExitDescriptorBindingFailure(state, kind, resource, "descriptor group was not allocated");
@@ -98,7 +98,7 @@ DescriptorResourceBinding ResourceForDescriptor(const EmitterState&       state,
 		ExitDescriptorBindingFailure(state, kind, resource,
 		                             "resource is absent from descriptor group");
 	}
-	return {descriptor, static_cast<uint32_t>(found - descriptor->resources.begin())};
+	return static_cast<uint32_t>(found - descriptor->resources.begin());
 }
 
 uint32_t DescriptorElementPointer(EmitterState& state, uint32_t result_ptr_type,
@@ -114,68 +114,56 @@ uint32_t DescriptorElementPointer(EmitterState& state, uint32_t result_ptr_type,
 	return pointer;
 }
 
-ImageViewKind ImageViewKindFromDimension(Decoder::ImageDimension dimension) {
-	switch (dimension) {
-		case Decoder::ImageDimension::Dim1D: return ImageViewKind::Dim1D;
-		case Decoder::ImageDimension::Dim1DArray: return ImageViewKind::Dim1DArray;
-		case Decoder::ImageDimension::Dim2DArray: return ImageViewKind::Dim2DArray;
-		case Decoder::ImageDimension::Dim3D: return ImageViewKind::Dim3D;
-		case Decoder::ImageDimension::Dim2DMsaa: return ImageViewKind::Dim2DMsaa;
-		case Decoder::ImageDimension::Dim2DMsaaArray: return ImageViewKind::Dim2DMsaaArray;
-		default: return ImageViewKind::Dim2D;
+const ImageDimensionInfo& ImageDimensionInfoFor(ImageDimension dimension) {
+	for (const auto& info: ImageDimensions) {
+		if (info.dimension == dimension) {
+			return info;
+		}
 	}
+	EXIT("SPIR-V image dimension %u is invalid\n", static_cast<uint32_t>(dimension));
+	std::abort();
 }
 
-ImageViewKind SampledImageViewKind(const EmitterState& state, const IR::MemoryInfo& mem,
-                                   uint32_t use_pc) {
-	(void)state;
-	(void)use_pc;
-	return ImageViewKindFromDimension(mem.image_dimension);
-}
-
-ImageViewKind StorageImageViewKind(const IR::MemoryInfo& mem) {
-	return ImageViewKindFromDimension(mem.image_dimension);
-}
-
-uint32_t ImageViewCoordinateComponents(ImageViewKind view) {
-	switch (view) {
-		case ImageViewKind::Dim1D: return 1u;
-		case ImageViewKind::Dim1DArray:
-		case ImageViewKind::Dim2D: return 2u;
-		case ImageViewKind::Dim2DArray:
-		case ImageViewKind::Dim2DMsaaArray:
-		case ImageViewKind::Dim3D: return 3u;
-		case ImageViewKind::Dim2DMsaa: return 2u;
-		default: return 0u;
+uint32_t ImageScalarType(EmitterState& state, Prospero::TextureNumericClass numeric_class) {
+	switch (numeric_class) {
+		case Prospero::TextureNumericClass::Float: return TypeF32(state);
+		case Prospero::TextureNumericClass::Uint: return TypeU32(state);
+		case Prospero::TextureNumericClass::Sint: return TypeI32(state);
+		case Prospero::TextureNumericClass::Unsupported: break;
 	}
+	EXIT("invalid image numeric class");
 }
 
-uint32_t ImageViewSpatialComponents(ImageViewKind view) {
-	switch (view) {
-		case ImageViewKind::Dim1D:
-		case ImageViewKind::Dim1DArray: return 1u;
-		case ImageViewKind::Dim2D:
-		case ImageViewKind::Dim2DArray:
-		case ImageViewKind::Dim2DMsaa:
-		case ImageViewKind::Dim2DMsaaArray: return 2u;
-		case ImageViewKind::Dim3D: return 3u;
-		default: return 0u;
+uint32_t ImageVectorType(EmitterState& state, Prospero::TextureNumericClass numeric_class,
+                         uint32_t components) {
+	return state.builder.Type(OpTypeVector, {ImageScalarType(state, numeric_class), components});
+}
+
+uint32_t ImageType(EmitterState& state, const IR::ImageResource& image) {
+	uint32_t sampled = 0;
+	uint32_t format  = ImageFormatUnknown;
+	if (image.resource_class == IR::ImageResourceClass::Sampled) {
+		EXIT_IF(image.atomic);
+		sampled = 1;
+	} else if (image.resource_class == IR::ImageResourceClass::Storage) {
+		EXIT_IF(image.numeric_class == Prospero::TextureNumericClass::Sint ||
+		        image.numeric_class == Prospero::TextureNumericClass::Unsupported);
+		sampled = 2;
+		if (image.atomic) {
+			EXIT_IF(image.numeric_class != Prospero::TextureNumericClass::Uint);
+			format = ImageFormatR32ui;
+		}
+	} else {
+		EXIT("invalid image resource class");
 	}
-}
-
-uint32_t ImageViewImageType(EmitterState& state, ImageViewKind view, bool integer) {
-	const auto component = integer ? TypeU32(state) : TypeF32(state);
+	const auto& info = ImageDimensionInfoFor(image.dimension);
 	return state.builder.Type(OpTypeImage,
-	                          {component, ImageSpirvDimension(view), 0, ImageSpirvArrayed(view),
-	                           ImageSpirvMultisampled(view), 1, ImageFormatUnknown});
+	                          {ImageScalarType(state, image.numeric_class), info.spirv_dimension, 0,
+	                           info.arrayed, info.multisampled, sampled, format});
 }
 
-uint32_t ImageViewSampledImageType(EmitterState& state, ImageViewKind view, bool integer) {
-	return state.builder.Type(OpTypeSampledImage, {ImageViewImageType(state, view, integer)});
-}
-
-uint32_t ImageViewSizeType(EmitterState& state, ImageViewKind view) {
-	switch (ImageViewCoordinateComponents(view)) {
+uint32_t ImageViewSizeType(EmitterState& state, ImageDimension dimension) {
+	switch (ImageDimensionInfoFor(dimension).coordinate_components) {
 		case 1u: return TypeU32(state);
 		case 2u: return TypeU32Vector(state, 2);
 		case 3u: return TypeU32Vector(state, 3);
@@ -183,128 +171,89 @@ uint32_t ImageViewSizeType(EmitterState& state, ImageViewKind view) {
 	}
 }
 
-uint32_t StorageImageType(EmitterState& state, StorageImageClass image_class, ImageViewKind view) {
-	uint32_t component = TypeF32(state);
-	uint32_t format    = ImageFormatUnknown;
-	if (image_class == StorageImageClass::FormatlessUint) {
-		component = TypeU32(state);
-	} else if (image_class == StorageImageClass::AtomicUint) {
-		component = TypeU32(state);
-		format    = ImageFormatR32ui;
-	}
-	return state.builder.Type(OpTypeImage, {component, ImageSpirvDimension(view), 0,
-	                                        ImageSpirvArrayed(view), 0, 2, format});
-}
-
-uint32_t StorageImagePointerType(EmitterState& state, StorageImageClass image_class,
-                                 ImageViewKind view) {
-	return state.builder.Type(
-	    OpTypePointer, {StorageClassUniformConstant, StorageImageType(state, image_class, view)});
-}
-
-StorageImageClass StorageImageClassForResource(const EmitterState& state, uint32_t resource) {
-	const auto& image      = state.program.info.images.at(resource);
-	const bool  uint_image = image.kind == IR::ResourceKind::StorageImageUint;
-	EXIT_IF(image.kind != IR::ResourceKind::StorageImage && !uint_image);
-	EXIT_IF(image.atomic && !uint_image);
-	return StorageImageClassFor(uint_image, image.atomic);
-}
-
-uint32_t StorageImageVariable(const EmitterState& state, StorageImageClass image_class,
-                              ImageViewKind view) {
-	return state.storage_image_variables[StorageImageIndex(image_class, view)];
-}
-
-uint32_t LoadSampledImageDescriptor(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                                    ImageViewKind view) {
-	(void)use_pc;
-	const bool integer      = mem.kind == IR::ResourceKind::ImageUint;
-	const auto kind         = SampledBindingKind(integer, view);
-	const auto binding      = ResourceForDescriptor(state, kind, mem.resource);
-	const auto variable     = state.sampled_image_variables[SampledImageIndex(integer, view)];
+uint32_t LoadSampledImageDescriptor(EmitterState& state, uint32_t resource) {
+	const auto& image_resource = state.program.info.images.at(resource);
+	EXIT_IF(image_resource.resource_class != IR::ImageResourceClass::Sampled);
+	const auto kind = IR::DescriptorBindingForImage(image_resource);
+	EXIT_IF(!kind.has_value());
+	const auto array_index  = ResourceForDescriptor(state, *kind, resource);
+	const auto variable     = state.image_variables[IR::ImageBindingIndex(*kind)];
 	const auto pointer_type = state.builder.Type(
-	    OpTypePointer, {StorageClassUniformConstant, ImageViewImageType(state, view, integer)});
+	    OpTypePointer, {StorageClassUniformConstant, ImageType(state, image_resource)});
 	const auto pointer =
-	    DescriptorElementPointer(state, pointer_type, variable, binding.array_index, kind,
-	                             mem.resource, "sampled image descriptor array was not emitted");
+	    DescriptorElementPointer(state, pointer_type, variable, array_index, *kind, resource,
+	                             "sampled image descriptor array was not emitted");
 	const auto image = state.builder.AllocateId();
-	state.builder.AddFunction({OpLoad, ImageViewImageType(state, view, integer), image, pointer});
+	state.builder.AddFunction({OpLoad, ImageType(state, image_resource), image, pointer});
 	return image;
 }
 
-uint32_t LoadSamplerDescriptor(EmitterState& state, uint32_t sampler, uint32_t use_pc) {
-	(void)use_pc;
-	const auto binding = ResourceForDescriptor(state, IR::DescriptorBindingKind::Samplers, sampler);
+uint32_t LoadSamplerDescriptor(EmitterState& state, uint32_t sampler) {
+	const auto array_index =
+	    ResourceForDescriptor(state, IR::DescriptorBindingKind::Samplers, sampler);
 	const auto sampler_type = state.builder.Type(OpTypeSampler);
 	const auto pointer_type =
 	    state.builder.Type(OpTypePointer, {StorageClassUniformConstant, sampler_type});
 	const auto pointer = DescriptorElementPointer(
-	    state, pointer_type, state.sampler_variable, binding.array_index,
+	    state, pointer_type, state.sampler_variable, array_index,
 	    IR::DescriptorBindingKind::Samplers, sampler, "sampler descriptor array was not emitted");
 	const auto sampler_id = state.builder.AllocateId();
 	state.builder.AddFunction({OpLoad, sampler_type, sampler_id, pointer});
 	return sampler_id;
 }
 
-uint32_t MakeSampledImage(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                          ImageViewKind view) {
-	const auto image   = LoadSampledImageDescriptor(state, mem, use_pc, view);
-	const auto sampler = LoadSamplerDescriptor(state, mem.sampler, use_pc);
-	if (image == 0 || sampler == 0) {
-		ExitDescriptorBindingFailure(
-		    state, SampledBindingKind(mem.kind == IR::ResourceKind::ImageUint, view), mem.resource,
-		    "sampled image or sampler descriptor load failed");
-	}
-	const auto sampled_image = state.builder.AllocateId();
-	state.builder.AddFunction(
-	    {OpSampledImage,
-	     ImageViewSampledImageType(state, view, mem.kind == IR::ResourceKind::ImageUint),
-	     sampled_image, image, sampler});
+uint32_t MakeSampledImage(EmitterState& state, uint32_t resource, uint32_t sampler) {
+	const auto& image_resource = state.program.info.images.at(resource);
+	const auto  image          = LoadSampledImageDescriptor(state, resource);
+	const auto  sampler_id     = LoadSamplerDescriptor(state, sampler);
+	const auto  sampled_image = state.builder.AllocateId();
+	const auto  sampled_type  =
+	    state.builder.Type(OpTypeSampledImage, {ImageType(state, image_resource)});
+	state.builder.AddFunction({OpSampledImage, sampled_type, sampled_image, image, sampler_id});
 	return sampled_image;
 }
 
-uint32_t MakeSampledImage(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                          ImageViewKind view, uint32_t image_resource) {
-	auto selected     = mem;
-	selected.resource = image_resource;
-	return MakeSampledImage(state, selected, use_pc, view);
-}
-
-uint32_t StorageImageDescriptorPointer(EmitterState& state, uint32_t resource, ImageViewKind view) {
-	const auto image_class = StorageImageClassForResource(state, resource);
-	const auto kind        = StorageBindingKind(image_class, view);
-	const auto binding  = ResourceForDescriptor(state, kind, resource);
-	const auto ptr_type    = StorageImagePointerType(state, image_class, view);
-	const auto variable    = StorageImageVariable(state, image_class, view);
-	return DescriptorElementPointer(state, ptr_type, variable, binding.array_index, kind, resource,
+uint32_t StorageImageDescriptorPointer(EmitterState& state, uint32_t resource) {
+	const auto& image = state.program.info.images.at(resource);
+	EXIT_IF(image.resource_class != IR::ImageResourceClass::Storage);
+	const auto kind = IR::DescriptorBindingForImage(image);
+	EXIT_IF(!kind.has_value());
+	const auto array_index = ResourceForDescriptor(state, *kind, resource);
+	const auto pointer_type =
+	    state.builder.Type(OpTypePointer, {StorageClassUniformConstant, ImageType(state, image)});
+	const auto variable = state.image_variables[IR::ImageBindingIndex(*kind)];
+	return DescriptorElementPointer(state, pointer_type, variable, array_index, *kind, resource,
 	                                "storage image descriptor array was not emitted");
 }
 
-void EmitStorageImageWrite(EmitterState& state, uint32_t resource, ImageViewKind view,
-                           uint32_t mip_lod, uint32_t coord, uint32_t texel) {
-	const auto image_class = StorageImageClassForResource(state, resource);
-	if (image_class != StorageImageClass::AtomicUint) {
+void EmitStorageImageWrite(EmitterState& state, uint32_t resource, uint32_t mip_lod, uint32_t coord,
+                           uint32_t texel) {
+	const auto& image = state.program.info.images.at(resource);
+	EXIT_IF(image.resource_class != IR::ImageResourceClass::Storage);
+	if (!image.atomic) {
 		state.builder.RequireCapability(CapabilityStorageImageWriteWithoutFormat);
 	}
-	const auto  kind    = StorageBindingKind(image_class, view);
-	const auto  binding = ResourceForDescriptor(state, kind, resource);
-	const auto& image   = state.program.info.images.at(resource);
-	const auto  LoadAt  = [&](uint32_t array_index) {
-		const auto pointer = DescriptorElementPointer(
-		    state, StorageImagePointerType(state, image_class, view),
-		    StorageImageVariable(state, image_class, view), array_index, kind, resource,
-		    "storage image descriptor array was not emitted");
+	const auto kind = IR::DescriptorBindingForImage(image);
+	EXIT_IF(!kind.has_value());
+	const auto array_index = ResourceForDescriptor(state, *kind, resource);
+	const auto image_type  = ImageType(state, image);
+	const auto pointer_type =
+	    state.builder.Type(OpTypePointer, {StorageClassUniformConstant, image_type});
+	const auto variable = state.image_variables[IR::ImageBindingIndex(*kind)];
+	const auto LoadAt   = [&](uint32_t array_index) {
+		const auto pointer =
+		    DescriptorElementPointer(state, pointer_type, variable, array_index, *kind, resource,
+		                             "storage image descriptor array was not emitted");
 		const auto descriptor = state.builder.AllocateId();
-		state.builder.AddFunction(
-		    {OpLoad, StorageImageType(state, image_class, view), descriptor, pointer});
+		state.builder.AddFunction({OpLoad, image_type, descriptor, pointer});
 		return descriptor;
 	};
 	if (image.mip_mode != IR::ImageMipMode::DynamicStorage) {
-		state.builder.AddFunction({OpImageWrite, LoadAt(binding.array_index), coord, texel});
+		state.builder.AddFunction({OpImageWrite, LoadAt(array_index), coord, texel});
 		return;
 	}
 	if (image.mip_count == 0u) {
-		ExitDescriptorBindingFailure(state, kind, resource,
+		ExitDescriptorBindingFailure(state, *kind, resource,
 		                             "dynamic storage image has no mip descriptors");
 	}
 
@@ -320,7 +269,7 @@ void EmitStorageImageWrite(EmitterState& state, uint32_t resource, ImageViewKind
 	state.builder.AddFunction(words);
 	for (uint32_t mip = 0; mip < image.mip_count; mip++) {
 		EmitLabel(state, labels[mip]);
-		state.builder.AddFunction({OpImageWrite, LoadAt(binding.array_index + mip), coord, texel});
+		state.builder.AddFunction({OpImageWrite, LoadAt(array_index + mip), coord, texel});
 		state.builder.AddFunction({OpBranch, merge_label});
 	}
 	EmitLabel(state, merge_label);

src/graphics/shader/recompiler/backend/spirv/spirvEmitterImage.cpp

@@ -103,20 +103,21 @@ uint32_t AddressF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::
 	           : Unary(ctx.state, OpBitcast, TypeF32(ctx.state), value);
 }
 
-ImageSampleLayout Layout(const IR::MemoryInfo& mem, ImageViewKind view) {
+ImageSampleLayout Layout(const IR::MemoryInfo& mem, ImageDimension dimension) {
 	ImageSampleLayout layout;
 	uint32_t          cursor = 0;
+	const auto&       info   = ImageDimensionInfoFor(dimension);
 	if (HasFlag(mem, Decoder::ImageSampleFlagOffset)) layout.offset = cursor++;
 	if (HasFlag(mem, Decoder::ImageSampleFlagBias)) layout.bias = cursor++;
 	if (HasFlag(mem, Decoder::ImageSampleFlagCompare)) layout.dref = cursor++;
 	if (HasFlag(mem, Decoder::ImageSampleFlagDerivative)) {
 		layout.grad_x = cursor;
-		cursor += ImageViewSpatialComponents(view);
+		cursor += info.spatial_components;
 		layout.grad_y = cursor;
-		cursor += ImageViewSpatialComponents(view);
+		cursor += info.spatial_components;
 	}
 	layout.coord = cursor;
-	cursor += ImageViewCoordinateComponents(view);
+	cursor += info.coordinate_components;
 	if (HasFlag(mem, Decoder::ImageSampleFlagLod)) layout.lod = cursor++;
 	return layout;
 }
@@ -144,11 +145,12 @@ uint32_t CubeLayer(EmitterState& state, uint32_t value) {
 
 uint32_t CoordF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
                   uint32_t first, uint32_t components) {
+	const bool cube = ctx.state.program.info.images.at(mem.resource).cube;
 	auto x = AddressF32(ctx, mem, address, first);
 	if (components == 1u) return x;
 	auto y = mem.image_address_components > first + 1u ? AddressF32(ctx, mem, address, first + 1u)
 	                                                   : ZeroF32(ctx.state);
-	if (mem.image_cube) {
+	if (cube) {
 		x = CubeAxis(ctx.state, x);
 		y = CubeAxis(ctx.state, y);
 	}
@@ -157,7 +159,7 @@ uint32_t CoordF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::In
 		auto z = mem.image_address_components > first + 2u
 		             ? AddressF32(ctx, mem, address, first + 2u)
 		             : ZeroF32(ctx.state);
-		if (mem.image_cube) z = CubeLayer(ctx.state, z);
+		if (cube) z = CubeLayer(ctx.state, z);
 		ctx.state.builder.AddFunction(
 		    {OpCompositeConstruct, TypeF32Vector(ctx.state, 3), result, x, y, z});
 	} else {
@@ -168,8 +170,8 @@ uint32_t CoordF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::In
 }
 
 uint32_t CoordU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
-                  ImageViewKind view) {
-	const auto components = ImageViewCoordinateComponents(view);
+                  ImageDimension dimension) {
+	const auto components = ImageDimensionInfoFor(dimension).coordinate_components;
 	const auto x          = AddressU32(ctx, mem, address, 0);
 	if (components == 1u) return x;
 	const auto y      = mem.image_address_components > 1u ? AddressU32(ctx, mem, address, 1)
@@ -188,8 +190,8 @@ uint32_t CoordU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::In
 }
 
 uint32_t LodU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
-                ImageViewKind view) {
-	const auto component = ImageViewCoordinateComponents(view);
+                ImageDimension dimension) {
+	const auto component = ImageDimensionInfoFor(dimension).coordinate_components;
 	return mem.image_has_mip && mem.image_address_components > component
 	           ? AddressU32(ctx, mem, address, component)
 	           : ConstantU32(ctx.state, 0);
@@ -199,8 +201,33 @@ uint32_t FloatBits(ValueEmitContext& ctx, uint32_t value) {
 	return Unary(ctx.state, OpBitcast, TypeU32(ctx.state), value);
 }
 
-uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value, bool integer, bool dref,
+uint32_t SampledComponentBits(ValueEmitContext& ctx, uint32_t value,
+                              Prospero::TextureNumericClass numeric_class) {
+	if (numeric_class == Prospero::TextureNumericClass::Uint) {
+		return value;
+	}
+	return Unary(ctx.state, OpBitcast, TypeU32(ctx.state), value);
+}
+
+uint32_t SampledComponentZero(EmitterState& state, Prospero::TextureNumericClass numeric_class) {
+	switch (numeric_class) {
+		case Prospero::TextureNumericClass::Float: return ZeroF32(state);
+		case Prospero::TextureNumericClass::Uint: return ConstantU32(state, 0);
+		case Prospero::TextureNumericClass::Sint: return ConstantI32(state, 0);
+		case Prospero::TextureNumericClass::Unsupported: break;
+	}
+	EXIT("invalid sampled image numeric class");
+}
+
+uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value,
+                      Prospero::TextureNumericClass numeric_class, bool dref,
                       const IR::MemoryInfo& mem, bool gather = false) {
+	auto value_class = numeric_class;
+	if (dref) {
+		value_class = Prospero::TextureNumericClass::Float;
+	}
+	const bool integer = value_class == Prospero::TextureNumericClass::Uint ||
+	                     value_class == Prospero::TextureNumericClass::Sint;
 	if (mem.data_bits == 16u) {
 		uint32_t   packed[4] = {ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0),
 		                        ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0)};
@@ -209,25 +236,27 @@ uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value, bool integer, bool
 			const auto component = gather ? index : DmaskComponent(mem.dmask, index);
 			const auto result    = ctx.state.builder.AllocateId();
 			ctx.state.builder.AddFunction({OpCompositeExtract,
-			                               integer ? TypeU32(ctx.state) : TypeF32(ctx.state),
-			                               result, value, component});
+			                               ImageScalarType(ctx.state, value_class), result, value,
+			                               component});
 			return result;
 		};
 		for (uint32_t word = 0; word < mem.data_dwords; word++) {
 			const auto low_index  = word * 2u;
 			const auto high_index = low_index + 1u;
 			const auto low        = scalar(low_index);
-			const auto high = high_index < mem.component_count
-			                      ? scalar(high_index)
-			                      : (integer ? ConstantU32(ctx.state, 0) : ZeroF32(ctx.state));
+			const auto high       = high_index < mem.component_count
+			                            ? scalar(high_index)
+			                            : SampledComponentZero(ctx.state, value_class);
 			if (integer) {
-				const auto mask = ConstantU32(ctx.state, 0xffffu);
-				packed[word] =
-				    Binary(ctx.state, OpBitwiseOr, TypeU32(ctx.state),
-				           Binary(ctx.state, OpBitwiseAnd, TypeU32(ctx.state), low, mask),
-				           Binary(ctx.state, OpShiftLeftLogical, TypeU32(ctx.state),
-				                  Binary(ctx.state, OpBitwiseAnd, TypeU32(ctx.state), high, mask),
-				                  ConstantU32(ctx.state, 16u)));
+				const auto low_bits  = SampledComponentBits(ctx, low, value_class);
+				const auto high_bits = SampledComponentBits(ctx, high, value_class);
+				const auto mask      = ConstantU32(ctx.state, 0xffffu);
+				packed[word]         = Binary(
+				    ctx.state, OpBitwiseOr, TypeU32(ctx.state),
+				    Binary(ctx.state, OpBitwiseAnd, TypeU32(ctx.state), low_bits, mask),
+				    Binary(ctx.state, OpShiftLeftLogical, TypeU32(ctx.state),
+				           Binary(ctx.state, OpBitwiseAnd, TypeU32(ctx.state), high_bits, mask),
+				           ConstantU32(ctx.state, 16u)));
 			} else {
 				const auto pair = ctx.state.builder.AllocateId();
 				ctx.state.builder.AddFunction(
@@ -249,10 +278,9 @@ uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value, bool integer, bool
 			continue;
 		}
 		const auto scalar = ctx.state.builder.AllocateId();
-		ctx.state.builder.AddFunction({OpCompositeExtract,
-		                               integer ? TypeU32(ctx.state) : TypeF32(ctx.state), scalar,
-		                               value, index});
-		component[index] = integer ? scalar : FloatBits(ctx, scalar);
+		ctx.state.builder.AddFunction(
+		    {OpCompositeExtract, ImageScalarType(ctx.state, value_class), scalar, value, index});
+		component[index] = SampledComponentBits(ctx, scalar, value_class);
 	}
 	const auto result = ctx.state.builder.AllocateId();
 	ctx.state.builder.AddFunction({OpCompositeConstruct, TypeU32Vector(ctx.state, 4), result,
@@ -260,20 +288,20 @@ uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value, bool integer, bool
 	return result;
 }
 
-uint32_t QueryDimensions(ValueEmitContext& ctx, const IR::Inst& inst, const IR::MemoryInfo& mem,
+uint32_t QueryDimensions(ValueEmitContext& ctx, const IR::MemoryInfo& mem,
                          const IR::Inst& address) {
-	const auto pc    = inst.Flags<IR::MemoryFlags>().pc;
-	const auto view  = SampledImageViewKind(ctx.state, mem, pc);
-	const auto image = LoadSampledImageDescriptor(ctx.state, mem, pc, view);
-	const auto size  = ctx.state.builder.AllocateId();
-	if (ImageSpirvMultisampled(view) != 0u) {
+	const auto  dimension = ctx.state.program.info.images.at(mem.resource).dimension;
+	const auto& info      = ImageDimensionInfoFor(dimension);
+	const auto  image     = LoadSampledImageDescriptor(ctx.state, mem.resource);
+	const auto  size      = ctx.state.builder.AllocateId();
+	if (info.multisampled != 0u) {
 		ctx.state.builder.AddFunction(
-		    {OpImageQuerySize, ImageViewSizeType(ctx.state, view), size, image});
+		    {OpImageQuerySize, ImageViewSizeType(ctx.state, dimension), size, image});
 	} else {
-		ctx.state.builder.AddFunction({OpImageQuerySizeLod, ImageViewSizeType(ctx.state, view),
+		ctx.state.builder.AddFunction({OpImageQuerySizeLod, ImageViewSizeType(ctx.state, dimension),
 		                               size, image, AddressU32(ctx, mem, address, 0)});
 	}
-	const auto components = ImageViewCoordinateComponents(view);
+	const auto components = info.coordinate_components;
 	uint32_t   result[4]  = {ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0),
 	                         ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0)};
 	if (components == 1u) {
@@ -285,7 +313,7 @@ uint32_t QueryDimensions(ValueEmitContext& ctx, const IR::Inst& inst, const IR::
 			    {OpCompositeExtract, TypeU32(ctx.state), result[index], size, index});
 		}
 	}
-	if (ImageSpirvMultisampled(view) == 0u) {
+	if (info.multisampled == 0u) {
 		result[3] = ctx.state.builder.AllocateId();
 		ctx.state.builder.AddFunction({OpImageQueryLevels, TypeU32(ctx.state), result[3], image});
 	}
@@ -296,8 +324,8 @@ uint32_t QueryDimensions(ValueEmitContext& ctx, const IR::Inst& inst, const IR::
 }
 
 uint32_t PackedOffset(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
-                      const ImageSampleLayout& layout, ImageViewKind view) {
-	const auto components = ImageViewSpatialComponents(view);
+                      const ImageSampleLayout& layout, ImageDimension dimension) {
+	const auto components = ImageDimensionInfoFor(dimension).spatial_components;
 	const auto zero       = ConstantI32(ctx.state, 0);
 	if (layout.offset == NoImageComponent || mem.image_address_components <= layout.offset) {
 		if (components == 1u) return zero;
@@ -332,8 +360,8 @@ uint32_t PackedOffset(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR
 	return result;
 }
 
-uint32_t HorizontalOffsets(EmitterState& state, ImageViewKind view) {
-	const auto components   = ImageViewSpatialComponents(view);
+uint32_t HorizontalOffsets(EmitterState& state, ImageDimension dimension) {
+	const auto components   = ImageDimensionInfoFor(dimension).spatial_components;
 	const auto count        = ConstantU32(state, 4);
 	const auto element_type = components == 1u ? TypeI32(state) : TypeI32Vector(state, 2);
 	const auto array_type   = state.builder.Type(OpTypeArray, {element_type, count});
@@ -363,8 +391,7 @@ Format::BufferFormatInfo ImageConversionFormat(const EmitterState&   state,
 	const auto format = state.program.info.images[mem.resource].conversion_format;
 	if (format == Prospero::BufferFormat::kInvalid) return {};
 	const auto info = Format::GetFormatInfo(format);
-	EXIT_IF(!Prospero::IsSampledTextureFormat(format) ||
-	        !Prospero::IsUintTextureFormat(format) ||
+	EXIT_IF(Prospero::SampledTextureNumericClass(format) != Prospero::TextureNumericClass::Uint ||
 	        Prospero::RemapTextureFormat(format) == format ||
 	        info.type != Format::ComponentType::Uint || !info.packed_bitfield ||
 	        info.byte_size != sizeof(uint32_t) || info.component_count == 0u ||
@@ -439,46 +466,46 @@ uint32_t UnpackImageGather(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uin
 	return result;
 }
 
-uint32_t EmitOneDimensionalGatherLz(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t pc,
-	                                 uint32_t coord, bool integer) {
+uint32_t EmitOneDimensionalGatherLz(ValueEmitContext& ctx, const IR::MemoryInfo& mem,
+                                    uint32_t coord, Prospero::TextureNumericClass numeric_class) {
 	auto& state = ctx.state;
 	state.builder.RequireCapability(CapabilityImageQuery);
-	const auto image = LoadSampledImageDescriptor(state, mem, pc, ImageViewKind::Dim1D);
+	const auto image = LoadSampledImageDescriptor(state, mem.resource);
 	const auto width = state.builder.AllocateId();
 	state.builder.AddFunction(
 	    {OpImageQuerySizeLod, TypeU32(state), width, image, ConstantU32(state, 0)});
 	const auto width_f32 = state.builder.AllocateId();
 	state.builder.AddFunction({OpConvertUToF, TypeF32(state), width_f32, width});
 	const auto left = state.builder.AllocateId();
-	state.builder.AddFunction(
-	    {OpExtInst, TypeF32(state), left, GlslStd450(state), GlslFloor,
-	     Binary(state, OpFSub, TypeF32(state),
-	            Binary(state, OpFMul, TypeF32(state), coord, width_f32),
-	            ConstantF32(state, 0x3f000000u))});
+	state.builder.AddFunction({OpExtInst, TypeF32(state), left, GlslStd450(state), GlslFloor,
+	                           Binary(state, OpFSub, TypeF32(state),
+	                                  Binary(state, OpFMul, TypeF32(state), coord, width_f32),
+	                                  ConstantF32(state, 0x3f000000u))});
 
-	const auto sampled = MakeSampledImage(state, mem, pc, ImageViewKind::Dim1D);
-	const auto vector_type = integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4);
-	const auto scalar_type = integer ? TypeU32(state) : TypeF32(state);
-	const auto component = ImageConversionFormat(state, mem).format == Prospero::BufferFormat::kInvalid
-	                           ? ImageGatherComponent(mem.dmask)
-	                           : 0u;
+	const auto sampled     = MakeSampledImage(state, mem.resource, mem.sampler);
+	const auto vector_type = ImageVectorType(state, numeric_class, 4);
+	const auto scalar_type = ImageScalarType(state, numeric_class);
+	const auto component =
+	    ImageConversionFormat(state, mem).format == Prospero::BufferFormat::kInvalid
+	        ? ImageGatherComponent(mem.dmask)
+	        : 0u;
 	uint32_t values[2] {};
 	for (uint32_t index = 0; index < 2u; index++) {
-		const auto sample_coord = Binary(
-		    state, OpFDiv, TypeF32(state),
-		    Binary(state, OpFAdd, TypeF32(state), left,
-		           ConstantF32(state, index == 0u ? 0x3f000000u : 0x3fc00000u)),
-		    width_f32);
+		const auto sample_coord =
+		    Binary(state, OpFDiv, TypeF32(state),
+		           Binary(state, OpFAdd, TypeF32(state), left,
+		                  ConstantF32(state, index == 0u ? 0x3f000000u : 0x3fc00000u)),
+		           width_f32);
 		const auto texel = state.builder.AllocateId();
-		state.builder.AddFunction({OpImageSampleExplicitLod, vector_type, texel, sampled, sample_coord,
-		                           ImageOperandsLodMask, ZeroF32(state)});
+		state.builder.AddFunction({OpImageSampleExplicitLod, vector_type, texel, sampled,
+		                           sample_coord, ImageOperandsLodMask, ZeroF32(state)});
 		values[index] = state.builder.AllocateId();
 		state.builder.AddFunction(
 		    {OpCompositeExtract, scalar_type, values[index], texel, component});
 	}
 	const auto result = state.builder.AllocateId();
-	state.builder.AddFunction({OpCompositeConstruct, vector_type, result, values[0], values[1],
-	                           values[1], values[0]});
+	state.builder.AddFunction(
+	    {OpCompositeConstruct, vector_type, result, values[0], values[1], values[1], values[0]});
 	return result;
 }
 
@@ -549,6 +576,7 @@ uint32_t StoreTexel(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t d
 
 uint32_t ImageAtomicOpcode(IR::ValueOpcode opcode) {
 	switch (opcode) {
+		case IR::ValueOpcode::ImageAtomicSwap32: return OpAtomicExchange;
 		case IR::ValueOpcode::ImageAtomicIAdd32: return OpAtomicIAdd;
 		case IR::ValueOpcode::ImageAtomicUMin32: return OpAtomicUMin;
 		case IR::ValueOpcode::ImageAtomicUMax32: return OpAtomicUMax;
@@ -569,24 +597,24 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 	}
 	auto&       state     = ctx.state;
 	const auto& mem       = ctx.Memory(inst);
-	const auto  pc        = inst.Flags<IR::MemoryFlags>().pc;
 	const auto  image_arg = inst.Arg(0);
 	ctx.ResourceIndex(image_arg, IR::ValueOpcode::GetImageResource);
+	const auto& image   = state.program.info.images.at(mem.resource);
 	const auto* address = ctx.ImageAddress(inst.Arg(image_info.needs_sampler ? 2 : 1));
 	if (address == nullptr) return true;
 	if (op == IR::ValueOpcode::ImageQueryDimensions) {
 		state.builder.RequireCapability(CapabilityImageQuery);
-		ctx.Define(inst, QueryDimensions(ctx, inst, mem, *address));
+		ctx.Define(inst, QueryDimensions(ctx, mem, *address));
 		return true;
 	}
 	if (op == IR::ValueOpcode::ImageQueryLod) {
 		state.builder.RequireCapability(CapabilityImageQuery);
-		const auto view    = SampledImageViewKind(state, mem, pc);
-		const auto sampled = MakeSampledImage(state, mem, pc, view);
-		const auto lod     = state.builder.AllocateId();
+		const auto dimension = image.dimension;
+		const auto sampled   = MakeSampledImage(state, mem.resource, mem.sampler);
+		const auto lod       = state.builder.AllocateId();
 		state.builder.AddFunction(
 		    {OpImageQueryLod, TypeF32Vector(state, 2), lod, sampled,
-		     CoordF32(ctx, mem, *address, 0, ImageViewSpatialComponents(view))});
+		     CoordF32(ctx, mem, *address, 0, ImageDimensionInfoFor(dimension).spatial_components)});
 		uint32_t values[4] = {ConstantU32(state, 0), ConstantU32(state, 0), ConstantU32(state, 0),
 		                      ConstantU32(state, 0)};
 		for (uint32_t index = 0; index < 2u; index++) {
@@ -601,143 +629,153 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 		return true;
 	}
 	if (op == IR::ValueOpcode::ImageRead) {
-		const auto view      = SampledImageViewKind(state, mem, pc);
-		const bool integer   = mem.kind == IR::ResourceKind::ImageUint;
-		const auto condition = ctx.Arg(inst, 2);
+		const auto  dimension      = image.dimension;
+		const auto& dimension_info = ImageDimensionInfoFor(dimension);
+		const auto  numeric_class  = image.numeric_class;
+		const auto  condition      = ctx.Arg(inst, 2);
 		ctx.Define(
 		    inst,
 		    EmitValueOrDefaultIfCondition(
 		        state, condition, TypeU32Vector(state, 4), ConstantU32CompositeZero(state, 4),
 		        [&]() {
-			        const auto image = LoadSampledImageDescriptor(state, mem, pc, view);
-			        const auto color = state.builder.AllocateId();
-			        const auto coord = CoordU32(ctx, mem, *address, view);
-			        if (ImageSpirvMultisampled(view) != 0u) {
+			        const auto descriptor = LoadSampledImageDescriptor(state, mem.resource);
+			        const auto color      = state.builder.AllocateId();
+			        const auto coord      = CoordU32(ctx, mem, *address, dimension);
+			        if (dimension_info.multisampled != 0u) {
 				        state.builder.AddFunction(
-				            {OpImageFetch,
-				             integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4), color,
-				             image, coord, ImageOperandsSampleMask,
-				             AddressU32(ctx, mem, *address, ImageViewCoordinateComponents(view))});
+				            {OpImageFetch, ImageVectorType(state, numeric_class, 4), color,
+				             descriptor, coord, ImageOperandsSampleMask,
+				             AddressU32(ctx, mem, *address, dimension_info.coordinate_components)});
 			        } else {
-				        state.builder.AddFunction(
-				            {OpImageFetch,
-				             integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4), color,
-				             image, coord, ImageOperandsLodMask, LodU32(ctx, mem, *address, view)});
+				        state.builder.AddFunction({OpImageFetch,
+				                                   ImageVectorType(state, numeric_class, 4), color,
+				                                   descriptor, coord, ImageOperandsLodMask,
+				                                   LodU32(ctx, mem, *address, dimension)});
 			        }
-			        return ResultVector(ctx, UnpackImageTexel(ctx, mem, color), integer, false,
-			                            mem);
+			        return ResultVector(ctx, UnpackImageTexel(ctx, mem, color), numeric_class,
+			                            false, mem);
 		        }));
 		return true;
 	}
 	if (op == IR::ValueOpcode::ImageWrite) {
-		const auto uint_image = mem.kind == IR::ResourceKind::StorageImageUint;
-		const auto view       = StorageImageViewKind(mem);
+		const bool uint_image = image.numeric_class == Prospero::TextureNumericClass::Uint;
+		const auto dimension  = image.dimension;
 		EmitIfCondition(state, ctx.Arg(inst, 3), [&]() {
 			const auto mip_lod =
 			    state.program.info.images[mem.resource].mip_mode == IR::ImageMipMode::DynamicStorage
-			        ? LodU32(ctx, mem, *address, view)
+			        ? LodU32(ctx, mem, *address, dimension)
 			        : 0u;
-			const auto coord = CoordU32(ctx, mem, *address, view);
+			const auto coord = CoordU32(ctx, mem, *address, dimension);
 			const auto texel = StoreTexel(ctx, mem, ctx.Arg(inst, 2), uint_image);
-			EmitStorageImageWrite(state, mem.resource, view, mip_lod, coord, texel);
+			EmitStorageImageWrite(state, mem.resource, mip_lod, coord, texel);
 		});
 		return true;
 	}
 	if (op == IR::ValueOpcode::ImageSampleRaw || op == IR::ValueOpcode::ImageGatherRaw) {
-		const auto view    = SampledImageViewKind(state, mem, pc);
-		const auto layout  = Layout(mem, view);
-		const bool integer = mem.kind == IR::ResourceKind::ImageUint;
-		const bool dref    = HasFlag(mem, Decoder::ImageSampleFlagCompare);
+		const auto  dimension      = image.dimension;
+		const auto& dimension_info = ImageDimensionInfoFor(dimension);
+		const auto  layout         = Layout(mem, dimension);
+		const auto  numeric_class  = image.numeric_class;
+		const bool  dref           = HasFlag(mem, Decoder::ImageSampleFlagCompare);
 		if (dref && state.program.info.images[mem.resource].conversion_format !=
 		                Prospero::BufferFormat::kInvalid) {
 			ctx.Fail(inst, "uses depth comparison with a packed integer image");
 			return true;
 		}
 		const auto coord =
-		    CoordF32(ctx, mem, *address, layout.coord, ImageViewCoordinateComponents(view));
+		    CoordF32(ctx, mem, *address, layout.coord, dimension_info.coordinate_components);
 		if (op == IR::ValueOpcode::ImageGatherRaw) {
-			if (view == ImageViewKind::Dim1D) {
+			if (dimension == ImageDimension::Dim1D) {
 				if (dref || !HasFlag(mem, Decoder::ImageSampleFlagLevelZero) ||
 				    HasFlag(mem, Decoder::ImageSampleFlagOffset) ||
 				    HasFlag(mem, Decoder::ImageSampleFlagGatherHorizontal)) {
 					ctx.Fail(inst, "has an unsupported 1D gather variant");
 					return true;
 				}
-				const auto sample = EmitOneDimensionalGatherLz(ctx, mem, pc, coord, integer);
-				ctx.Define(inst, ResultVector(ctx, UnpackImageGather(ctx, mem, sample), integer,
-				                              false, mem, true));
+				const auto sample = EmitOneDimensionalGatherLz(ctx, mem, coord, numeric_class);
+				ctx.Define(inst, ResultVector(ctx, UnpackImageGather(ctx, mem, sample),
+				                              numeric_class, false, mem, true));
 				return true;
 			}
-			if (view == ImageViewKind::Dim1DArray) {
+			if (dimension == ImageDimension::Dim1DArray) {
 				ctx.Fail(inst, "has an unsupported 1D-array gather");
 				return true;
 			}
-			const auto            sampled = MakeSampledImage(state, mem, pc, view);
+			const auto            sampled = MakeSampledImage(state, mem.resource, mem.sampler);
 			const auto            sample  = state.builder.AllocateId();
-			std::vector<uint32_t> words =
-			    dref ? std::vector<uint32_t> {OpImageDrefGather,
-			                                  TypeF32Vector(state, 4),
-			                                  sample,
-			                                  sampled,
-			                                  coord,
-			                                  layout.dref != NoImageComponent
-			                                      ? AddressF32(ctx, mem, *address, layout.dref)
-			                                      : ZeroF32(state)}
-			         : std::vector<uint32_t> {
-			               OpImageGather,
-			               integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4),
-			               sample,
-			               sampled,
-			               coord,
-			               ConstantU32(state, ImageConversionFormat(state, mem).format ==
-			                                          Prospero::BufferFormat::kInvalid
-			                                      ? ImageGatherComponent(mem.dmask)
-			                                      : 0u)};
+			std::vector<uint32_t> words;
+			if (dref) {
+				auto dref_value = ZeroF32(state);
+				if (layout.dref != NoImageComponent) {
+					dref_value = AddressF32(ctx, mem, *address, layout.dref);
+				}
+				words = {OpImageDrefGather, TypeF32Vector(state, 4), sample, sampled, coord,
+				         dref_value};
+			} else {
+				uint32_t component = 0;
+				if (ImageConversionFormat(state, mem).format == Prospero::BufferFormat::kInvalid) {
+					component = ImageGatherComponent(mem.dmask);
+				}
+				words = {OpImageGather, ImageVectorType(state, numeric_class, 4),
+				         sample,        sampled,
+				         coord,         ConstantU32(state, component)};
+			}
 			if (HasFlag(mem, Decoder::ImageSampleFlagGatherHorizontal)) {
 				words.push_back(ImageOperandsConstOffsetsMask);
-				words.push_back(HorizontalOffsets(state, view));
+				words.push_back(HorizontalOffsets(state, dimension));
 			} else if (layout.offset != NoImageComponent) {
 				words.push_back(ImageOperandsOffsetMask);
-				words.push_back(PackedOffset(ctx, mem, *address, layout, view));
+				words.push_back(PackedOffset(ctx, mem, *address, layout, dimension));
 			}
 			state.builder.AddFunction(words);
+			auto result_numeric_class = numeric_class;
+			if (dref) {
+				result_numeric_class = Prospero::TextureNumericClass::Float;
+			}
 			ctx.Define(inst, ResultVector(ctx, UnpackImageGather(ctx, mem, sample),
-			                              integer && !dref, false, mem, true));
+			                              result_numeric_class, false, mem, true));
 			return true;
 		}
 		const bool explicit_lod = HasFlag(mem, Decoder::ImageSampleFlagDerivative) ||
 		                          HasFlag(mem, Decoder::ImageSampleFlagLod) ||
 		                          HasFlag(mem, Decoder::ImageSampleFlagLevelZero) ||
 		                          state.stage != ShaderType::Pixel;
-		const auto opcode = explicit_lod
-		                        ? (dref ? OpImageSampleDrefExplicitLod : OpImageSampleExplicitLod)
-		                        : (dref ? OpImageSampleDrefImplicitLod : OpImageSampleImplicitLod);
-		const auto result_type =
-		    dref ? TypeF32(state) : (integer ? TypeU32Vector(state, 4) : TypeF32Vector(state, 4));
-		const auto dref_value =
-		    dref ? (layout.dref != NoImageComponent ? AddressF32(ctx, mem, *address, layout.dref)
-		                                            : ZeroF32(state))
-		         : 0u;
+		uint32_t opcode = OpImageSampleImplicitLod;
+		if (explicit_lod) {
+			opcode = dref ? OpImageSampleDrefExplicitLod : OpImageSampleExplicitLod;
+		} else if (dref) {
+			opcode = OpImageSampleDrefImplicitLod;
+		}
+		uint32_t result_type = ImageVectorType(state, numeric_class, 4);
+		uint32_t dref_value  = 0;
+		if (dref) {
+			result_type = TypeF32(state);
+			dref_value  = ZeroF32(state);
+			if (layout.dref != NoImageComponent) {
+				dref_value = AddressF32(ctx, mem, *address, layout.dref);
+			}
+		}
 		uint32_t              operand_mask = 0;
 		std::vector<uint32_t> operands;
 		if (HasFlag(mem, Decoder::ImageSampleFlagDerivative)) {
 			operand_mask |= ImageOperandsGradMask;
 			operands.push_back(
-			    CoordF32(ctx, mem, *address, layout.grad_x, ImageViewSpatialComponents(view)));
+			    CoordF32(ctx, mem, *address, layout.grad_x, dimension_info.spatial_components));
 			operands.push_back(
-			    CoordF32(ctx, mem, *address, layout.grad_y, ImageViewSpatialComponents(view)));
+			    CoordF32(ctx, mem, *address, layout.grad_y, dimension_info.spatial_components));
 		} else if (explicit_lod) {
 			operand_mask |= ImageOperandsLodMask;
-			operands.push_back(HasFlag(mem, Decoder::ImageSampleFlagLod) &&
-			                           layout.lod != NoImageComponent
-			                       ? AddressF32(ctx, mem, *address, layout.lod)
-			                       : ZeroF32(state));
+			auto lod = ZeroF32(state);
+			if (HasFlag(mem, Decoder::ImageSampleFlagLod) && layout.lod != NoImageComponent) {
+				lod = AddressF32(ctx, mem, *address, layout.lod);
+			}
+			operands.push_back(lod);
 		} else if (layout.bias != NoImageComponent) {
 			operand_mask |= ImageOperandsBiasMask;
 			operands.push_back(AddressF32(ctx, mem, *address, layout.bias));
 		}
 		const auto EmitSample = [&](uint32_t resource) {
-			const auto            sampled = MakeSampledImage(state, mem, pc, view, resource);
+			const auto            sampled = MakeSampledImage(state, resource, mem.sampler);
 			const auto            sample  = state.builder.AllocateId();
 			std::vector<uint32_t> words {opcode, result_type, sample, sampled, coord};
 			if (dref) {
@@ -750,11 +788,13 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 			state.builder.AddFunction(words);
 			return sample;
 		};
-		const auto& image = state.program.info.images[mem.resource];
 		if (image.indirect_root != mem.resource) {
 			const auto sample = EmitSample(mem.resource);
-			ctx.Define(inst, ResultVector(ctx, dref ? sample : UnpackImageTexel(ctx, mem, sample),
-			                              integer, dref, mem));
+			auto       result = sample;
+			if (!dref) {
+				result = UnpackImageTexel(ctx, mem, sample);
+			}
+			ctx.Define(inst, ResultVector(ctx, result, numeric_class, dref, mem));
 			return true;
 		}
 		const auto* handle = image_arg.ResolveInstruction();
@@ -767,7 +807,7 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 			return true;
 		}
 		const auto key = ctx.Def(handle->Arg(source->indirect_image->key_arg));
-		if (state.flattened_srt_variable == 0 || image.indirect_mapping_capacity == 0u ||
+		if (state.flattened_srt_variable == 0 || image.indirect_search_iterations == 0u ||
 		    image.indirect_resources.size() < 2u) {
 			ctx.Fail(inst, "has no indirect image runtime mapping");
 			return true;
@@ -785,7 +825,7 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 		auto       low      = ConstantU32(state, 0u);
 		auto       high     = LoadMapping(mapping);
 		auto       selected = ConstantU32(state, 0u);
-		for (uint32_t iteration = 0; iteration < std::bit_width(image.indirect_mapping_capacity);
+		for (uint32_t iteration = 0; iteration < image.indirect_search_iterations;
 		     iteration++) {
 			const auto active = Binary(state, OpULessThan, TypeBool(state), low, high);
 			const auto mid =
@@ -845,22 +885,24 @@ bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst) {
 		}
 		EmitLabel(state, merge_label);
 		state.builder.AddFunction(phi_words);
-		ctx.Define(inst,
-		           ResultVector(ctx, dref ? phi_words[2] : UnpackImageTexel(ctx, mem, phi_words[2]),
-		                        integer, dref, mem));
+		auto result = phi_words[2];
+		if (!dref) {
+			result = UnpackImageTexel(ctx, mem, result);
+		}
+		ctx.Define(inst, ResultVector(ctx, result, numeric_class, dref, mem));
 		return true;
 	}
 	const auto atomic_opcode = ImageAtomicOpcode(op);
 	if (atomic_opcode != 0u) {
-		const auto view = StorageImageViewKind(mem);
+		const auto dimension = image.dimension;
 		ctx.Define(inst, EmitValueOrZeroIfCondition(state, ctx.Arg(inst, 3), [&]() {
 			           const auto pointer = state.builder.AllocateId();
 			           const auto pointer_type =
 			               state.builder.Type(OpTypePointer, {StorageClassImage, TypeU32(state)});
 			           state.builder.AddFunction(
 			               {OpImageTexelPointer, pointer_type, pointer,
-			                StorageImageDescriptorPointer(state, mem.resource, view),
-			                CoordU32(ctx, mem, *address, view), ConstantU32(state, 0)});
+			                StorageImageDescriptorPointer(state, mem.resource),
+			                CoordU32(ctx, mem, *address, dimension), ConstantU32(state, 0)});
 			           const auto old = state.builder.AllocateId();
 			           state.builder.AddFunction({atomic_opcode, TypeU32(state), old, pointer,
 			                                      ConstantU32(state, ScopeDevice),

src/graphics/shader/recompiler/backend/spirv/spirvEmitterInternal.h

@@ -6,7 +6,6 @@
 #include "graphics/shader/recompiler/BufferFormat.h"
 #include "graphics/shader/recompiler/backend/spirv/SpirvBuilder.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/recompiler/ir/ShaderIR.h"
 #include "graphics/shader/recompiler/ir/passes/BindingLayout.h"
 #include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
 
@@ -318,61 +317,53 @@ struct OutputBinding {
 	std::string         debug_name;
 };
 
-struct DescriptorResourceBinding {
-	const IR::DescriptorBinding* descriptor  = nullptr;
-	uint32_t                     array_index = 0;
+using ImageDimension = Decoder::ImageDimension;
+
+struct ImageDimensionInfo {
+	ImageDimension dimension;
+	uint32_t       spirv_dimension;
+	uint32_t       coordinate_components;
+	uint32_t       spatial_components;
+	uint32_t       arrayed;
+	uint32_t       multisampled;
 };
 
-enum class ImageViewKind {
-	Dim1D,
-	Dim1DArray,
-	Dim2D,
-	Dim2DArray,
-	Dim3D,
-	Dim2DMsaa,
-	Dim2DMsaaArray,
-	Count,
-};
+constexpr std::array<ImageDimensionInfo, 7> ImageDimensions {{
+    {ImageDimension::Dim1D, Dim1D, 1, 1, 0, 0},
+    {ImageDimension::Dim1DArray, Dim1D, 2, 1, 1, 0},
+    {ImageDimension::Dim2D, Dim2D, 2, 2, 0, 0},
+    {ImageDimension::Dim2DArray, Dim2D, 3, 2, 1, 0},
+    {ImageDimension::Dim3D, Dim3D, 3, 3, 0, 0},
+    {ImageDimension::Dim2DMsaa, Dim2D, 2, 2, 0, 1},
+    {ImageDimension::Dim2DMsaaArray, Dim2D, 3, 2, 1, 1},
+}};
 
-constexpr uint32_t SampledImageViewKindCount = static_cast<uint32_t>(ImageViewKind::Count);
-constexpr uint32_t StorageImageViewKindCount = static_cast<uint32_t>(ImageViewKind::Dim2DMsaa);
-
-enum class StorageImageClass : uint32_t {
-	FormatlessFloat,
-	FormatlessUint,
-	AtomicUint,
-	Count,
-};
+const ImageDimensionInfo& ImageDimensionInfoFor(ImageDimension dimension);
 
 struct EmitterState {
-	EmitterState(const IR::Program& program_, const IR::ResourceSnapshot& resources_,
-	             ShaderStageInputInfo input_info_)
-	    : program(program_), resources(resources_), input_info(input_info_),
+	EmitterState(const IR::Program& program_, ShaderStageInputInfo input_info_)
+	    : program(program_), input_info(input_info_),
 	      requirements(*program_.spirv_requirements) {}
 
-	Builder                      builder;
-	const IR::Program&           program;
-	const IR::ResourceSnapshot&  resources;
-	ShaderStageInputInfo         input_info;
-	const IR::SpirvRequirements& requirements;
-	ShaderType                   stage                   = ShaderType::Unknown;
-	uint32_t                     wave_size               = 64;
-	uint32_t                     storage_buffer_variable = 0;
-	std::array<uint32_t, IR::ShaderInfo::MaxBuffers>      memory_byte_offsets {};
-	uint32_t                                             bda_pagetable_variable = 0;
-	uint32_t                                             fault_buffer_variable  = 0;
-	uint32_t                                             bda_pointer_function   = 0;
-	uint32_t                                             gds_variable            = 0;
-	uint32_t                                             gds_length              = 0;
-	uint32_t                                             push_constant_variable  = 0;
-	uint32_t                                             vsharp_storage_variable = 0;
-	uint32_t                                             flattened_srt_variable  = 0;
-	uint32_t                                             lds_variable            = 0;
-	uint32_t                                             scratch_variable        = 0;
-	std::array<uint32_t, 2u * SampledImageViewKindCount> sampled_image_variables {};
-	std::array<uint32_t,
-	           static_cast<uint32_t>(StorageImageClass::Count) * StorageImageViewKindCount>
-	                           storage_image_variables {};
+	Builder                                          builder;
+	const IR::Program&                               program;
+	ShaderStageInputInfo                             input_info;
+	const IR::SpirvRequirements&                     requirements;
+	ShaderType                                       stage                   = ShaderType::Unknown;
+	uint32_t                                         wave_size               = 64;
+	uint32_t                                         storage_buffer_variable = 0;
+	std::array<uint32_t, IR::ShaderInfo::MaxBuffers> memory_byte_offsets {};
+	uint32_t                                         bda_pagetable_variable  = 0;
+	uint32_t                                         fault_buffer_variable   = 0;
+	uint32_t                                         bda_pointer_function    = 0;
+	uint32_t                                         gds_variable            = 0;
+	uint32_t                                         gds_length              = 0;
+	uint32_t                                         push_constant_variable  = 0;
+	uint32_t                                         shader_data_storage_variable = 0;
+	uint32_t                                         flattened_srt_variable  = 0;
+	uint32_t                                         lds_variable            = 0;
+	uint32_t                                         scratch_variable        = 0;
+	std::array<uint32_t, IR::ImageBindingCount>      image_variables {};
 	uint32_t                   sampler_variable                      = 0;
 	uint32_t                   main_func                             = 0;
 	uint32_t                   entry_label                           = 0;
@@ -443,7 +434,7 @@ struct ValueEmitContext {
 	[[noreturn]] void     Fail(const IR::Inst& inst, const char* reason) const;
 
 	EmitterState&                                                      state;
-	const IR::Program&                                            program;
+	const IR::Program&                                                 program;
 	std::unordered_map<const IR::Inst*, uint32_t>                      definitions;
 	std::unordered_map<const IR::Block*, uint32_t>                     labels;
 	const std::unordered_map<const IR::Inst*, uint32_t>*               dispatcher_spills = nullptr;
@@ -471,119 +462,6 @@ struct ImageSampleLayout {
 	uint32_t grad_y = NoImageComponent;
 };
 
-constexpr uint32_t SampledImageIndex(bool integer, ImageViewKind view) {
-	return static_cast<uint32_t>(view) + (integer ? SampledImageViewKindCount : 0u);
-}
-
-constexpr StorageImageClass StorageImageClassFor(bool uint_image, bool atomic) {
-	if (atomic) {
-		return StorageImageClass::AtomicUint;
-	}
-	if (uint_image) {
-		return StorageImageClass::FormatlessUint;
-	}
-	return StorageImageClass::FormatlessFloat;
-}
-
-constexpr uint32_t StorageImageIndex(StorageImageClass image_class, ImageViewKind view) {
-	return static_cast<uint32_t>(view) +
-	       static_cast<uint32_t>(image_class) * StorageImageViewKindCount;
-}
-
-constexpr IR::DescriptorBindingKind SampledBindingKind(bool integer, ImageViewKind view) {
-	if (integer) {
-		switch (view) {
-			case ImageViewKind::Dim1D: return IR::DescriptorBindingKind::SampledUint1D;
-			case ImageViewKind::Dim1DArray: return IR::DescriptorBindingKind::SampledUint1DArray;
-			case ImageViewKind::Dim2D: return IR::DescriptorBindingKind::SampledUint2D;
-			case ImageViewKind::Dim2DArray: return IR::DescriptorBindingKind::SampledUint2DArray;
-			case ImageViewKind::Dim3D: return IR::DescriptorBindingKind::SampledUint3D;
-			case ImageViewKind::Dim2DMsaa: return IR::DescriptorBindingKind::SampledUint2DMsaa;
-			case ImageViewKind::Dim2DMsaaArray:
-				return IR::DescriptorBindingKind::SampledUint2DMsaaArray;
-			default: break;
-		}
-	}
-	switch (view) {
-		case ImageViewKind::Dim1D: return IR::DescriptorBindingKind::Sampled1D;
-		case ImageViewKind::Dim1DArray: return IR::DescriptorBindingKind::Sampled1DArray;
-		case ImageViewKind::Dim2D: return IR::DescriptorBindingKind::Sampled2D;
-		case ImageViewKind::Dim2DArray: return IR::DescriptorBindingKind::Sampled2DArray;
-		case ImageViewKind::Dim3D: return IR::DescriptorBindingKind::Sampled3D;
-		case ImageViewKind::Dim2DMsaa: return IR::DescriptorBindingKind::Sampled2DMsaa;
-		case ImageViewKind::Dim2DMsaaArray: return IR::DescriptorBindingKind::Sampled2DMsaaArray;
-		default: break;
-	}
-	return IR::DescriptorBindingKind::Count;
-}
-
-constexpr IR::DescriptorBindingKind StorageBindingKind(StorageImageClass image_class,
-                                                       ImageViewKind     view) {
-	switch (image_class) {
-		case StorageImageClass::FormatlessFloat:
-			switch (view) {
-				case ImageViewKind::Dim1D: return IR::DescriptorBindingKind::Storage1D;
-				case ImageViewKind::Dim1DArray: return IR::DescriptorBindingKind::Storage1DArray;
-				case ImageViewKind::Dim2D: return IR::DescriptorBindingKind::Storage2D;
-				case ImageViewKind::Dim2DArray: return IR::DescriptorBindingKind::Storage2DArray;
-				case ImageViewKind::Dim3D: return IR::DescriptorBindingKind::Storage3D;
-				default: break;
-			}
-			break;
-		case StorageImageClass::FormatlessUint:
-			switch (view) {
-				case ImageViewKind::Dim1D: return IR::DescriptorBindingKind::StorageUint1D;
-				case ImageViewKind::Dim1DArray:
-					return IR::DescriptorBindingKind::StorageUint1DArray;
-				case ImageViewKind::Dim2D: return IR::DescriptorBindingKind::StorageUint2D;
-				case ImageViewKind::Dim2DArray:
-					return IR::DescriptorBindingKind::StorageUint2DArray;
-				case ImageViewKind::Dim3D: return IR::DescriptorBindingKind::StorageUint3D;
-				default: break;
-			}
-			break;
-		case StorageImageClass::AtomicUint:
-			switch (view) {
-				case ImageViewKind::Dim1D: return IR::DescriptorBindingKind::StorageAtomic1D;
-				case ImageViewKind::Dim1DArray:
-					return IR::DescriptorBindingKind::StorageAtomic1DArray;
-				case ImageViewKind::Dim2D: return IR::DescriptorBindingKind::StorageAtomic2D;
-				case ImageViewKind::Dim2DArray:
-					return IR::DescriptorBindingKind::StorageAtomic2DArray;
-				case ImageViewKind::Dim3D: return IR::DescriptorBindingKind::StorageAtomic3D;
-				default: break;
-			}
-			break;
-		case StorageImageClass::Count: break;
-	}
-	return IR::DescriptorBindingKind::Count;
-}
-
-constexpr uint32_t ImageSpirvDimension(ImageViewKind view) {
-	switch (view) {
-		case ImageViewKind::Dim1D:
-		case ImageViewKind::Dim1DArray: return Dim1D;
-		case ImageViewKind::Dim2D:
-		case ImageViewKind::Dim2DArray:
-		case ImageViewKind::Dim2DMsaa:
-		case ImageViewKind::Dim2DMsaaArray:
-		case ImageViewKind::Count: return Dim2D;
-		case ImageViewKind::Dim3D: return Dim3D;
-	}
-	return Dim2D;
-}
-
-constexpr uint32_t ImageSpirvArrayed(ImageViewKind view) {
-	return view == ImageViewKind::Dim1DArray || view == ImageViewKind::Dim2DArray ||
-	               view == ImageViewKind::Dim2DMsaaArray
-	           ? 1u
-	           : 0u;
-}
-
-constexpr uint32_t ImageSpirvMultisampled(ImageViewKind view) {
-	return view == ImageViewKind::Dim2DMsaa || view == ImageViewKind::Dim2DMsaaArray ? 1u : 0u;
-}
-
 struct F32Class {
 	uint32_t bits = 0;
 	uint32_t nan  = 0;
@@ -626,48 +504,33 @@ uint32_t EmitSubgroupLocalInvocationId(EmitterState& state);
                                                IR::DescriptorBindingKind kind, uint32_t resource,
                                                const char* reason);
 
-DescriptorResourceBinding ResourceForDescriptor(const EmitterState&       state,
-                                                IR::DescriptorBindingKind kind, uint32_t resource);
+uint32_t ResourceForDescriptor(const EmitterState& state, IR::DescriptorBindingKind kind,
+                               uint32_t resource);
 
 uint32_t DescriptorElementPointer(EmitterState& state, uint32_t result_ptr_type,
                                   uint32_t variable_id, uint32_t array_index,
                                   IR::DescriptorBindingKind kind, uint32_t resource,
                                   const char* variable_name);
 
-ImageViewKind SampledImageViewKind(const EmitterState& state, const IR::MemoryInfo& mem,
-                                   uint32_t use_pc);
+uint32_t ImageScalarType(EmitterState& state, Prospero::TextureNumericClass numeric_class);
 
-uint32_t ImageViewCoordinateComponents(ImageViewKind view);
+uint32_t ImageVectorType(EmitterState& state, Prospero::TextureNumericClass numeric_class,
+                         uint32_t components);
 
-uint32_t ImageViewSpatialComponents(ImageViewKind view);
+uint32_t ImageType(EmitterState& state, const IR::ImageResource& image);
 
-uint32_t ImageViewImageType(EmitterState& state, ImageViewKind view, bool integer);
+uint32_t ImageViewSizeType(EmitterState& state, ImageDimension dimension);
 
-uint32_t ImageViewSampledImageType(EmitterState& state, ImageViewKind view, bool integer);
+uint32_t LoadSampledImageDescriptor(EmitterState& state, uint32_t resource);
 
-uint32_t ImageViewSizeType(EmitterState& state, ImageViewKind view);
+uint32_t LoadSamplerDescriptor(EmitterState& state, uint32_t sampler);
 
-uint32_t StorageImageType(EmitterState& state, StorageImageClass image_class, ImageViewKind view);
+uint32_t MakeSampledImage(EmitterState& state, uint32_t resource, uint32_t sampler);
 
-uint32_t StorageImagePointerType(EmitterState& state, StorageImageClass image_class,
-                                 ImageViewKind view);
+uint32_t StorageImageDescriptorPointer(EmitterState& state, uint32_t resource);
 
-uint32_t LoadSampledImageDescriptor(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                                    ImageViewKind view);
-
-uint32_t LoadSamplerDescriptor(EmitterState& state, uint32_t sampler, uint32_t use_pc);
-
-uint32_t MakeSampledImage(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                          ImageViewKind view);
-uint32_t MakeSampledImage(EmitterState& state, const IR::MemoryInfo& mem, uint32_t use_pc,
-                          ImageViewKind view, uint32_t image_resource);
-
-ImageViewKind StorageImageViewKind(const IR::MemoryInfo& mem);
-
-uint32_t StorageImageDescriptorPointer(EmitterState& state, uint32_t resource, ImageViewKind view);
-
-void EmitStorageImageWrite(EmitterState& state, uint32_t resource, ImageViewKind view,
-                           uint32_t mip_lod, uint32_t coord, uint32_t texel);
+void EmitStorageImageWrite(EmitterState& state, uint32_t resource, uint32_t mip_lod, uint32_t coord,
+                           uint32_t texel);
 
 uint32_t ExecutionModelForStage(ShaderType stage);
 

src/graphics/shader/recompiler/backend/spirv/spirvEmitterMemoryHelpers.cpp

@@ -4,6 +4,7 @@ namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter {
 
 uint32_t EmitShaderDataDwordLoad(EmitterState& state, uint32_t dword_index) {
 	if (state.push_constant_variable != 0) {
+		dword_index += state.program.bindings.push_data_start_dword;
 		const auto pointer = state.builder.AllocateId();
 		const auto value   = state.builder.AllocateId();
 		state.builder.AddFunction({OpAccessChain, TypePushConstantElementPointer(state), pointer,
@@ -12,11 +13,11 @@ uint32_t EmitShaderDataDwordLoad(EmitterState& state, uint32_t dword_index) {
 		state.builder.AddFunction({OpLoad, TypeU32(state), value, pointer});
 		return value;
 	}
-	if (state.vsharp_storage_variable != 0) {
+	if (state.shader_data_storage_variable != 0) {
 		const auto pointer = state.builder.AllocateId();
 		const auto value   = state.builder.AllocateId();
 		state.builder.AddFunction({OpAccessChain, TypeStorageBufferElementPointer(state), pointer,
-		                           state.vsharp_storage_variable, ConstantU32(state, 0),
+		                           state.shader_data_storage_variable, ConstantU32(state, 0),
 		                           ConstantU32(state, dword_index)});
 		state.builder.AddFunction({OpLoad, TypeU32(state), value, pointer});
 		return value;
@@ -117,15 +118,15 @@ MemoryResourceAccess PrepareMemoryResourceAccess(EmitterState& state, const IR::
 				                             mem.resource,
 				                             "storage buffer descriptor array was not emitted");
 			}
-			const auto binding =
+			const auto array_index =
 			    ResourceForDescriptor(state, IR::DescriptorBindingKind::Buffers, mem.resource);
 			access.object_pointer = state.builder.AllocateId();
 			state.builder.AddFunction({OpAccessChain, TypeStorageBufferPointer(state),
 			                           access.object_pointer, state.storage_buffer_variable,
-			                           ConstantU32(state, binding.array_index)});
-			access.index_offset     = EmitBinaryU32(state, OpShiftRightLogical,
-			                                        state.memory_byte_offsets[binding.array_index],
-			                                        ConstantU32(state, 2u));
+			                           ConstantU32(state, array_index)});
+			access.index_offset =
+			    EmitBinaryU32(state, OpShiftRightLogical, state.memory_byte_offsets[array_index],
+			                  ConstantU32(state, 2u));
 			access.add_index_offset = true;
 			break;
 		}

src/graphics/shader/recompiler/backend/spirv/spirvEmitterModule.cpp

@@ -119,8 +119,7 @@ uint32_t TypeU32ElementPointer(EmitterState& state, uint32_t storage_class) {
 namespace {
 
 uint32_t PushConstantArrayType(EmitterState& state) {
-	const auto count =
-	    ConstantU32(state, state.program.bindings.push_constant_size / sizeof(uint32_t));
+	const auto count = ConstantU32(state, IR::PushData::DwordCount);
 	return state.builder.DecoratedType(OpTypeArray, {TypeU32(state), count},
 	                                   {{OpDecorate, {DecorationArrayStride, sizeof(uint32_t)}}});
 }
@@ -128,7 +127,7 @@ uint32_t PushConstantArrayType(EmitterState& state) {
 uint32_t PushConstantBlockType(EmitterState& state) {
 	return state.builder.DecoratedType(
 	    OpTypeStruct, {PushConstantArrayType(state)},
-	    {{OpMemberDecorate, {0, DecorationOffset, state.program.bindings.push_constant_offset}},
+	    {{OpMemberDecorate, {0, DecorationOffset, 0}},
 	     {OpDecorate, {DecorationBlock}}});
 }
 
@@ -173,52 +172,37 @@ void DefineDescriptorVariables(EmitterState& state) {
 		state.fault_buffer_variable = state.builder.DefineGlobalVariable(
 		    TypeStorageBufferPointer(state), StorageClassStorageBuffer);
 	}
-	if (state.program.bindings.push_constant_size != 0) {
+	if (state.program.bindings.UsesPushData()) {
 		const auto pointer_type =
 		    TypePointer(state, StorageClassPushConstant, PushConstantBlockType(state));
 		state.push_constant_variable =
 		    state.builder.DefineGlobalVariable(pointer_type, StorageClassPushConstant);
 	}
-	if (DescriptorBinding(state, IR::DescriptorBindingKind::UserData) != nullptr) {
-		state.vsharp_storage_variable = state.builder.DefineGlobalVariable(
+	if (DescriptorBinding(state, IR::DescriptorBindingKind::ShaderData) != nullptr) {
+		state.shader_data_storage_variable = state.builder.DefineGlobalVariable(
 		    TypeStorageBufferPointer(state), StorageClassStorageBuffer);
 	}
 	if (DescriptorBinding(state, IR::DescriptorBindingKind::FlattenedSrt) != nullptr) {
 		state.flattened_srt_variable = state.builder.DefineGlobalVariable(
 		    TypeStorageBufferPointer(state), StorageClassStorageBuffer);
 	}
-	for (uint32_t i = 0; i < state.sampled_image_variables.size(); i++) {
-		const auto view    = static_cast<ImageViewKind>(i % SampledImageViewKindCount);
-		const bool integer = i >= SampledImageViewKindCount;
-		const auto kind    = SampledBindingKind(integer, view);
-		if (DescriptorBinding(state, kind) == nullptr) {
+	for (const auto& binding: state.program.bindings.descriptors) {
+		if (IR::ImageBindingResourceClass(binding.kind) == IR::ImageResourceClass::None) {
 			continue;
 		}
-		const auto count        = ConstantU32(state, DescriptorCount(state, kind));
-		const auto image_type   = ImageViewImageType(state, view, integer);
-		const auto array_type   = state.builder.Type(OpTypeArray, {image_type, count});
-		const auto pointer_type = TypePointer(state, StorageClassUniformConstant, array_type);
-		state.sampled_image_variables[i] =
+		const auto& image        = state.program.info.images.at(binding.resources.front());
+		const auto  count        = ConstantU32(state, DescriptorCount(state, binding.kind));
+		const auto  image_type   = ImageType(state, image);
+		const auto  array_type   = state.builder.Type(OpTypeArray, {image_type, count});
+		const auto  pointer_type = TypePointer(state, StorageClassUniformConstant, array_type);
+		state.image_variables[IR::ImageBindingIndex(binding.kind)] =
 		    state.builder.DefineGlobalVariable(pointer_type, StorageClassUniformConstant);
-		if (view == ImageViewKind::Dim1D || view == ImageViewKind::Dim1DArray) {
-			state.builder.RequireCapability(CapabilitySampled1D);
-		}
-	}
-	for (uint32_t i = 0; i < state.storage_image_variables.size(); i++) {
-		const auto view        = static_cast<ImageViewKind>(i % StorageImageViewKindCount);
-		const auto image_class = static_cast<StorageImageClass>(i / StorageImageViewKindCount);
-		const auto kind        = StorageBindingKind(image_class, view);
-		if (DescriptorBinding(state, kind) == nullptr) {
-			continue;
-		}
-		const auto count        = ConstantU32(state, DescriptorCount(state, kind));
-		const auto image_type   = StorageImageType(state, image_class, view);
-		const auto array_type   = state.builder.Type(OpTypeArray, {image_type, count});
-		const auto pointer_type = TypePointer(state, StorageClassUniformConstant, array_type);
-		state.storage_image_variables[i] =
-		    state.builder.DefineGlobalVariable(pointer_type, StorageClassUniformConstant);
-		if (view == ImageViewKind::Dim1D || view == ImageViewKind::Dim1DArray) {
-			state.builder.RequireCapability(CapabilityImage1D);
+		if (image.dimension == ImageDimension::Dim1D ||
+		    image.dimension == ImageDimension::Dim1DArray) {
+			const auto capability = image.resource_class == IR::ImageResourceClass::Sampled
+			                            ? CapabilitySampled1D
+			                            : CapabilityImage1D;
+			state.builder.RequireCapability(capability);
 		}
 	}
 	if (DescriptorBinding(state, IR::DescriptorBindingKind::Samplers) != nullptr) {
@@ -594,45 +578,13 @@ void AddDescriptorAnnotationsAndNames(EmitterState& state) {
 		Decorate(state.fault_buffer_variable, "fault_buffer",
 		         IR::DescriptorBindingKind::FaultBuffer);
 	}
-	constexpr const char* SampledNames[] = {"sampled_1d",
-	                                        "sampled_1d_array",
-	                                        "sampled_2d",
-	                                        "sampled_2d_array",
-	                                        "sampled_3d",
-	                                        "sampled_2d_msaa",
-	                                        "sampled_2d_msaa_array",
-	                                        "sampled_uint_1d",
-	                                        "sampled_uint_1d_array",
-	                                        "sampled_uint_2d",
-	                                        "sampled_uint_2d_array",
-	                                        "sampled_uint_3d",
-	                                        "sampled_uint_2d_msaa",
-	                                        "sampled_uint_2d_msaa_array"};
-	for (uint32_t i = 0; i < state.sampled_image_variables.size(); i++) {
-		const auto view = static_cast<ImageViewKind>(i % SampledImageViewKindCount);
-		Decorate(state.sampled_image_variables[i], SampledNames[i],
-		         SampledBindingKind(i >= SampledImageViewKindCount, view));
-	}
-	constexpr const char* StorageNames[] = {"storage_1d",
-	                                        "storage_1d_array",
-	                                        "storage_2d",
-	                                        "storage_2d_array",
-	                                        "storage_3d",
-	                                        "storage_uint_1d",
-	                                        "storage_uint_1d_array",
-	                                        "storage_uint_2d",
-	                                        "storage_uint_2d_array",
-	                                        "storage_uint_3d",
-	                                        "storage_atomic_1d",
-	                                        "storage_atomic_1d_array",
-	                                        "storage_atomic_2d",
-	                                        "storage_atomic_2d_array",
-	                                        "storage_atomic_3d"};
-	for (uint32_t i = 0; i < state.storage_image_variables.size(); i++) {
-		const auto view        = static_cast<ImageViewKind>(i % StorageImageViewKindCount);
-		const auto image_class = static_cast<StorageImageClass>(i / StorageImageViewKindCount);
-		Decorate(state.storage_image_variables[i], StorageNames[i],
-		         StorageBindingKind(image_class, view));
+	for (const auto& binding: state.program.bindings.descriptors) {
+		if (IR::ImageBindingResourceClass(binding.kind) == IR::ImageResourceClass::None) {
+			continue;
+		}
+		const auto name = "image_" + std::to_string(static_cast<uint32_t>(binding.kind));
+		Decorate(state.image_variables[IR::ImageBindingIndex(binding.kind)], name.c_str(),
+		         binding.kind);
 	}
 	if (state.sampler_variable != 0) {
 		Decorate(state.sampler_variable, "samplers", IR::DescriptorBindingKind::Samplers);
@@ -651,9 +603,9 @@ void AddVsharpAnnotationsAndNames(EmitterState& state) {
 		state.builder.AddName(PushConstantBlockType(state), "BufferResource");
 		state.builder.AddName(state.push_constant_variable, "vsharp");
 	}
-	if (state.vsharp_storage_variable != 0) {
-		DecorateDescriptor(state, state.vsharp_storage_variable, "user_data",
-		                   IR::DescriptorBindingKind::UserData);
+	if (state.shader_data_storage_variable != 0) {
+		DecorateDescriptor(state, state.shader_data_storage_variable, "shader_data",
+		                   IR::DescriptorBindingKind::ShaderData);
 	}
 }
 

src/graphics/shader/recompiler/frontend/decode/ImageOps.cpp

@@ -202,6 +202,7 @@ constexpr MimgGatherInfo MIMG_GATHER_OPCODE_LIST[] = {
 };
 
 constexpr MimgAtomicInfo MIMG_ATOMIC_OPCODE_LIST[] = {
+    {0x0fu, "image_atomic_swap", Opcode::IMAGE_ATOMIC_SWAP},
     {0x11u, "image_atomic_add", Opcode::IMAGE_ATOMIC_ADD},
     {0x15u, "image_atomic_umin", Opcode::IMAGE_ATOMIC_UMIN},
     {0x17u, "image_atomic_umax", Opcode::IMAGE_ATOMIC_UMAX},

src/graphics/shader/recompiler/frontend/decode/ScalarAluOps.cpp

@@ -27,7 +27,8 @@ constexpr OpcodeMap SOP2_OPCODE_LIST[] = {
     {0x22u, Opcode::S_ASHR_I32},        {0x24u, Opcode::S_BFM_B32},
     {0x25u, Opcode::S_BFM_B64},         {0x26u, Opcode::S_MUL_I32},
     {0x27u, Opcode::S_BFE_U32},         {0x28u, Opcode::S_BFE_I32},
-    {0x29u, Opcode::S_BFE_U64},         {0x2eu, Opcode::S_LSHL1_ADD_U32},
+    {0x29u, Opcode::S_BFE_U64},         {0x2cu, Opcode::S_ABSDIFF_I32},
+    {0x2eu, Opcode::S_LSHL1_ADD_U32},
     {0x2fu, Opcode::S_LSHL2_ADD_U32},   {0x30u, Opcode::S_LSHL3_ADD_U32},
     {0x31u, Opcode::S_LSHL4_ADD_U32},   {0x32u, Opcode::S_PACK_LL_B32_B16},
     {0x33u, Opcode::S_PACK_LH_B32_B16}, {0x34u, Opcode::S_PACK_HH_B32_B16},
@@ -48,7 +49,9 @@ constexpr OpcodeMap SOP1_OPCODE_LIST[] = {
     {0x15u, Opcode::S_FLBIT_I32_B32},
     {0x16u, Opcode::S_FLBIT_I32_B64},
     {0x1bu, Opcode::S_BITSET0_B32},
+    {0x1cu, Opcode::S_BITSET0_B64},
     {0x1du, Opcode::S_BITSET1_B32},
+    {0x1eu, Opcode::S_BITSET1_B64},
     {0x1fu, Opcode::S_GETPC_B64},
     {0x20u, Opcode::S_SETPC_B64},
     {0x24u, Opcode::S_AND_SAVEEXEC_B64},
@@ -93,6 +96,7 @@ constexpr OpcodeMap SOPP_OPCODE_LIST[] = {
     {0x0au, Opcode::S_BARRIER},
     {0x0cu, Opcode::S_WAITCNT},
     {0x0eu, Opcode::S_SLEEP},
+    {0x0fu, Opcode::S_SETPRIO},
     {0x10u, Opcode::S_SENDMSG},
     {0x12u, Opcode::S_TRAP},
     {0x16u, Opcode::S_TTRACEDATA},
@@ -276,6 +280,7 @@ void DecodeSopp(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	                           : static_cast<int32_t>(static_cast<int16_t>(simm));
 	inst.src_count = (inst.opcode == Opcode::S_NOP || inst.opcode == Opcode::S_WAITCNT ||
 	                  inst.opcode == Opcode::S_WAITCNT_DEPCTR || inst.opcode == Opcode::S_SLEEP ||
+	                  inst.opcode == Opcode::S_SETPRIO ||
 	                  inst.opcode == Opcode::S_SENDMSG || inst.opcode == Opcode::S_TRAP ||
 	                  inst.opcode == Opcode::S_TTRACEDATA || inst.opcode == Opcode::S_INST_PREFETCH)
 	                     ? 1

src/graphics/shader/recompiler/frontend/decode/ShaderDecoder.cpp

@@ -479,6 +479,8 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::S_FLBIT_I32_B32:
 		case Opcode::S_FF1_I32_B32:
 		case Opcode::S_FF1_I32_B64:
+		case Opcode::S_BITSET0_B64:
+		case Opcode::S_BITSET1_B64:
 		case Opcode::S_NOT_B64:
 		case Opcode::S_WQM_B64:
 		case Opcode::S_QUADMASK_B64:
@@ -505,6 +507,7 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::S_WAITCNT:
 		case Opcode::S_WAITCNT_DEPCTR:
 		case Opcode::S_SLEEP:
+		case Opcode::S_SETPRIO:
 		case Opcode::S_TRAP:
 		case Opcode::S_SENDMSG:
 		case Opcode::S_TTRACEDATA:
@@ -532,6 +535,7 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::IMAGE_SAMPLE:
 		case Opcode::IMAGE_STORE:
 		case Opcode::IMAGE_STORE_MIP:
+		case Opcode::IMAGE_ATOMIC_SWAP:
 		case Opcode::IMAGE_ATOMIC_ADD:
 		case Opcode::IMAGE_ATOMIC_UMIN:
 		case Opcode::IMAGE_ATOMIC_UMAX:

src/graphics/shader/recompiler/frontend/decode/ShaderDecoder.h

@@ -40,6 +40,7 @@ enum class Opcode {
 	S_MOV_B64,
 	S_MOVK_I32,
 	S_ABS_I32,
+	S_ABSDIFF_I32,
 	S_BREV_B32,
 	S_BCNT1_I32_B32,
 	S_BCNT1_I32_B64,
@@ -69,6 +70,8 @@ enum class Opcode {
 	S_BITCMP1_B32,
 	S_BITSET0_B32,
 	S_BITSET1_B32,
+	S_BITSET0_B64,
+	S_BITSET1_B64,
 	S_MIN_I32,
 	S_MAX_I32,
 	S_MIN_U32,
@@ -108,6 +111,7 @@ enum class Opcode {
 	S_BFM_B64,
 	S_CSELECT_B32,
 	S_CSELECT_B64,
+	S_SETPRIO,
 	S_PACK_LL_B32_B16,
 	S_PACK_LH_B32_B16,
 	S_PACK_HH_B32_B16,
@@ -282,6 +286,7 @@ enum class Opcode {
 	V_MAD_MIXHI_F16,
 	V_ADD_NC_U32,
 	V_ADDC_U32,
+	V_SUB_CO_CI_U32,
 	V_SUBREV_CO_CI_U32,
 	V_SUB_NC_U32,
 	V_SUBREV_NC_U32,
@@ -533,6 +538,7 @@ enum class Opcode {
 	IMAGE_LOAD_MIP,
 	IMAGE_STORE,
 	IMAGE_STORE_MIP,
+	IMAGE_ATOMIC_SWAP,
 	IMAGE_ATOMIC_ADD,
 	IMAGE_ATOMIC_UMIN,
 	IMAGE_ATOMIC_UMAX,

src/graphics/shader/recompiler/frontend/decode/VectorAluOps.cpp

@@ -61,6 +61,7 @@ constexpr Vop2OpcodeInfo VOP2_OPCODE_LIST[] = {
     {0x24u, Opcode::V_MBCNT_HI_U32_B32},
     {0x25u, Opcode::V_ADD_NC_U32, Vop2SdwaProfile::IntegerPartialDestination},
     {0x28u, Opcode::V_ADDC_U32, Vop2SdwaProfile::IntegerFullDestination},
+    {0x29u, Opcode::V_SUB_CO_CI_U32},
     {0x2au, Opcode::V_SUBREV_CO_CI_U32},
     {0x26u, Opcode::V_SUB_NC_U32, Vop2SdwaProfile::IntegerPartialDestination},
     {0x27u, Opcode::V_SUBREV_NC_U32, Vop2SdwaProfile::IntegerFullDestination},
@@ -1033,6 +1034,7 @@ void FinalizeVop2Instruction(std::span<const uint32_t> code, uint32_t word_index
 			inst.src_count = 3;
 			break;
 		case Opcode::V_ADDC_U32:
+		case Opcode::V_SUB_CO_CI_U32:
 		case Opcode::V_SUBREV_CO_CI_U32:
 			inst.dst2.kind = OperandKind::VccLo;
 			inst.src2.kind = OperandKind::VccLo;
@@ -1643,6 +1645,7 @@ void DecodeVop3(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	SetRawWords(inst, code, word_index, 2);
 
 	const bool carry_in_out    = (inst.opcode == Opcode::V_ADDC_U32 && opcode == 0x128u) ||
+	                             (inst.opcode == Opcode::V_SUB_CO_CI_U32 && opcode == 0x129u) ||
 	                             (inst.opcode == Opcode::V_SUBREV_CO_CI_U32 && opcode == 0x12au);
 	const bool vop3b_carry_out = IsVop3BCarryOutOpcode(inst.opcode);
 	const bool vop3b_mad_u64   = IsVop3BMadU64Opcode(inst.opcode);

src/graphics/shader/recompiler/frontend/translate/Control.cpp

@@ -76,9 +76,9 @@ void Translator::SUB_U32(const Decoder::Instruction& inst, bool vector, bool rev
 	}
 }
 
-void Translator::SUBB_U32(const Decoder::Instruction& inst, bool vector) {
-	const auto lhs       = ReadU32(vector ? inst.src1 : inst.src0);
-	const auto rhs       = ReadU32(vector ? inst.src0 : inst.src1);
+void Translator::SUBB_U32(const Decoder::Instruction& inst, bool vector, bool reverse) {
+	const auto lhs       = ReadU32(reverse ? inst.src1 : inst.src0);
+	const auto rhs       = ReadU32(reverse ? inst.src0 : inst.src1);
 	const auto borrow_in = vector ? ConditionBit(inst.src2)
 	                              : ConditionBit(ConditionOperand(Decoder::OperandKind::Scc));
 	const auto partial   = ir.ISub(lhs, rhs);
@@ -94,6 +94,13 @@ void Translator::SUBB_U32(const Decoder::Instruction& inst, bool vector) {
 	}
 }
 
+void Translator::S_ABSDIFF_I32(const Decoder::Instruction& inst) {
+	const auto difference = ir.ISub(ReadU32(inst.src0), ReadU32(inst.src1));
+	const auto result     = IR::U32(ir.Emit(IR::ValueOpcode::IAbs32, {difference}));
+	WriteOperand(DestinationOperand(inst), result);
+	ir.SetScc(ir.INotEqual(result, IR::U32(IR::Value(0u))));
+}
+
 void Translator::S_ADD_SUB_I32(const Decoder::Instruction& inst, bool subtract) {
 	const auto lhs      = ReadU32(inst.src0);
 	const auto rhs      = ReadU32(inst.src1);

src/graphics/shader/recompiler/frontend/translate/Integer.cpp

@@ -312,6 +312,22 @@ bool Translator::S_BITSET_B32(const Decoder::Instruction& inst, bool set) {
 	return true;
 }
 
+bool Translator::S_BITSET_B64(const Decoder::Instruction& inst, bool set) {
+	const auto offset    = ir.BitwiseAnd(ReadU32(inst.src0), IR::U32(IR::Value(63u)));
+	const auto word_bit  = ir.BitwiseAnd(offset, IR::U32(IR::Value(31u)));
+	const auto bit       = ir.ShiftLeftLogical(IR::U32(IR::Value(1u)), word_bit);
+	const auto old       = ReadU32Pair(inst.dst);
+	const auto low_value = set ? ir.BitwiseOr(old[0], bit)
+	                           : ir.BitwiseAnd(old[0], ir.BitwiseNot(bit));
+	const auto high_value = set ? ir.BitwiseOr(old[1], bit)
+	                            : ir.BitwiseAnd(old[1], ir.BitwiseNot(bit));
+	const auto high = IR::U1(ir.Emit(IR::ValueOpcode::UGreaterThanEqual32,
+	                                {offset, IR::Value(32u)}));
+	WriteU32Pair(inst.dst,
+	             {ir.Select(high, old[0], low_value), ir.Select(high, high_value, old[1])});
+	return true;
+}
+
 bool Translator::V_BCNT_U32_B32(const Decoder::Instruction& inst) {
 	const auto count = IR::U32(ir.Emit(IR::ValueOpcode::BitCount32, {ReadU32(inst.src0)}));
 	WriteOperand(DestinationOperand(inst), ir.IAdd(count, ReadU32(inst.src1)));

src/graphics/shader/recompiler/frontend/translate/Memory.cpp

@@ -84,18 +84,7 @@ ResourceKind MemoryKind(const Decoder::Instruction& decoded) {
 		case Decoder::Family::MTBUF: return ResourceKind::Buffer;
 		case Decoder::Family::FLAT: return FlatSegmentResourceKind(decoded.memory_segment);
 		case Decoder::Family::DS: return decoded.gds ? ResourceKind::Gds : ResourceKind::Lds;
-		case Decoder::Family::MIMG:
-			switch (decoded.opcode) {
-				case Decoder::Opcode::IMAGE_STORE:
-				case Decoder::Opcode::IMAGE_STORE_MIP: return ResourceKind::StorageImage;
-				case Decoder::Opcode::IMAGE_ATOMIC_ADD:
-				case Decoder::Opcode::IMAGE_ATOMIC_UMIN:
-				case Decoder::Opcode::IMAGE_ATOMIC_UMAX:
-				case Decoder::Opcode::IMAGE_ATOMIC_AND:
-				case Decoder::Opcode::IMAGE_ATOMIC_OR:
-				case Decoder::Opcode::IMAGE_ATOMIC_XOR: return ResourceKind::StorageImageUint;
-				default: return ResourceKind::Image;
-			}
+		case Decoder::Family::MIMG: return ResourceKind::Image;
 		default: return ResourceKind::None;
 	}
 }
@@ -153,10 +142,6 @@ IR::MemoryInfo MemoryInfoFromDecoded(const Decoder::Instruction& decoded) {
 	           decoded.opcode == Decoder::Opcode::DS_WRITE2ST64_B32) {
 		memory.data_dwords = 2u;
 	}
-	if (memory.kind == ResourceKind::StorageImage ||
-	    memory.kind == ResourceKind::StorageImageUint) {
-		memory.sampler = 0;
-	}
 	return memory;
 }
 
@@ -238,9 +223,12 @@ Decoder::Operand MemorySourceAt(const Decoder::Instruction& decoded, uint32_t in
 	if (decoded.family == Decoder::Family::MIMG) {
 		const bool store_or_atomic = decoded.opcode == Decoder::Opcode::IMAGE_STORE ||
 		                             decoded.opcode == Decoder::Opcode::IMAGE_STORE_MIP ||
-		                             (decoded.opcode >= Decoder::Opcode::IMAGE_ATOMIC_ADD &&
+		                             (decoded.opcode >= Decoder::Opcode::IMAGE_ATOMIC_SWAP &&
 		                              decoded.opcode <= Decoder::Opcode::IMAGE_ATOMIC_XOR);
-		return store_or_atomic ? (index == 0u ? decoded.dst : decoded.src0) : decoded.src0;
+		if (store_or_atomic) {
+			return index == 0u ? decoded.dst : decoded.src0;
+		}
+		return decoded.src0;
 	}
 	if (decoded.family == Decoder::Family::DS) {
 		switch (decoded.opcode) {
@@ -993,6 +981,8 @@ bool Translator::EmitMemory(const Decoder::Instruction& inst) {
 		case Decoder::Opcode::DS_WRXCHG_RTN_B32:
 			return DS_ATOMIC(inst, IR::ValueOpcode::SharedAtomicSwap32, true);
 
+		case Decoder::Opcode::IMAGE_ATOMIC_SWAP:
+			return IMAGE_ATOMIC(inst, IR::ValueOpcode::ImageAtomicSwap32);
 		case Decoder::Opcode::IMAGE_ATOMIC_ADD:
 			return IMAGE_ATOMIC(inst, IR::ValueOpcode::ImageAtomicIAdd32);
 		case Decoder::Opcode::IMAGE_ATOMIC_UMIN:

src/graphics/shader/recompiler/frontend/translate/Scalar.cpp

@@ -34,7 +34,8 @@ bool Translator::EmitScalar(const Decoder::Instruction& inst) {
 		case O::S_ADD_U32: ADD_U32(inst, false, false); return true;
 		case O::S_ADDC_U32: ADD_U32(inst, false, true); return true;
 		case O::S_SUB_U32: SUB_U32(inst, false, false); return true;
-		case O::S_SUBB_U32: SUBB_U32(inst, false); return true;
+		case O::S_SUBB_U32: SUBB_U32(inst, false, false); return true;
+		case O::S_ABSDIFF_I32: S_ABSDIFF_I32(inst); return true;
 		case O::S_ADD_I32: S_ADD_SUB_I32(inst, false); return true;
 		case O::S_SUB_I32: S_ADD_SUB_I32(inst, true); return true;
 		case O::S_LSHL1_ADD_U32: S_LSHL_ADD_U32(inst, 1u); return true;
@@ -186,6 +187,8 @@ bool Translator::EmitScalar(const Decoder::Instruction& inst) {
 
 		case O::S_BITSET0_B32: return S_BITSET_B32(inst, false);
 		case O::S_BITSET1_B32: return S_BITSET_B32(inst, true);
+		case O::S_BITSET0_B64: return S_BITSET_B64(inst, false);
+		case O::S_BITSET1_B64: return S_BITSET_B64(inst, true);
 		case O::S_BITREPLICATE_B64_B32: return S_BITREPLICATE_B64_B32(inst);
 		case O::S_QUADMASK_B64: return S_QUADMASK_B64(inst);
 		case O::S_BFM_B32: return BFM_B32(inst);
@@ -201,6 +204,7 @@ bool Translator::EmitScalar(const Decoder::Instruction& inst) {
 
 		case O::S_NOP:
 		case O::S_SLEEP:
+		case O::S_SETPRIO:
 		case O::S_TRAP: EmitControlNop(); return true;
 		case O::S_WAITCNT_DEPCTR: EmitWaitcnt(); return true;
 		case O::S_BARRIER: S_BARRIER(); return true;

src/graphics/shader/recompiler/frontend/translate/Translator.h

@@ -192,6 +192,7 @@ private:
 	bool V_SAD_U32(const Decoder::Instruction& inst);
 	bool V_ADD3_U32(const Decoder::Instruction& inst);
 	bool S_BITSET_B32(const Decoder::Instruction& inst, bool set);
+	bool S_BITSET_B64(const Decoder::Instruction& inst, bool set);
 	bool V_BCNT_U32_B32(const Decoder::Instruction& inst);
 	bool V_MBCNT_U32_B32(const Decoder::Instruction& inst, bool low);
 	bool S_BITREPLICATE_B64_B32(const Decoder::Instruction& inst);
@@ -218,7 +219,8 @@ private:
 	                bool negate_source, bool write_64);
 	void ADD_U32(const Decoder::Instruction& inst, bool vector, bool use_carry_in);
 	void SUB_U32(const Decoder::Instruction& inst, bool vector, bool reverse);
-	void SUBB_U32(const Decoder::Instruction& inst, bool vector);
+	void SUBB_U32(const Decoder::Instruction& inst, bool vector, bool reverse);
+	void S_ABSDIFF_I32(const Decoder::Instruction& inst);
 	void S_ADD_SUB_I32(const Decoder::Instruction& inst, bool subtract);
 	void S_LSHL_ADD_U32(const Decoder::Instruction& inst, uint32_t shift_amount);
 	void ScalarMinMax32(const Decoder::Instruction& inst, IR::ValueOpcode value_opcode,

src/graphics/shader/recompiler/frontend/translate/Vector.cpp

@@ -10,7 +10,8 @@ bool Translator::EmitVector(const Decoder::Instruction& inst) {
 		case O::V_ADDC_U32: ADD_U32(inst, true, true); return true;
 		case O::V_SUB_I32: SUB_U32(inst, true, false); return true;
 		case O::V_SUBREV_I32: SUB_U32(inst, true, true); return true;
-		case O::V_SUBREV_CO_CI_U32: SUBB_U32(inst, true); return true;
+		case O::V_SUB_CO_CI_U32: SUBB_U32(inst, true, false); return true;
+		case O::V_SUBREV_CO_CI_U32: SUBB_U32(inst, true, true); return true;
 
 		case O::V_MOV_B32: MOV_B32(inst, true); return true;
 		case O::V_MOVRELS_B32: V_MOVRELS_B32(inst); return true;

src/graphics/shader/recompiler/ir/Program.cpp

@@ -54,7 +54,7 @@ bool IsRuntimeRead(ValueOpcode opcode) {
 	       AddressOpcodeInfoOf(opcode).access == AddressAccess::Read;
 }
 
-bool EquivalentValue(const Program& program, Value left, Value right,
+bool EquivalentValue(const ResourcePlan& program, Value left, Value right,
                      std::vector<std::pair<const Inst*, const Inst*>>& visited) {
 	left  = left.Resolve();
 	right = right.Resolve();
@@ -97,6 +97,20 @@ bool EquivalentValue(const Program& program, Value left, Value right,
 
 } // namespace
 
+ResourcePlan::~ResourcePlan() {
+	for (auto& inst: value_storage) {
+		inst.Invalidate();
+	}
+}
+
+ResourcePlan& ResourcePlan::operator=(ResourcePlan&& other) noexcept {
+	if (this != &other) {
+		this->~ResourcePlan();
+		new (this) ResourcePlan(std::move(other));
+	}
+	return *this;
+}
+
 Program::~Program() {
 	// Values may cross block boundaries. Detach all arguments before any block starts destroying
 	// its instruction storage so reverse-use links always point to live definitions.
@@ -115,12 +129,31 @@ Program& Program::operator=(Program&& other) noexcept {
 	return *this;
 }
 
-bool EquivalentValue(const Program& program, Value left, Value right) {
+CompiledShaderInfo Program::TakeCompiledInfo() && {
+	CompiledShaderInfo result {
+	    .stage           = stage,
+	    .shader_hash     = shader_hash,
+	    .wave_size       = wave_size,
+	    .user_data_base  = user_data_base,
+	    .user_data_count = user_data_count,
+	    .scratch_dwords  = scratch_dwords,
+	    .info            = std::move(info),
+	    .bindings        = std::move(bindings),
+	};
+	for (const auto& output: result.info.outputs) {
+		if (output.kind == StageOutputKind::Parameter && output.index < 32) {
+			result.param_export_mask |= 1u << output.index;
+		}
+	}
+	return result;
+}
+
+bool EquivalentValue(const ResourcePlan& program, Value left, Value right) {
 	std::vector<std::pair<const Inst*, const Inst*>> visited;
 	return EquivalentValue(program, left, right, visited);
 }
 
-Value ResolveInvariantPhi(const Program& program, Value value) {
+Value ResolveInvariantPhi(const ResourcePlan& program, Value value) {
 	value            = value.Resolve();
 	const auto* root = value.TryInstruction();
 	if (root == nullptr || root->GetOpcode() != ValueOpcode::Phi) {
@@ -450,7 +483,8 @@ void ValidateProgram(const Program& program, bool require_ssa) {
 					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
-				if (!ImageResourceKindMatches(memory.kind, image_info.resource_class)) {
+				if (memory.kind != ResourceKind::Image ||
+				    image_info.resource_class == ImageResourceClass::None) {
 					return Fail(fmt::format("{} has invalid image-memory metadata",
 					                        ValueOpcodeName(inst.GetOpcode())));
 				}

src/graphics/shader/recompiler/ir/ResourceSnapshot.h

@@ -0,0 +1,29 @@
+#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_RESOURCESNAPSHOT_H_
+#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_RESOURCESNAPSHOT_H_
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+namespace Libs::Graphics::ShaderRecompiler::IR {
+
+struct DescriptorValue {
+	std::array<uint32_t, 8> dwords      = {};
+	uint32_t                dword_count = 0;
+
+	bool operator==(const DescriptorValue& other) const {
+		return dword_count == other.dword_count && dwords == other.dwords;
+	}
+};
+
+struct ResourceSnapshot {
+	std::vector<DescriptorValue> buffers;
+	std::vector<DescriptorValue> images;
+	std::vector<DescriptorValue> samplers;
+	std::vector<uint32_t>        flattened_srt;
+	std::vector<uint32_t>        user_data;
+};
+
+} // namespace Libs::Graphics::ShaderRecompiler::IR
+
+#endif // EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_RESOURCESNAPSHOT_H_

src/graphics/shader/recompiler/ir/ShaderIR.h

@@ -4,14 +4,17 @@
 #include "common/common.h"
 #include "common/stringUtils.h"
 #include "graphics/guest_gpu/gpu_defs.h"
+#include "graphics/guest_gpu/gpu_format.h"
 #include "graphics/shader/recompiler/frontend/cfg/ShaderCFG.h"
 #include "graphics/shader/recompiler/frontend/decode/ShaderDecoder.h"
 #include "graphics/shader/recompiler/ir/Block.h"
+#include "graphics/shader/recompiler/ir/ResourceSnapshot.h"
 #include "graphics/shader/recompiler/ir/opcodes/ValueOpcodes.h"
 #include "graphics/shader/shader.h"
 
 #include <array>
 #include <bit>
+#include <list>
 #include <memory>
 #include <optional>
 #include <string_view>
@@ -30,9 +33,6 @@ enum class ResourceKind {
 	Lds,
 	Gds,
 	Image,
-	ImageUint,
-	StorageImage,
-	StorageImageUint,
 	Sampler
 };
 
@@ -41,19 +41,6 @@ enum class ResourceKind {
 	       kind == ResourceKind::Global || kind == ResourceKind::Scratch;
 }
 
-[[nodiscard]] constexpr bool ImageResourceKindMatches(ResourceKind       kind,
-                                                      ImageResourceClass resource_class) {
-	switch (resource_class) {
-		case ImageResourceClass::Sampled:
-			return kind == ResourceKind::Image || kind == ResourceKind::ImageUint;
-		case ImageResourceClass::Storage:
-			return kind == ResourceKind::StorageImage || kind == ResourceKind::StorageImageUint;
-		case ImageResourceClass::StorageUint: return kind == ResourceKind::StorageImageUint;
-		case ImageResourceClass::None: return false;
-	}
-	return false;
-}
-
 struct MemoryInfo {
 	ResourceKind            kind                     = ResourceKind::None;
 	uint32_t                resource                 = 0;
@@ -78,7 +65,6 @@ struct MemoryInfo {
 	bool                    typed                                                 = false;
 	bool                    formatted                                             = false;
 	bool                    image_has_mip                                         = false;
-	bool                    image_cube                                            = false;
 	bool                    image_r128                                            = false;
 	bool                    glc                                                   = false;
 	bool                    slc                                                   = false;
@@ -103,15 +89,6 @@ struct ExportInfo {
 	bool operator==(const ExportInfo& other) const = default;
 };
 
-struct DescriptorValue {
-	std::array<uint32_t, 8> dwords      = {};
-	uint32_t                dword_count = 0;
-
-	bool operator==(const DescriptorValue& other) const {
-		return dword_count == other.dword_count && dwords == other.dwords;
-	}
-};
-
 struct BufferResource {
 	static constexpr uint32_t NoImageAlias = UINT32_MAX;
 
@@ -138,24 +115,25 @@ constexpr uint32_t ShaderImageIdentitySwizzle = 0x00000facu;
 struct ImageResource {
 	static constexpr uint32_t NoIndirectImage = UINT32_MAX;
 
-	uint32_t                source                    = 0;
-	uint32_t                first_use_pc              = 0;
-	ResourceKind            kind                      = ResourceKind::None;
-	Decoder::ImageDimension dimension                 = Decoder::ImageDimension::Unknown;
-	ImageMipMode            mip_mode                  = ImageMipMode::None;
-	uint32_t                mip_count                 = 1;
-	Prospero::BufferFormat  conversion_format         = Prospero::BufferFormat::kInvalid;
-	uint32_t                shader_swizzle            = ShaderImageIdentitySwizzle;
-	bool                    read                      = false;
-	bool                    written                   = false;
-	bool                    atomic                    = false;
-	bool                    depth_compare             = false;
-	bool                    cube                      = false;
-	bool                    r128                      = false;
-	uint32_t                indirect_root             = NoIndirectImage;
-	uint32_t                indirect_mapping_offset   = 0;
-	uint32_t                indirect_mapping_capacity = 0;
-	std::vector<uint32_t>   indirect_resources;
+	uint32_t                      source            = 0;
+	uint32_t                      first_use_pc      = 0;
+	ImageResourceClass            resource_class    = ImageResourceClass::None;
+	Prospero::TextureNumericClass numeric_class     = Prospero::TextureNumericClass::Unsupported;
+	Decoder::ImageDimension       dimension         = Decoder::ImageDimension::Unknown;
+	ImageMipMode                  mip_mode          = ImageMipMode::None;
+	uint32_t                      mip_count         = 1;
+	Prospero::BufferFormat        conversion_format = Prospero::BufferFormat::kInvalid;
+	uint32_t                      shader_swizzle    = ShaderImageIdentitySwizzle;
+	bool                          read              = false;
+	bool                          written           = false;
+	bool                          atomic            = false;
+	bool                          depth_compare     = false;
+	bool                          cube              = false;
+	bool                          r128              = false;
+	uint32_t                      indirect_root     = NoIndirectImage;
+	uint32_t                      indirect_mapping_offset   = 0;
+	uint32_t                      indirect_search_iterations = 0;
+	std::vector<uint32_t>         indirect_resources;
 
 	bool operator==(const ImageResource& other) const = default;
 };
@@ -164,6 +142,7 @@ struct SamplerResource {
 	uint32_t source                = 0;
 	uint32_t first_use_pc          = 0;
 	bool     force_point_filtering = false;
+	bool     depth_compare         = false;
 
 	bool operator==(const SamplerResource& other) const = default;
 };
@@ -274,124 +253,126 @@ struct StageOutput {
 	bool operator==(const StageOutput& other) const = default;
 };
 
-enum class DescriptorBindingKind {
-	Buffers,
-	Sampled1D,
-	Sampled1DArray,
-	Sampled2D,
-	Sampled2DArray,
-	Sampled2DMsaa,
-	Sampled2DMsaaArray,
-	Sampled3D,
-	SampledUint1D,
-	SampledUint1DArray,
-	SampledUint2D,
-	SampledUint2DArray,
-	SampledUint2DMsaa,
-	SampledUint2DMsaaArray,
-	SampledUint3D,
-	Storage1D,
-	Storage1DArray,
-	Storage2D,
-	Storage2DArray,
-	Storage3D,
-	StorageUint1D,
-	StorageUint1DArray,
-	StorageUint2D,
-	StorageUint2DArray,
-	StorageUint3D,
-	StorageAtomic1D,
-	StorageAtomic1DArray,
-	StorageAtomic2D,
-	StorageAtomic2DArray,
-	StorageAtomic3D,
-	Samplers,
+inline constexpr uint32_t FirstImageBinding        = 1u;
+inline constexpr uint32_t FirstStorageImageBinding = 22u;
+inline constexpr uint32_t ImageBindingCount        = 36u;
+
+enum class DescriptorBindingKind : uint32_t {
+	Buffers  = 0u,
+	Samplers = FirstImageBinding + ImageBindingCount,
 	Gds,
 	BdaPagetable,
 	FaultBuffer,
 	FlattenedSrt,
-	UserData,
+	ShaderData,
 	Count,
 };
 
-constexpr uint32_t NativePushConstantSize = 128;
+static_assert(static_cast<uint32_t>(DescriptorBindingKind::Samplers) == 37u);
+static_assert(static_cast<uint32_t>(DescriptorBindingKind::Count) == 43u);
+
+struct PushData {
+	static constexpr uint32_t DwordCount = 32;
+	static constexpr uint32_t NoStart    = UINT32_MAX;
+	std::array<uint32_t, DwordCount> dwords {};
+
+	[[nodiscard]] static constexpr bool CanFit(uint32_t start, uint32_t size) {
+		return size != 0 && start <= DwordCount && size <= DwordCount - start;
+	}
+	[[nodiscard]] static constexpr uint32_t StartFor(uint32_t cursor, uint32_t size) {
+		return CanFit(cursor, size) ? cursor : NoStart;
+	}
+};
+
+static_assert(sizeof(PushData) == 128);
+constexpr uint32_t NativePushConstantSize = sizeof(PushData);
 
 [[nodiscard]] constexpr uint32_t NativeBinding(ShaderType stage, DescriptorBindingKind kind) {
 	return static_cast<uint32_t>(kind) +
 	       (stage == ShaderType::Pixel ? static_cast<uint32_t>(DescriptorBindingKind::Count) : 0u);
 }
 
-[[nodiscard]] inline std::optional<DescriptorBindingKind>
-DescriptorBindingForImage(const ImageResource& image) {
-	using Dimension = Decoder::ImageDimension;
-	using Kind      = DescriptorBindingKind;
+[[nodiscard]] constexpr ImageResourceClass ImageBindingResourceClass(DescriptorBindingKind kind) {
+	const auto value = static_cast<uint32_t>(kind);
+	if (value >= FirstImageBinding && value < FirstStorageImageBinding) {
+		return ImageResourceClass::Sampled;
+	}
+	if (value >= FirstStorageImageBinding &&
+	    value < static_cast<uint32_t>(DescriptorBindingKind::Samplers)) {
+		return ImageResourceClass::Storage;
+	}
+	return ImageResourceClass::None;
+}
 
-	switch (image.kind) {
-		case ResourceKind::Image:
-			switch (image.dimension) {
-				case Dimension::Dim1D: return Kind::Sampled1D;
-				case Dimension::Dim1DArray: return Kind::Sampled1DArray;
-				case Dimension::Dim2D: return Kind::Sampled2D;
-				case Dimension::Dim2DArray: return Kind::Sampled2DArray;
-				case Dimension::Dim2DMsaa: return Kind::Sampled2DMsaa;
-				case Dimension::Dim2DMsaaArray: return Kind::Sampled2DMsaaArray;
-				case Dimension::Dim3D: return Kind::Sampled3D;
-				default: return std::nullopt;
-			}
-		case ResourceKind::ImageUint:
-			switch (image.dimension) {
-				case Dimension::Dim1D: return Kind::SampledUint1D;
-				case Dimension::Dim1DArray: return Kind::SampledUint1DArray;
-				case Dimension::Dim2D: return Kind::SampledUint2D;
-				case Dimension::Dim2DArray: return Kind::SampledUint2DArray;
-				case Dimension::Dim2DMsaa: return Kind::SampledUint2DMsaa;
-				case Dimension::Dim2DMsaaArray: return Kind::SampledUint2DMsaaArray;
-				case Dimension::Dim3D: return Kind::SampledUint3D;
-				default: return std::nullopt;
-			}
-		case ResourceKind::StorageImage:
-			if (image.atomic) {
+[[nodiscard]] constexpr uint32_t ImageBindingIndex(DescriptorBindingKind kind) {
+	return static_cast<uint32_t>(kind) - FirstImageBinding;
+}
+
+[[nodiscard]] constexpr std::optional<DescriptorBindingKind>
+DescriptorBindingForImage(const ImageResource& image) {
+	constexpr uint32_t SampledFloatBinding = 1u;
+	constexpr uint32_t SampledUintBinding  = 8u;
+	constexpr uint32_t SampledSintBinding  = 15u;
+	constexpr uint32_t StorageFloatBinding = 22u;
+	constexpr uint32_t StorageUintBinding  = 27u;
+	constexpr uint32_t AtomicUintBinding   = 32u;
+
+	uint32_t base    = 0;
+	bool     sampled = false;
+	if (image.resource_class == ImageResourceClass::Sampled) {
+		if (image.atomic) {
+			return std::nullopt;
+		}
+		sampled = true;
+		switch (image.numeric_class) {
+			case Prospero::TextureNumericClass::Float: base = SampledFloatBinding; break;
+			case Prospero::TextureNumericClass::Uint: base = SampledUintBinding; break;
+			case Prospero::TextureNumericClass::Sint: base = SampledSintBinding; break;
+			case Prospero::TextureNumericClass::Unsupported: return std::nullopt;
+			default: return std::nullopt;
+		}
+	} else if (image.resource_class == ImageResourceClass::Storage) {
+		if (image.atomic) {
+			if (image.numeric_class != Prospero::TextureNumericClass::Uint) {
 				return std::nullopt;
 			}
-			switch (image.dimension) {
-				case Dimension::Dim1D: return Kind::Storage1D;
-				case Dimension::Dim1DArray: return Kind::Storage1DArray;
-				case Dimension::Dim2D: return Kind::Storage2D;
-				case Dimension::Dim2DArray: return Kind::Storage2DArray;
-				case Dimension::Dim3D: return Kind::Storage3D;
+			base = AtomicUintBinding;
+		} else {
+			switch (image.numeric_class) {
+				case Prospero::TextureNumericClass::Float: base = StorageFloatBinding; break;
+				case Prospero::TextureNumericClass::Uint: base = StorageUintBinding; break;
+				case Prospero::TextureNumericClass::Sint:
+				case Prospero::TextureNumericClass::Unsupported: return std::nullopt;
 				default: return std::nullopt;
 			}
-		case ResourceKind::StorageImageUint:
-			switch (image.dimension) {
-				case Dimension::Dim1D:
-					if (image.atomic) {
-						return Kind::StorageAtomic1D;
-					}
-					return Kind::StorageUint1D;
-				case Dimension::Dim1DArray:
-					if (image.atomic) {
-						return Kind::StorageAtomic1DArray;
-					}
-					return Kind::StorageUint1DArray;
-				case Dimension::Dim2D:
-					if (image.atomic) {
-						return Kind::StorageAtomic2D;
-					}
-					return Kind::StorageUint2D;
-				case Dimension::Dim2DArray:
-					if (image.atomic) {
-						return Kind::StorageAtomic2DArray;
-					}
-					return Kind::StorageUint2DArray;
-				case Dimension::Dim3D:
-					if (image.atomic) {
-						return Kind::StorageAtomic3D;
-					}
-					return Kind::StorageUint3D;
-				default: return std::nullopt;
+		}
+	} else {
+		return std::nullopt;
+	}
+
+	uint32_t dimension = 0;
+	switch (image.dimension) {
+		case Decoder::ImageDimension::Dim1D: break;
+		case Decoder::ImageDimension::Dim1DArray: dimension = 1u; break;
+		case Decoder::ImageDimension::Dim2D: dimension = 2u; break;
+		case Decoder::ImageDimension::Dim2DArray: dimension = 3u; break;
+		case Decoder::ImageDimension::Dim2DMsaa:
+			if (!sampled) {
+				return std::nullopt;
 			}
+			dimension = 4u;
+			break;
+		case Decoder::ImageDimension::Dim2DMsaaArray:
+			if (!sampled) {
+				return std::nullopt;
+			}
+			dimension = 5u;
+			break;
+		case Decoder::ImageDimension::Dim3D: dimension = sampled ? 6u : 4u; break;
+		case Decoder::ImageDimension::Unknown: return std::nullopt;
 		default: return std::nullopt;
 	}
+	return static_cast<DescriptorBindingKind>(base + dimension);
 }
 
 struct DescriptorBinding {
@@ -402,8 +383,7 @@ struct DescriptorBinding {
 };
 
 struct BindingLayout {
-	uint32_t                       push_constant_offset = 0;
-	uint32_t                       push_constant_size  = 0;
+	uint32_t                       push_data_start_dword = PushData::NoStart;
 	uint32_t                       memory_offset_dword = 0;
 	uint32_t                       memory_offset_count = 0;
 	std::vector<uint32_t>          user_data_registers;
@@ -412,6 +392,14 @@ struct BindingLayout {
 	[[nodiscard]] uint32_t ShaderDataDwords() const {
 		return memory_offset_dword + (memory_offset_count + 3u) / 4u;
 	}
+	[[nodiscard]] bool UsesPushData() const {
+		return push_data_start_dword != PushData::NoStart;
+	}
+	void AdvancePushData(uint32_t& cursor) const {
+		if (UsesPushData()) {
+			cursor = push_data_start_dword + ShaderDataDwords();
+		}
+	}
 
 	bool operator==(const BindingLayout& other) const = default;
 };
@@ -481,7 +469,47 @@ struct SrtRead {
 	bool operator==(const SrtRead& other) const = default;
 };
 
-struct Program {
+// Stable shader metadata consumed by the renderer after native IR has been discarded.
+struct CompiledShaderInfo {
+	ShaderType                    stage               = ShaderType::Unknown;
+	uint64_t                      shader_hash         = 0;
+	uint32_t                      wave_size           = 64;
+	uint32_t                      user_data_base      = 0;
+	uint32_t                      user_data_count     = 64;
+	uint32_t                      scratch_dwords      = 0;
+	uint32_t                      param_export_mask   = 0;
+	ShaderInfo                    info;
+	BindingLayout                 bindings;
+};
+
+// Immutable runtime resource analysis retained by the shader cache. It owns only the native
+// value graph reachable from descriptors/SRT reads, rather than the translated shader CFG.
+struct ResourcePlan {
+	ResourcePlan() = default;
+	~ResourcePlan();
+
+	ResourcePlan(const ResourcePlan&)            = delete;
+	ResourcePlan& operator=(const ResourcePlan&) = delete;
+	ResourcePlan(ResourcePlan&&) noexcept         = default;
+	ResourcePlan& operator=(ResourcePlan&& other) noexcept;
+
+	ShaderType                    stage           = ShaderType::Unknown;
+	uint64_t                      shader_hash     = 0;
+	uint32_t                      user_data_base  = 0;
+	uint32_t                      user_data_count = 64;
+	std::list<Inst>                     value_storage;
+	std::vector<MemoryInfo>             memory_info;
+	std::vector<DescriptorSource>       descriptor_sources;
+	std::vector<uint32_t>               materialization_sources;
+	std::vector<SrtRead>                srt_reads;
+	std::vector<uint8_t>                clean_flat_slots;
+	bool                                requires_specialization_memory = false;
+	bool                                srt_plan_complete          = false;
+	bool                                resource_tracking_complete = false;
+	ShaderInfo                          info;
+};
+
+struct Program: ResourcePlan {
 	Program() = default;
 	~Program();
 
@@ -489,31 +517,22 @@ struct Program {
 	Program& operator=(const Program&) = delete;
 	Program(Program&&) noexcept         = default;
 	Program& operator=(Program&& other) noexcept;
+	CompiledShaderInfo TakeCompiledInfo() &&;
 
-	ShaderType                    stage               = ShaderType::Unknown;
-	uint64_t                      shader_hash         = 0;
-	uint32_t                      wave_size           = 64;
-	uint32_t                      user_data_base      = 0;
-	uint32_t                      user_data_count     = 64;
-	uint32_t                      scratch_dwords      = 0;
+	std::vector<std::unique_ptr<Block>> block_storage;
+	BlockList                           blocks;
+	uint32_t                      wave_size      = 64;
+	uint32_t                      scratch_dwords = 0;
 	bool                          dispatcher_fallback = false;
 	CFG::FailureKind              cfg_failure_kind    = CFG::FailureKind::None;
 	std::string                   fallback_reason;
-	std::vector<std::unique_ptr<Block>> block_storage;
-	BlockList                           blocks;
-	std::vector<BlockInfo>              block_info;
+	std::vector<BlockInfo>        block_info;
 	// Decoded MIMG/VMEM metadata carries details such as RDNA2 NSA address registers and
 	// storage-image swizzles. Typed memory instructions carry a dense index into these shader-local
 	// tables until those fields are consumed by emission.
-	std::vector<MemoryInfo>       memory_info;
 	std::vector<ExportInfo>       export_info;
-	std::vector<DescriptorSource> descriptor_sources;
-	std::vector<SrtRead>          srt_reads;
 	std::vector<Value>            dynamic_reads;
-	bool                          srt_plan_complete = false;
-	ShaderInfo                    info;
-	bool                          resource_tracking_complete = false;
-	bool                          shader_info_complete       = false;
+	bool                          shader_info_complete = false;
 	BindingLayout                 bindings;
 	bool                          binding_layout_complete = false;
 
@@ -524,8 +543,8 @@ std::string ProgramToString(const Program& program);
 
 void  ValidateProgram(const Program& program, bool require_ssa);
 void  ResolveControlFlowIdentities(Program& program);
-bool  EquivalentValue(const Program& program, Value left, Value right);
-Value ResolveInvariantPhi(const Program& program, Value value);
+bool  EquivalentValue(const ResourcePlan& program, Value left, Value right);
+Value ResolveInvariantPhi(const ResourcePlan& program, Value value);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

src/graphics/shader/recompiler/ir/opcodes/ValueOpcodes.cpp

@@ -204,13 +204,14 @@ ImageOpcodeInfo ImageOpcodeInfoOf(ValueOpcode opcode) {
 			return {ImageAccess::Read, ImageResourceClass::Sampled, true};
 		case ValueOpcode::ImageWrite:
 			return {ImageAccess::Write, ImageResourceClass::Storage, false};
+		case ValueOpcode::ImageAtomicSwap32:
 		case ValueOpcode::ImageAtomicIAdd32:
 		case ValueOpcode::ImageAtomicUMin32:
 		case ValueOpcode::ImageAtomicUMax32:
 		case ValueOpcode::ImageAtomicAnd32:
 		case ValueOpcode::ImageAtomicOr32:
 		case ValueOpcode::ImageAtomicXor32:
-			return {ImageAccess::Atomic, ImageResourceClass::StorageUint, false};
+			return {ImageAccess::Atomic, ImageResourceClass::Storage, false};
 		default: return {};
 	}
 }

src/graphics/shader/recompiler/ir/opcodes/ValueOpcodes.h

@@ -20,7 +20,7 @@ enum class BufferAccess { None, Read, Write, Atomic };
 enum class SharedAccess { None, Read, Write, Atomic, Append, Consume };
 enum class AddressAccess { None, Read, Write };
 enum class ImageAccess { None, Read, Write, Atomic };
-enum class ImageResourceClass { None, Sampled, Storage, StorageUint };
+enum class ImageResourceClass { None, Sampled, Storage };
 
 struct AddressOpcodeInfo {
 	AddressAccess access    = AddressAccess::None;

src/graphics/shader/recompiler/ir/opcodes/ValueOpcodes.inc

@@ -268,6 +268,7 @@ VALUE_OPCODE(ImageRead, U32x4, ImageResource, ImageAddress, U1)
 VALUE_OPCODE(ImageWrite, Void, ImageResource, ImageAddress, U32x4, U1)
 VALUE_OPCODE(ImageSampleRaw, U32x4, ImageResource, SamplerResource, ImageAddress)
 VALUE_OPCODE(ImageGatherRaw, U32x4, ImageResource, SamplerResource, ImageAddress)
+VALUE_OPCODE(ImageAtomicSwap32, U32, ImageResource, ImageAddress, U32, U1)
 VALUE_OPCODE(ImageAtomicIAdd32, U32, ImageResource, ImageAddress, U32, U1)
 VALUE_OPCODE(ImageAtomicUMin32, U32, ImageResource, ImageAddress, U32, U1)
 VALUE_OPCODE(ImageAtomicUMax32, U32, ImageResource, ImageAddress, U32, U1)

src/graphics/shader/recompiler/ir/passes/BindingLayout.cpp

@@ -10,11 +10,6 @@
 namespace Libs::Graphics::ShaderRecompiler::IR {
 namespace {
 
-constexpr auto     FirstImageBinding = DescriptorBindingKind::Sampled1D;
-constexpr uint32_t ImageBindingCount =
-    static_cast<uint32_t>(DescriptorBindingKind::StorageAtomic3D) -
-    static_cast<uint32_t>(FirstImageBinding) + 1u;
-
 [[noreturn]] void BindingFail(const char* message) {
 	EXIT("shader binding layout failed: %s", message);
 	std::abort();
@@ -74,24 +69,18 @@ bool UsesGds(const Program& program) {
 
 } // namespace
 
-void AllocateBindings(Program& program, uint32_t push_constant_offset) {
+void AllocateBindings(Program& program, uint32_t push_data_start_dword) {
 	if (!program.shader_info_complete || program.binding_layout_complete) {
 		EXIT("shader binding layout failed: %s", !program.shader_info_complete
 		                                             ? "shader info is not ready"
 		                                             : "binding layout already allocated");
 	}
-	if (push_constant_offset > NativePushConstantSize ||
-	    push_constant_offset % sizeof(uint32_t) != 0) {
-		EXIT("shader binding layout failed: push-constant offset %u exceeds the Vulkan minimum "
-		     "guarantee or is unaligned",
-		     push_constant_offset);
-	}
-
 	BindingLayout next;
-	next.push_constant_offset = push_constant_offset;
 	next.user_data_registers = CollectUserData(program);
 	next.memory_offset_dword = static_cast<uint32_t>(next.user_data_registers.size());
 	next.memory_offset_count = static_cast<uint32_t>(program.info.buffers.size());
+	next.push_data_start_dword =
+	    PushData::StartFor(push_data_start_dword, next.ShaderDataDwords());
 
 	if (!program.info.buffers.empty()) {
 		std::vector<uint32_t> resources(program.info.buffers.size());
@@ -107,7 +96,7 @@ void AllocateBindings(Program& program, uint32_t push_constant_offset) {
 		if (!kind.has_value()) {
 			EXIT("shader binding layout failed: image %u has an invalid binding class", i);
 		}
-		const auto group = static_cast<uint32_t>(*kind) - static_cast<uint32_t>(FirstImageBinding);
+		const auto group = ImageBindingIndex(*kind);
 		if (group >= image_groups.size()) {
 			EXIT("shader binding layout failed: image %u has an unmapped binding class", i);
 		}
@@ -122,10 +111,8 @@ void AllocateBindings(Program& program, uint32_t push_constant_offset) {
 	}
 	for (uint32_t i = 0; i < image_groups.size(); i++) {
 		if (!image_groups[i].empty()) {
-			AddBinding(
-			    next,
-			    static_cast<DescriptorBindingKind>(static_cast<uint32_t>(FirstImageBinding) + i),
-			    std::move(image_groups[i]));
+			AddBinding(next, static_cast<DescriptorBindingKind>(FirstImageBinding + i),
+			           std::move(image_groups[i]));
 		}
 	}
 
@@ -146,17 +133,14 @@ void AllocateBindings(Program& program, uint32_t push_constant_offset) {
 	const bool uses_flattened_runtime =
 	    !program.srt_reads.empty() ||
 	    std::ranges::any_of(program.info.images, [](const ImageResource& image) {
-		    return image.indirect_mapping_capacity != 0u;
+		    return image.indirect_search_iterations != 0u;
 	    });
 	if (uses_flattened_runtime) {
 		AddBinding(next, DescriptorBindingKind::FlattenedSrt);
 	}
 
-	const auto push_dwords = (NativePushConstantSize - push_constant_offset) / sizeof(uint32_t);
-	if (next.ShaderDataDwords() <= push_dwords) {
-		next.push_constant_size = next.ShaderDataDwords() * sizeof(uint32_t);
-	} else {
-		AddBinding(next, DescriptorBindingKind::UserData);
+	if (next.ShaderDataDwords() != 0 && !next.UsesPushData()) {
+		AddBinding(next, DescriptorBindingKind::ShaderData);
 	}
 
 	program.bindings                = std::move(next);

src/graphics/shader/recompiler/ir/passes/BindingLayout.h

@@ -5,7 +5,7 @@
 
 namespace Libs::Graphics::ShaderRecompiler::IR {
 
-void AllocateBindings(Program& program, uint32_t push_constant_offset);
+void AllocateBindings(Program& program, uint32_t push_data_start_dword = 0);
 
 const DescriptorBinding* FindBinding(const BindingLayout& layout, DescriptorBindingKind kind);
 

src/graphics/shader/recompiler/ir/passes/ResourceMaterialization.h

@@ -5,34 +5,46 @@
 
 namespace Libs::Graphics::ShaderRecompiler::IR {
 
-struct ResourceSnapshot {
-	struct IndirectImage {
-		uint32_t                     resource = 0;
-		uint32_t                     capacity = 0;
-		std::vector<uint32_t>        keys;
-		std::vector<uint32_t>        candidates;
-		std::vector<DescriptorValue> descriptors;
+// Canonical module-affecting resource state. Runtime addresses and descriptor payloads remain in
+// ResourceSnapshot and therefore do not create shader permutations.
+struct ResourceSpecialization {
+	struct Buffer {
+		uint32_t               packed_stride                   = 0;
+		Prospero::BufferFormat descriptor_format               = Prospero::BufferFormat::kInvalid;
+		uint32_t               descriptor_swizzle              = DstSel(4, 5, 6, 7);
+		bool                   operator==(const Buffer&) const = default;
 	};
 
-	std::vector<DescriptorValue> buffers;
-	std::vector<DescriptorValue> images;
-	std::vector<DescriptorValue> samplers;
-	std::vector<uint32_t>        flattened_srt;
-	std::vector<uint32_t>        user_data;
-	std::vector<IndirectImage>   indirect_images;
+	struct Image {
+		Prospero::TextureNumericClass numeric_class = Prospero::TextureNumericClass::Unsupported;
+		Decoder::ImageDimension       dimension     = Decoder::ImageDimension::Unknown;
+		uint32_t                      mip_count     = 1;
+		Prospero::BufferFormat        conversion_format          = Prospero::BufferFormat::kInvalid;
+		uint32_t                      shader_swizzle             = ShaderImageIdentitySwizzle;
+		uint32_t                      indirect_root              = ImageResource::NoIndirectImage;
+		uint32_t                      indirect_mapping_offset    = 0;
+		uint32_t                      indirect_search_iterations = 0;
+		bool                          cube                       = false;
+		bool                          operator==(const Image&) const = default;
+	};
+
+	std::vector<Buffer> buffers;
+	std::vector<Image>  images;
+
+	bool operator==(const ResourceSpecialization&) const = default;
 };
 
-bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot);
-bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot);
+// Extracts the descriptor/SRT value graph before resource specialization. The returned plan owns
+// its values and is independent of the translated shader CFG.
+ResourcePlan ExtractResourcePlan(const Program& program);
 
-// Resolves the immutable dense resource topology against one runtime user-data/SRT snapshot.
-// On failure the destination is unchanged.
-bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
-                          ResourceSnapshot& snapshot);
+// Resolves and specializes the immutable resource plan in one transaction. On failure both
+// destinations are unchanged.
+bool MaterializeResources(const ResourcePlan& program, const SrtRuntime& runtime,
+                          ResourceSnapshot& snapshot, ResourceSpecialization& specialization);
 
-// Applies runtime descriptor shape/format facts to a copied dense topology before layout and
-// emission. Invalid specializations are fatal.
-void SpecializeResources(Program& program, ResourceSnapshot& snapshot);
+// Applies an already-derived specialization to native IR before layout and emission.
+void ApplyResourceSpecialization(Program& program, const ResourceSpecialization& specialization);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

src/graphics/shader/recompiler/ir/passes/ResourceTracking.cpp

@@ -80,17 +80,6 @@ uint32_t ByteExtent(const MemoryInfo& memory) {
 	return end > UINT32_MAX ? UINT32_MAX : static_cast<uint32_t>(end);
 }
 
-bool IsStorageImage(ResourceKind kind) {
-	return kind == ResourceKind::StorageImage || kind == ResourceKind::StorageImageUint;
-}
-
-ImageMipMode MipMode(const MemoryInfo& memory) {
-	if (IsStorageImage(memory.kind) && memory.image_has_mip) {
-		return ImageMipMode::DynamicStorage;
-	}
-	return ImageMipMode::None;
-}
-
 class Tracker {
 public:
 	explicit Tracker(Program& program): m_program(program), m_info(program.info) {
@@ -475,6 +464,16 @@ private:
 		DescriptorSource descriptor;
 		MakeSource(*handle, width, sampler, sample_adjust, descriptor, pc);
 		uint32_t bad_dword = 0;
+		if (expected == ValueOpcode::GetImageResource) {
+			for (; bad_dword < descriptor.dword_count; bad_dword++) {
+				const auto* value = descriptor.dwords[bad_dword].Resolve().TryInstruction();
+				if (value != nullptr && value->GetOpcode() == ValueOpcode::ReadConstBuffer) {
+					Fail(pc, fmt::format("{} dword {} is not a valid runtime value",
+					                     ValueOpcodeName(expected), bad_dword));
+				}
+			}
+			bad_dword = 0;
+		}
 		if (!ValidateSource(descriptor, bad_dword)) {
 			Fail(pc, fmt::format("{} dword {} is not a valid runtime value",
 			                     ValueOpcodeName(expected), bad_dword));
@@ -526,18 +525,16 @@ private:
 	}
 
 	uint32_t AddImage(uint32_t source, const MemoryInfo& memory, ValueOpcode op, uint32_t pc) {
-		const auto mip   = MipMode(memory);
+		const auto resource_class = ImageOpcodeInfoOf(op).resource_class;
+		const auto mip   = resource_class == ImageResourceClass::Storage && memory.image_has_mip
+		                       ? ImageMipMode::DynamicStorage
+		                       : ImageMipMode::None;
 		const bool depth = (memory.image_sample_flags & Decoder::ImageSampleFlagCompare) != 0;
 		for (uint32_t i = 0; i < m_info.images.size(); i++) {
-			auto&      image           = m_info.images[i];
-			const bool compatible_kind = image.kind == memory.kind || (IsStorageImage(image.kind) &&
-			                                                           IsStorageImage(memory.kind));
-			if (image.source == source && compatible_kind &&
+			auto& image = m_info.images[i];
+			if (image.source == source && image.resource_class == resource_class &&
 			    image.dimension == memory.image_dimension && image.mip_mode == mip &&
 			    image.depth_compare == depth && image.r128 == memory.image_r128) {
-				if (memory.kind == ResourceKind::StorageImageUint) {
-					image.kind = ResourceKind::StorageImageUint;
-				}
 				Merge(image, op, pc);
 				return i;
 			}
@@ -546,13 +543,13 @@ private:
 			return UINT32_MAX;
 		}
 		ImageResource image;
-		image.source        = source;
-		image.first_use_pc  = pc;
-		image.kind          = memory.kind;
-		image.dimension     = memory.image_dimension;
-		image.mip_mode      = mip;
-		image.depth_compare = depth;
-		image.r128          = memory.image_r128;
+		image.source         = source;
+		image.first_use_pc   = pc;
+		image.resource_class = resource_class;
+		image.dimension      = memory.image_dimension;
+		image.mip_mode       = mip;
+		image.depth_compare  = depth;
+		image.r128           = memory.image_r128;
 		Merge(image, op, pc);
 		m_info.images.push_back(image);
 		return static_cast<uint32_t>(m_info.images.size() - 1);
@@ -681,7 +678,8 @@ private:
 			return;
 		}
 
-		if (!ImageResourceKindMatches(memory.kind, image_info.resource_class)) {
+		if (memory.kind != ResourceKind::Image ||
+		    image_info.resource_class == ImageResourceClass::None) {
 			Fail(flags.pc, "image operation has invalid resource kind");
 		}
 		handle               = inst.Arg(0).Resolve().TryInstruction();

src/graphics/shader/recompiler/ir/passes/SrtWalker.cpp

@@ -5,6 +5,7 @@
 
 #include <algorithm>
 #include <bit>
+#include <cmath>
 #include <cstring>
 #include <fmt/format.h>
 #include <unordered_map>
@@ -25,7 +26,7 @@ const char* StageName(ShaderType stage) {
 	}
 }
 
-std::string Diagnostic(const Program& program, uint32_t pc, const std::string& message) {
+std::string Diagnostic(const ResourcePlan& program, uint32_t pc, const std::string& message) {
 	return fmt::format("shader SRT: hash=0x{:016x} stage={} pc=0x{:08x} {}", program.shader_hash,
 	                   StageName(program.stage), pc, message);
 }
@@ -50,7 +51,7 @@ bool AddSignedAddress(uint64_t base, int64_t offset, uint64_t& result) {
 	return true;
 }
 
-bool IsRawRead(const Program& values, const Inst& inst) {
+bool IsRawRead(const ResourcePlan& values, const Inst& inst) {
 	const auto op = inst.GetOpcode();
 	if (op != ValueOpcode::LoadAddressU32 && op != ValueOpcode::ReadConstBuffer) {
 		return false;
@@ -74,8 +75,17 @@ bool IsDescriptorHandle(ValueOpcode opcode) {
 	}
 }
 
-bool IsRuntimeIntegerOp(ValueOpcode op) {
+bool IsRuntimeSelect(ValueOpcode op) {
+	return op == ValueOpcode::SelectU1 || op == ValueOpcode::SelectU32 ||
+	       op == ValueOpcode::SelectF32;
+}
+
+bool IsRuntimeUniformOp(ValueOpcode op) {
 	switch (op) {
+		case ValueOpcode::BitCastU32F32:
+		case ValueOpcode::BitCastF32U32:
+		case ValueOpcode::ConvertU32F32:
+		case ValueOpcode::ConvertF32U32:
 		case ValueOpcode::CompositeConstructU64:
 		case ValueOpcode::CompositeExtractU64:
 		case ValueOpcode::CompositeConstructU32x2:
@@ -104,6 +114,7 @@ bool IsRuntimeIntegerOp(ValueOpcode op) {
 		case ValueOpcode::BitwiseNot32:
 		case ValueOpcode::SelectU1:
 		case ValueOpcode::SelectU32:
+		case ValueOpcode::SelectF32:
 		case ValueOpcode::ULessThan32:
 		case ValueOpcode::IEqual32:
 		case ValueOpcode::UGreaterThan32:
@@ -111,14 +122,20 @@ bool IsRuntimeIntegerOp(ValueOpcode op) {
 		case ValueOpcode::LogicalOr:
 		case ValueOpcode::LogicalAnd:
 		case ValueOpcode::LogicalXor:
-		case ValueOpcode::LogicalNot: return true;
+		case ValueOpcode::LogicalNot:
+		case ValueOpcode::FPOrdLessThanEqual32:
+		case ValueOpcode::FPOrdGreaterThanEqual32:
+		case ValueOpcode::FPIsNan32:
+		case ValueOpcode::FPMul32:
+		case ValueOpcode::FPTrunc32: return true;
 		default: return false;
 	}
 }
 
 class RuntimeValidator {
 public:
-	explicit RuntimeValidator(const Program& program): m_program(program) {}
+	explicit RuntimeValidator(const ResourcePlan& program, Value active_mask = {})
+	    : m_program(program), m_active_mask(active_mask.Resolve()) {}
 
 	bool Run(Value value) { return Validate(value); }
 
@@ -132,7 +149,8 @@ private:
 				case Type::U8:
 				case Type::U16:
 				case Type::U32:
-				case Type::U64: return true;
+				case Type::U64:
+				case Type::F32: return true;
 				default: return false;
 			}
 		}
@@ -144,6 +162,10 @@ private:
 			return valid;
 		};
 		const auto op = inst->GetOpcode();
+		if (!m_active_mask.IsEmpty() && IsRuntimeSelect(op) && inst->NumArgs() == 3 &&
+		    inst->Arg(0).Resolve() == m_active_mask) {
+			return finish(Validate(inst->Arg(1)));
+		}
 		if (op == ValueOpcode::UndefU1 || op == ValueOpcode::UndefU8 ||
 		    op == ValueOpcode::UndefU16 || op == ValueOpcode::UndefU32 ||
 		    op == ValueOpcode::UndefU64 || op == ValueOpcode::Void) {
@@ -173,6 +195,13 @@ private:
 			}
 			return finish(Validate(invariant));
 		}
+		if (op == ValueOpcode::ReadFirstLane) {
+			if (inst->NumArgs() != 2 || inst->Arg(0).GetType() != Type::U32 ||
+			    inst->Arg(1).GetType() != Type::U1) {
+				return finish(false);
+			}
+			return finish(RuntimeValidator(m_program, inst->Arg(1)).Run(inst->Arg(0)));
+		}
 		if (op == ValueOpcode::GetSrtResource) {
 			if (inst->NumArgs() != 0) {
 				return finish(false);
@@ -222,7 +251,7 @@ private:
 				return finish(false);
 			}
 		} else if (op != ValueOpcode::ReadConst && op != ValueOpcode::ReadConstBuffer &&
-		           op != ValueOpcode::LoadAddressU32 && !IsRuntimeIntegerOp(op)) {
+		           op != ValueOpcode::LoadAddressU32 && !IsRuntimeUniformOp(op)) {
 			return finish(false);
 		}
 		for (size_t index = 0; index < inst->NumArgs(); index++) {
@@ -233,7 +262,8 @@ private:
 		return finish(true);
 	}
 
-	const Program&                  m_program;
+	const ResourcePlan&             m_program;
+	Value                           m_active_mask;
 	std::unordered_set<const Inst*> m_visiting;
 };
 
@@ -385,10 +415,11 @@ private:
 
 class Evaluator {
 public:
-	Evaluator(const Program& program, const SrtRuntime& runtime,
-	          std::span<const uint8_t> clean_flat_slots = {}, Evaluator* clean_evaluator = nullptr)
+	Evaluator(const ResourcePlan& program, const SrtRuntime& runtime,
+	          std::span<const uint8_t> clean_flat_slots = {}, Evaluator* clean_evaluator = nullptr,
+	          Value active_mask = {})
 	    : m_program(program), m_runtime(runtime), m_clean_flat_slots(clean_flat_slots),
-	      m_clean_evaluator(clean_evaluator) {}
+	      m_clean_evaluator(clean_evaluator), m_active_mask(active_mask.Resolve()) {}
 
 	bool Evaluate(Value value, uint32_t& result) {
 		uint64_t wide = 0;
@@ -400,6 +431,12 @@ public:
 	}
 
 private:
+	static float Float32(uint64_t bits) {
+		return std::bit_cast<float>(static_cast<uint32_t>(bits));
+	}
+
+	static uint64_t Float32Bits(float value) { return std::bit_cast<uint32_t>(value); }
+
 	bool EvaluateWide(Value value, uint64_t& result) {
 		value = value.Resolve();
 		if (value.IsImmediate()) {
@@ -409,6 +446,7 @@ private:
 				case Type::U16: result = value.U16(); return true;
 				case Type::U32: result = value.U32(); return true;
 				case Type::U64: result = value.U64(); return true;
+				case Type::F32: result = Float32Bits(value.F32Value()); return true;
 				default: return false;
 			}
 		}
@@ -416,6 +454,15 @@ private:
 		if (inst == nullptr) {
 			return false;
 		}
+		if (!m_reserved) {
+			m_cache.reserve(m_program.value_storage.size());
+			m_visiting.reserve(m_program.value_storage.size());
+			m_reserved = true;
+		}
+		if (!m_active_mask.IsEmpty() && IsRuntimeSelect(inst->GetOpcode()) &&
+		    inst->NumArgs() == 3 && inst->Arg(0).Resolve() == m_active_mask) {
+			return EvaluateWide(inst->Arg(1), result);
+		}
 		if (const auto found = m_cache.find(inst); found != m_cache.end()) {
 			result = found->second;
 			return true;
@@ -560,6 +607,13 @@ private:
 			}
 			case ValueOpcode::GetShaderBase: result = m_runtime.shader_base; return true;
 			case ValueOpcode::Phi: return EvaluatePhi(inst, result);
+			case ValueOpcode::ReadFirstLane: {
+				Evaluator active(m_program, m_runtime, m_clean_flat_slots, m_clean_evaluator,
+				                 inst.Arg(1));
+				return active.EvaluateWide(inst.Arg(0), result);
+			}
+			case ValueOpcode::BitCastU32F32:
+			case ValueOpcode::BitCastF32U32: return Arg(inst, 0, result);
 			case ValueOpcode::CompositeExtractU64:
 			case ValueOpcode::CompositeExtractU32x2: return EvaluateExtract(inst, result);
 			case ValueOpcode::CompositeConstructU64:
@@ -630,6 +684,53 @@ private:
 					return true;
 				}
 				return false;
+			case ValueOpcode::ConvertF32U32:
+				if (Arg(inst, 0, a)) {
+					result = Float32Bits(static_cast<float>(static_cast<uint32_t>(a)));
+					return true;
+				}
+				return false;
+			case ValueOpcode::ConvertU32F32:
+				if (Arg(inst, 0, a)) {
+					const auto value = Float32(a);
+					if (!std::isfinite(value) || value < 0.0f ||
+					    static_cast<double>(value) > UINT32_MAX) {
+						return false;
+					}
+					result = static_cast<uint32_t>(value);
+					return true;
+				}
+				return false;
+			case ValueOpcode::FPMul32:
+				if (binary()) {
+					result = Float32Bits(Float32(a) * Float32(b));
+					return true;
+				}
+				return false;
+			case ValueOpcode::FPTrunc32:
+				if (Arg(inst, 0, a)) {
+					result = Float32Bits(std::trunc(Float32(a)));
+					return true;
+				}
+				return false;
+			case ValueOpcode::FPIsNan32:
+				if (Arg(inst, 0, a)) {
+					result = std::isnan(Float32(a));
+					return true;
+				}
+				return false;
+			case ValueOpcode::FPOrdLessThanEqual32:
+				if (binary()) {
+					result = Float32(a) <= Float32(b);
+					return true;
+				}
+				return false;
+			case ValueOpcode::FPOrdGreaterThanEqual32:
+				if (binary()) {
+					result = Float32(a) >= Float32(b);
+					return true;
+				}
+				return false;
 			case ValueOpcode::BitwiseAnd32:
 				if (binary()) {
 					result = static_cast<uint32_t>(a & b);
@@ -753,6 +854,7 @@ private:
 			}
 			case ValueOpcode::SelectU32:
 			case ValueOpcode::SelectU1:
+			case ValueOpcode::SelectF32:
 				if (ternary()) {
 					result = a != 0u ? b : c;
 					return true;
@@ -816,23 +918,24 @@ private:
 		return false;
 	}
 
-	const Program&                            m_program;
+	const ResourcePlan&                       m_program;
 	const SrtRuntime&                         m_runtime;
 	std::span<const uint8_t>                  m_clean_flat_slots;
 	Evaluator*                                m_clean_evaluator = nullptr;
+	Value                                     m_active_mask;
 	std::unordered_map<const Inst*, uint64_t> m_cache;
 	std::vector<const Inst*>                  m_visiting;
+	bool                                      m_reserved = false;
 };
 
-const DescriptorSource* Source(const Program& program, uint32_t source) {
+const DescriptorSource* Source(const ResourcePlan& program, uint32_t source) {
 	if (source >= program.descriptor_sources.size()) {
 		return nullptr;
 	}
 	return &program.descriptor_sources[source];
 }
 
-bool EvaluateRuntimeSourcesImpl(const Program&                           program,
-                                std::span<const DescriptorSourceRequest> requests,
+bool EvaluateRuntimeSourcesImpl(const ResourcePlan& program, std::span<const uint32_t> sources,
                                 const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
                                 std::vector<uint32_t>& flat, bool evaluate_flat,
                                 std::span<const uint8_t> clean_flat_slots) {
@@ -848,9 +951,9 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
 	Evaluator                    clean_evaluator(program, clean_runtime);
 	Evaluator                    evaluator(program, runtime, clean_flat_slots, &clean_evaluator);
 	std::vector<DescriptorValue> evaluated;
-	evaluated.reserve(requests.size());
-	for (const auto& request: requests) {
-		const auto* source = Source(program, request.source);
+	evaluated.reserve(sources.size());
+	for (const auto source_index: sources) {
+		const auto* source = Source(program, source_index);
 		if (source == nullptr) {
 			return false;
 		}
@@ -885,7 +988,7 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
 
 } // namespace
 
-bool ValidateRuntimeValue(const Program& program, Value value) {
+bool ValidateRuntimeValue(const ResourcePlan& program, Value value) {
 	return RuntimeValidator(program).Run(value);
 }
 
@@ -898,34 +1001,32 @@ void BuildSrtPlan(Program& program) {
 	program.srt_plan_complete = true;
 }
 
-bool EvaluateDescriptorSource(const Program& program, uint32_t source, const SrtRuntime& runtime,
-                              DescriptorValue& result) {
-	const DescriptorSourceRequest request {source};
-	std::vector<DescriptorValue>  results;
-	if (!EvaluateDescriptorSources(program, std::span {&request, 1}, runtime, results)) {
+bool EvaluateDescriptorSource(const ResourcePlan& program, uint32_t source,
+                              const SrtRuntime& runtime, DescriptorValue& result) {
+	std::vector<DescriptorValue> results;
+	if (!EvaluateDescriptorSources(program, std::span {&source, 1}, runtime, results)) {
 		return false;
 	}
 	result = results.front();
 	return true;
 }
 
-bool EvaluateDescriptorSources(const Program&                           program,
-                               std::span<const DescriptorSourceRequest> requests,
+bool EvaluateDescriptorSources(const ResourcePlan& program, std::span<const uint32_t> sources,
                                const SrtRuntime& runtime, std::vector<DescriptorValue>& results) {
 	std::vector<uint32_t> ignored;
-	return EvaluateRuntimeSourcesImpl(program, requests, runtime, results, ignored, false, {});
+	return EvaluateRuntimeSourcesImpl(program, sources, runtime, results, ignored, false, {});
 }
 
-bool EvaluateRuntimeSources(const Program&                           program,
-                            std::span<const DescriptorSourceRequest> requests,
+bool EvaluateRuntimeSources(const ResourcePlan& program, std::span<const uint32_t> sources,
                             const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
                             std::vector<uint32_t>&   flat,
                             std::span<const uint8_t> clean_flat_slots) {
-	return EvaluateRuntimeSourcesImpl(program, requests, runtime, results, flat, true,
+	return EvaluateRuntimeSourcesImpl(program, sources, runtime, results, flat, true,
 	                                  clean_flat_slots);
 }
 
-bool WalkSrt(const Program& program, const SrtRuntime& runtime, std::vector<uint32_t>& flat) {
+bool WalkSrt(const ResourcePlan& program, const SrtRuntime& runtime,
+             std::vector<uint32_t>& flat) {
 	std::vector<DescriptorValue> ignored;
 	return EvaluateRuntimeSources(program, {}, runtime, ignored, flat, {});
 }

src/graphics/shader/recompiler/ir/passes/SrtWalker.h

@@ -19,32 +19,27 @@ struct SrtRuntime {
 	SrtMemoryReader           read_specialization_memory = nullptr;
 };
 
-struct DescriptorSourceRequest {
-	uint32_t source = 0;
-};
-
 // Collects reachable ReadConst values. Immediate offsets receive compact flat-buffer slots;
 // dynamic offsets remain explicit and are never assigned a fake slot.
 void BuildSrtPlan(Program& program);
-bool ValidateRuntimeValue(const Program& program, Value value);
+bool ValidateRuntimeValue(const ResourcePlan& program, Value value);
 
-bool EvaluateDescriptorSource(const Program& program, uint32_t source, const SrtRuntime& runtime,
-                              DescriptorValue& result);
+bool EvaluateDescriptorSource(const ResourcePlan& program, uint32_t source,
+                              const SrtRuntime& runtime, DescriptorValue& result);
 
 // Evaluates one runtime snapshot transactionally. Scalar values and ReadConst results shared by
 // several descriptors are memoized once across the batch.
-bool EvaluateDescriptorSources(const Program&                           program,
-                               std::span<const DescriptorSourceRequest> requests,
+bool EvaluateDescriptorSources(const ResourcePlan& program, std::span<const uint32_t> sources,
                                const SrtRuntime& runtime, std::vector<DescriptorValue>& results);
 
 // Evaluates descriptor sources and the flattened immediate SRT with one memoized scalar walk.
 // On failure neither destination is changed.
-bool EvaluateRuntimeSources(const Program&                           program,
-                            std::span<const DescriptorSourceRequest> requests,
+bool EvaluateRuntimeSources(const ResourcePlan& program, std::span<const uint32_t> sources,
                             const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
                             std::vector<uint32_t>& flat, std::span<const uint8_t> clean_flat_slots);
 
-bool WalkSrt(const Program& program, const SrtRuntime& runtime, std::vector<uint32_t>& flat);
+bool WalkSrt(const ResourcePlan& program, const SrtRuntime& runtime,
+             std::vector<uint32_t>& flat);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

src/graphics/shader/rectListShader.cpp

@@ -48,7 +48,7 @@ std::vector<Parameter> GetParameters(const ShaderVertexInputInfo& vertex_info,
 	std::vector<Parameter> parameters;
 	for (const auto input: active_inputs) {
 		const auto input_location = ShaderPixelParameterMappedLocation(*pixel_info, input);
-		if ((vertex_info.param_export_mask & (1u << input_location)) != 0) {
+		if ((vertex_info.stage.program->param_export_mask & (1u << input_location)) != 0) {
 			parameters.push_back({input_location,
 			                      ShaderPixelParameterLocation(*pixel_info, active_inputs, input),
 			                      ShaderPixelParameterIsFlat(*pixel_info, input)});

src/graphics/shader/shader.cpp

@@ -3,7 +3,6 @@
 #include "common/assert.h"
 #include "common/common.h"
 #include "common/emulatorConfig.h"
-#include "common/file.h"
 #include "common/logging/log.h"
 #include "common/magicEnum.h"
 #include "common/profiler.h"
@@ -12,23 +11,15 @@
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/shader/recompiler/ShaderRecompiler.h"
 #include "graphics/shader/recompiler/frontend/decode/ShaderDecoder.h"
-#include "graphics/shader/recompiler/ir/ShaderIR.h"
 #include "graphics/shader/shaderCompiler.h"
 #include "graphics/shader/shaderVertexMetadata.h"
-#include "kernel/memory.h"
 #include "libs/errno.h"
-#include "spirv-tools/libspirv.h"
-#include "spirv-tools/libspirv.hpp"
-#include "spirv-tools/optimizer.hpp"
 
 #include <algorithm>
 #include <atomic>
 #include <bit>
 #include <cstdio>
-#include <filesystem>
-#include <fmt/format.h>
 #include <memory>
 #include <mutex>
 #include <span>
@@ -49,15 +40,6 @@
 
 namespace Libs::Graphics {
 
-namespace {
-
-bool ReadShaderGuestMemory(void*, uint64_t address, uint32_t* value) {
-	return value != nullptr &&
-	       Libs::LibKernel::Memory::TryReadGpuCleanBacking(address, value, sizeof(*value));
-}
-
-} // namespace
-
 struct ShaderBinaryInfo {
 	uint8_t  signature[7];
 	uint8_t  version;
@@ -107,62 +89,6 @@ static ShaderMappedData ShaderGetMappedData(uint64_t addr, const char* label) {
 	EXIT("%s shader=0x%016" PRIx64 " is missing from ShaderMap\n", label, addr);
 }
 
-static bool SpirvDisassemble(const uint32_t* src_binary, size_t src_binary_size,
-                             std::string* dst_disassembly) {
-	if (dst_disassembly != nullptr) {
-		spvtools::SpirvTools core(SPV_ENV_VULKAN_1_2);
-
-		std::string disassembly;
-		if (!core.Disassemble(src_binary, src_binary_size, &disassembly,
-		                      static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_NO_HEADER) |
-		                          static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) |
-		                          static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COMMENT) |
-		                          static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_INDENT) |
-		                          static_cast<uint32_t>(SPV_BINARY_TO_TEXT_OPTION_COLOR))) {
-			*dst_disassembly = disassembly.c_str();
-
-			LOGF("Disassemble failed\n");
-			return false;
-		}
-
-		*dst_disassembly = disassembly.c_str();
-	}
-	return true;
-}
-
-static bool SpirvValidateBinary(const char* label, uint64_t shader_hash,
-                                const std::vector<uint32_t>& spirv) {
-	if (!Config::ShaderValidationEnabled()) {
-		return true;
-	}
-
-	spvtools::SpirvTools core(SPV_ENV_VULKAN_1_3);
-	std::string          messages;
-	core.SetMessageConsumer([&messages](spv_message_level_t /*level*/, const char* /*source*/,
-	                                    const spv_position_t& position, const char* message) {
-		messages += fmt::format("{}: {} ({}) {}\n", static_cast<int>(position.line),
-		                        static_cast<int>(position.column), static_cast<int>(position.index),
-		                        message);
-	});
-
-	if (core.Validate(spirv)) {
-		return true;
-	}
-
-	std::string disassembly;
-	SpirvDisassemble(spirv.data(), spirv.size(), &disassembly);
-	LOGF_COLOR(Log::Color::BrightRed, "%s SPIR-V validation failed hash=0x%016" PRIx64 ":\n%s",
-	           label, shader_hash, messages.c_str());
-	LOGF("%s\n", disassembly.c_str());
-	return false;
-}
-
-static void ExitShaderRecompilerFailure(const char* label, uint64_t shader_hash,
-                                        const char* reason) {
-	EXIT("%s failed hash=0x%016" PRIx64 ": %s\n", label, shader_hash,
-	     reason != nullptr ? reason : "");
-}
-
 static const ShaderBinaryInfo* GetBinaryInfo(const uint32_t* code) {
 	EXIT_IF(code == nullptr);
 
@@ -695,7 +621,6 @@ static bool ShaderGetStaticInputInfoVS(const HW::VertexShaderInfo& regs,
 
 	info = {};
 
-	info.export_count      = static_cast<int>(sh.GetExportCount());
 	info.pa_cl_vs_out_cntl = sh.m_paClVsOutCntl;
 
 	EXIT_NOT_IMPLEMENTED(regs.es_regs.data_addr == 0);
@@ -746,18 +671,12 @@ static bool ShaderGetStaticInputInfoVS(const HW::VertexShaderInfo& regs,
 
 static void ShaderGetStaticInputInfoPS(
     const HW::PixelShaderInfo& regs, const HW::ShaderRegisters& sh,
-    const ShaderVertexInputInfo&                        vs_info,
     std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
 	const ShaderMappedData& data, ShaderPixelInputInfo& ps_info) {
 	KYTY_PROFILER_FUNCTION();
 
 	ps_info = {};
 	ps_info.scratch_size_dwords = data.scratch_size_dwords;
-	ps_info.push_constant_offset =
-	    vs_info.stage.program != nullptr
-	        ? vs_info.stage.program->bindings.push_constant_offset +
-	              vs_info.stage.program->bindings.push_constant_size
-	        : 0;
 
 	// SPI_PS_IN_CONTROL.NUM_INTERP occupies bits 5:0. Keep the remaining control
 	// flags in the hardware state and extract only the input count here.
@@ -801,7 +720,6 @@ static void ShaderGetStaticInputInfoPS(
 		                                       ? target_export_mapping[i]
 		                                       : Prospero::ColorComponentMapping {};
 	}
-	ps_info.mrt_output_mask = 0;
 }
 
 static void ShaderGetStaticInputInfoCS(const HW::ComputeShaderInfo& regs,
@@ -828,73 +746,12 @@ static void ShaderGetStaticInputInfoCS(const HW::ComputeShaderInfo& regs,
 	info.workgroup_register = regs.cs_regs.user_sgpr;
 }
 
-static void ApplyVertexOutputs(ShaderVertexInputInfo&               info,
-                               const ShaderRecompiler::IR::Program& program) {
-	info.export_count      = 0;
-	info.param_export_mask = 0;
-	for (const auto& output: program.info.outputs) {
-		if (output.kind == ShaderRecompiler::IR::StageOutputKind::Parameter && output.index < 32) {
-			info.param_export_mask |= 1u << output.index;
-			info.export_count = std::max(info.export_count, static_cast<int>(output.index + 1));
-		}
-	}
-}
-
-static void ApplyPixelOutputs(ShaderPixelInputInfo&                info,
-                              const ShaderRecompiler::IR::Program& program) {
-	info.mrt_output_mask = 0;
-	for (const auto& output: program.info.outputs) {
-		if (output.kind == ShaderRecompiler::IR::StageOutputKind::Mrt && output.index < 8) {
-			info.mrt_output_mask |= 1u << output.index;
-		}
-	}
-}
-
-static bool LogPermutationMismatch(const ShaderRecompiler::IR::Program* program,
-                                   const char* stage) {
-	static std::atomic<uint32_t> log_count {0};
-	if (Config::GraphicsDebugDumpEnabled() &&
-	    log_count.fetch_add(1, std::memory_order_relaxed) < 64) {
-		LOGF("ShaderProgramCache native runtime mismatch %s shader=0x%016" PRIx64 "\n",
-		     stage, program != nullptr ? program->shader_hash : 0);
-	}
-	return false;
-}
-
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderVertexInputInfo& info) {
-	if (!ShaderMaterializeStageRuntime(program, params.user_data, params.Base(), info.stage,
-	                                   ReadShaderGuestMemory)) {
-		return LogPermutationMismatch(program.get(), "VS");
-	}
-	ApplyVertexOutputs(info, *program);
-	return true;
-}
-
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderPixelInputInfo& info) {
-	if (!ShaderMaterializeStageRuntime(program, params.user_data, params.Base(), info.stage,
-	                                   ReadShaderGuestMemory)) {
-		return LogPermutationMismatch(program.get(), "PS");
-	}
-	ApplyPixelOutputs(info, *program);
-	return true;
-}
-
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderComputeInputInfo& info) {
-	if (!ShaderMaterializeStageRuntime(program, params.user_data, params.Base(), info.stage,
-	                                   ReadShaderGuestMemory)) {
-		return LogPermutationMismatch(program.get(), "CS");
-	}
-	return true;
-}
-
 void BuildStageStaticKey(const ShaderVertexInputInfo& info, std::vector<uint32_t>& key) {
-	EXIT_IF(info.resources_num < 0 || info.resources_num > ShaderVertexInputInfo::RES_MAX ||
-	        info.buffers_num < 0 || info.buffers_num > ShaderVertexInputInfo::RES_MAX);
+	EXIT_IF(info.resources_num < 0 || info.resources_num > ShaderVertexInputInfo::RES_MAX);
 	key.clear();
 	key.push_back(static_cast<uint32_t>(info.fetch_embedded));
+	key.push_back(static_cast<uint32_t>(info.fetch_attrib_reg));
+	key.push_back(static_cast<uint32_t>(info.fetch_buffer_reg));
 	key.push_back(info.resources_num);
 	key.push_back(info.scratch_size_dwords);
 	key.push_back(info.pa_cl_vs_out_cntl);
@@ -917,6 +774,7 @@ void BuildStageStaticKey(const ShaderVertexInputInfo& info, std::vector<uint32_t
 		key.push_back(destination.register_start);
 		key.push_back(destination.registers_num);
 		key.push_back(destination.fetch_index);
+		key.push_back(static_cast<uint32_t>(destination.attr_id));
 		key.push_back(resource.Stride());
 		key.push_back(static_cast<uint32_t>(resource.SwizzleEnabled()));
 		key.push_back(resource.DstSelX());
@@ -927,28 +785,11 @@ void BuildStageStaticKey(const ShaderVertexInputInfo& info, std::vector<uint32_t
 		key.push_back(resource.OutOfBounds());
 		key.push_back(static_cast<uint32_t>(resource.AddTid()));
 	}
-
-	key.push_back(info.buffers_num);
-	int attributes_num = 0;
-	for (int i = 0; i < info.buffers_num; i++) {
-		const auto& buffer = info.buffers[i];
-		EXIT_IF(buffer.attr_num < 0 || buffer.attr_num > ShaderVertexInputBuffer::ATTR_MAX);
-		attributes_num += buffer.attr_num;
-		EXIT_IF(attributes_num > ShaderVertexInputInfo::RES_MAX);
-		key.push_back(buffer.attr_num);
-		key.push_back(buffer.stride);
-		key.push_back(buffer.fetch_index);
-		for (int j = 0; j < buffer.attr_num; j++) {
-			key.push_back(buffer.attr_indices[j]);
-			key.push_back(buffer.attr_offsets[j]);
-		}
-	}
 }
 
 void BuildStageStaticKey(const ShaderPixelInputInfo& info, std::vector<uint32_t>& key) {
 	EXIT_IF(info.input_num > std::size(info.interpolator_settings));
 	key.clear();
-	key.push_back(info.push_constant_offset);
 	key.push_back(info.scratch_size_dwords);
 	key.push_back(info.input_num);
 	key.push_back(info.ps_system_input_base);
@@ -1006,11 +847,10 @@ ShaderParams PrepareProgram(const HW::VertexShaderInfo& regs, const HW::ShaderRe
 
 ShaderParams PrepareProgram(
     const HW::PixelShaderInfo& regs, const HW::ShaderRegisters& sh,
-    const ShaderVertexInputInfo&                        vs_info,
     std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
     ShaderPixelInputInfo&                               ps_info) {
 	const auto data = ShaderGetMappedData(regs.ps_regs.data_addr, "ShaderGetInputInfoPS():");
-	ShaderGetStaticInputInfoPS(regs, sh, vs_info, target_export_mapping, data, ps_info);
+	ShaderGetStaticInputInfoPS(regs, sh, target_export_mapping, data, ps_info);
 	return GetShaderParams(
 	    regs.ps_regs.data_addr, "ShaderRecompiler PS", GetDeclaredShaderHash(regs.ps_regs.data_addr),
 	    std::span<const uint32_t>(regs.ps_user_sgpr.value, regs.ps_regs.rsrc2.user_sgpr), data);
@@ -1032,11 +872,8 @@ void ShaderDbgDumpInputInfo(const ShaderVertexInputInfo& info) {
 	LOGF("ShaderDbgDumpInputInfo()\n");
 
 	LOGF("\t fetch_external = %s\n"
-	     "\t fetch_embedded = %s\n"
-	     "\t param_export_mask = 0x%08" PRIx32 "\n"
-	     "\t export_count   = %d\n",
-	     info.fetch_external ? "true" : "false", info.fetch_embedded ? "true" : "false",
-	     info.param_export_mask, info.export_count);
+	     "\t fetch_embedded = %s\n",
+	     info.fetch_external ? "true" : "false", info.fetch_embedded ? "true" : "false");
 
 	for (int i = 0; i < info.resources_num; i++) {
 		LOGF("\t input %d\n", i);
@@ -1134,205 +971,6 @@ void ShaderDbgDumpInputInfo(const ShaderComputeInputInfo& info) {
 	     info.group_id[1] ? "true" : "false", info.group_id[2] ? "true" : "false");
 }
 
-static bool ShaderRecompilerTextDumpEnabled() {
-	// Graphics debug dump already writes SPIR-V binaries to _Shaders. Keep the very large
-	// disassembly/IR text behind the shader-log switch so file logging cannot stall boot.
-	return Config::GetShaderLogDirection() != Config::ShaderLogDirection::Silent;
-}
-
-static void DumpShaderRecompilerSpirv(const char* type, uint64_t shader_hash,
-                                      const std::vector<uint32_t>& bin) {
-	if (!Config::GraphicsDebugDumpEnabled()) {
-		return;
-	}
-
-	static std::atomic_int id = 0;
-
-	const auto base_name = Config::GetShaderLogFolder() /
-	                       fmt::format("{:04d}_new_shader_{}_{:016x}", id++, type, shader_hash);
-	Common::File::CreateDirectories(base_name.parent_path());
-
-	Common::File spv_file;
-	auto         spv_name = base_name;
-	spv_name += ".spv";
-	spv_file.Create(spv_name);
-	if (spv_file.IsInvalid()) {
-		auto spv_name_text = Common::PathToString(spv_name);
-		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", spv_name_text.c_str());
-	} else {
-		spv_file.Write(bin.data(), bin.size() * 4);
-		spv_file.Close();
-	}
-
-	return;
-
-	std::string text;
-	if (!SpirvDisassemble(bin.data(), bin.size(), &text)) {
-		auto spv_name_text = Common::PathToString(spv_name);
-		LOGF_COLOR(Log::Color::BrightRed, "SpirvDisassemble() failed for %s\n",
-		           spv_name_text.c_str());
-		return;
-	}
-
-	Common::File asm_file;
-	auto         asm_name = base_name;
-	asm_name += ".spvasm";
-	asm_file.Create(asm_name);
-	if (asm_file.IsInvalid()) {
-		auto asm_name_text = Common::PathToString(asm_name);
-		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", asm_name_text.c_str());
-	} else {
-		asm_file.Printf("%s", text.c_str());
-		asm_file.Close();
-	}
-}
-
-static void DumpShaderRecompilerOriginal(const char* type, uint64_t shader_hash,
-                                         std::span<const uint32_t> code,
-                                         const std::string&        decoded_dump) {
-	if (!Config::GraphicsDebugDumpEnabled()) {
-		return;
-	}
-	EXIT_IF(code.empty());
-
-	static std::atomic_int id = 0;
-
-	const auto base_name = Config::GetShaderLogFolder() / "original" /
-	                       fmt::format("{:04d}_new_shader_{}_{:016x}", id++, type, shader_hash);
-	Common::File::CreateDirectories(base_name.parent_path());
-
-	Common::File bin_file;
-	auto         bin_name = base_name;
-	bin_name += ".bin";
-	bin_file.Create(bin_name);
-	if (bin_file.IsInvalid()) {
-		auto bin_name_text = Common::PathToString(bin_name);
-		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", bin_name_text.c_str());
-	} else {
-		bin_file.Write(code.data(), code.size_bytes());
-		bin_file.Close();
-	}
-	if (decoded_dump.empty()) {
-		return;
-	}
-
-	Common::File text_file;
-	auto         text_name = base_name;
-	text_name += ".rdna2";
-	text_file.Create(text_name);
-	if (text_file.IsInvalid()) {
-		auto text_name_text = Common::PathToString(text_name);
-		LOGF_COLOR(Log::Color::BrightRed, "Can't create file: %s\n", text_name_text.c_str());
-	} else {
-		text_file.Printf("%s", decoded_dump.c_str());
-		text_file.Close();
-	}
-}
-
-static const char* ShaderStageName(ShaderType stage) {
-	switch (stage) {
-		case ShaderType::Vertex: return "vs";
-		case ShaderType::Pixel: return "ps";
-		case ShaderType::Compute: return "cs";
-		default: EXIT("invalid shader stage\n");
-	}
-}
-
-static const char* ShaderStageLabel(ShaderType stage) {
-	switch (stage) {
-		case ShaderType::Vertex: return "ShaderRecompiler VS";
-		case ShaderType::Pixel: return "ShaderRecompiler PS";
-		case ShaderType::Compute: return "ShaderRecompiler CS";
-		default: EXIT("invalid shader stage\n");
-	}
-}
-
-static ShaderRecompiler::CompileOptions MakeCompileOptions(const ShaderParams& params,
-                                                           ShaderType stage) {
-	ShaderRecompiler::CompileOptions options;
-	options.stage                      = stage;
-	options.shader_hash                = params.hash;
-	options.user_data                  = params.user_data;
-	options.read_specialization_memory = ReadShaderGuestMemory;
-	options.dump_ir                    = ShaderRecompilerTextDumpEnabled();
-	options.early_dump                 = options.dump_ir;
-	options.dump_label                 = ShaderStageLabel(stage);
-	return options;
-}
-
-static vk::ShaderModule CompileModule(vk::Device device, const ShaderParams& params,
-                                      ShaderRecompiler::CompileOptions options,
-                                      ShaderStageRuntime& stage) {
-	const auto* stage_name = ShaderStageName(options.stage);
-	const auto* label      = ShaderStageLabel(options.stage);
-	auto result = ShaderRecompiler::Recompile(params.code, options);
-
-	DumpShaderRecompilerOriginal(stage_name, options.shader_hash, params.code, result.decoded_dump);
-	if (!SpirvValidateBinary(label, options.shader_hash, result.spirv)) {
-		DumpShaderRecompilerSpirv(stage_name, options.shader_hash, result.spirv);
-		ExitShaderRecompilerFailure(label, options.shader_hash, "SPIR-V validation failed");
-	}
-	DumpShaderRecompilerSpirv(stage_name, options.shader_hash, result.spirv);
-
-	stage.program =
-	    std::make_shared<const ShaderRecompiler::IR::Program>(std::move(result.program));
-	stage.resources =
-	    std::make_shared<const ShaderRecompiler::IR::ResourceSnapshot>(std::move(result.resources));
-
-	vk::ShaderModuleCreateInfo create_info {};
-	create_info.sType    = vk::StructureType::eShaderModuleCreateInfo;
-	create_info.codeSize = result.spirv.size() * sizeof(uint32_t);
-	create_info.pCode    = result.spirv.data();
-	vk::ShaderModule module = nullptr;
-	RequireVulkanSuccess(device.createShaderModule(&create_info, nullptr, &module),
-	                     "create recompiled shader module");
-	EXIT_IF(module == nullptr);
-
-	if (options.dump_ir) {
-		if (!options.early_dump) {
-			LOGF("%s decoded RDNA2:\n%s", label, result.decoded_dump.c_str());
-			LOGF("%s IR:\n%s", label, result.ir_dump.c_str());
-		}
-		LOGF("%s SPIR-V words=%" PRIu64 " wave_size=%u\n", label,
-		     static_cast<uint64_t>(result.spirv.size()), options.wave_size);
-	}
-	return module;
-}
-
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderVertexInputInfo& input_info) {
-	KYTY_PROFILER_FUNCTION(profiler::colors::Amber300);
-	auto options                 = MakeCompileOptions(params, ShaderType::Vertex);
-	options.user_data_base       = 8;
-	options.scratch_dwords       = input_info.scratch_size_dwords;
-	options.input_info.vertex    = &input_info;
-	const auto module            = CompileModule(device, params, options, input_info.stage);
-	ApplyVertexOutputs(input_info, *input_info.stage.program);
-	return module;
-}
-
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderPixelInputInfo& input_info) {
-	KYTY_PROFILER_FUNCTION(profiler::colors::Blue300);
-	auto options                   = MakeCompileOptions(params, ShaderType::Pixel);
-	options.scratch_dwords         = input_info.scratch_size_dwords;
-	options.push_constant_offset   = input_info.push_constant_offset;
-	options.input_info.pixel       = &input_info;
-	const auto module              = CompileModule(device, params, options, input_info.stage);
-	ApplyPixelOutputs(input_info, *input_info.stage.program);
-	return module;
-}
-
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderComputeInputInfo& input_info) {
-	KYTY_PROFILER_FUNCTION(profiler::colors::CyanA700);
-	auto options               = MakeCompileOptions(params, ShaderType::Compute);
-	options.scratch_dwords     = input_info.scratch_size_dwords;
-	options.wave_size          = input_info.wave_size;
-	options.input_info.compute = &input_info;
-	return CompileModule(device, params, options, input_info.stage);
-}
-
 bool ShaderAddressValid(uint64_t addr) {
 	return reinterpret_cast<const uint32_t*>(addr) != nullptr;
 }

src/graphics/shader/shader.h

@@ -4,10 +4,10 @@
 #include "common/abi.h"
 #include "common/common.h"
 #include "graphics/guest_gpu/gpu_defs.h"
+#include "graphics/shader/recompiler/ir/ResourceSnapshot.h"
 #include "graphics/shader/shaderBindings.h"
 
 #include <array>
-#include <memory>
 #include <span>
 #include <string>
 #include <string_view>
@@ -36,30 +36,18 @@ struct ShaderRegisters;
 enum class ShaderType { Unknown, Vertex, Pixel, Fetch, Compute };
 
 namespace ShaderRecompiler::IR {
-struct Program;
-struct ResourceSnapshot;
+struct CompiledShaderInfo;
 } // namespace ShaderRecompiler::IR
 
 struct ShaderStageRuntime {
-	std::shared_ptr<const ShaderRecompiler::IR::Program>          program;
-	std::shared_ptr<const ShaderRecompiler::IR::ResourceSnapshot> resources;
+	const ShaderRecompiler::IR::CompiledShaderInfo* program = nullptr;
+	ShaderRecompiler::IR::ResourceSnapshot          resources;
 
 	[[nodiscard]] explicit operator bool() const {
-		return program != nullptr && resources != nullptr;
+		return program != nullptr;
 	}
 };
 
-using ShaderSpecializationMemoryReader = bool (*)(void* userdata, uint64_t address,
-                                                  uint32_t* value);
-
-// Resolves an immutable native shader plan against current user data. The prior stage is preserved
-// if any ReadConst, snapshot, or specialization check fails.
-bool ShaderMaterializeStageRuntime(
-    std::shared_ptr<const ShaderRecompiler::IR::Program> program,
-    std::span<const uint32_t> user_data, uint64_t shader_base, ShaderStageRuntime& stage,
-    ShaderSpecializationMemoryReader read_specialization_memory = nullptr,
-    void* read_memory_data = nullptr);
-
 constexpr uint32_t DstSel(uint32_t x, uint32_t y = 0, uint32_t z = 0, uint32_t w = 0) {
 	return x | (y << 3u) | (z << 6u) | (w << 9u);
 }
@@ -87,9 +75,7 @@ struct ShaderVertexInputInfo {
 	int                     fetch_attrib_reg    = 0;
 	int                     fetch_buffer_reg    = 0;
 	int                     buffers_num         = 0;
-	int                     export_count        = 0;
 	uint32_t                scratch_size_dwords = 0;
-	uint32_t                param_export_mask   = 0;
 	uint32_t                pa_cl_vs_out_cntl    = 0;
 	ShaderClipSpaceTransform clip_space;
 	bool                    fetch_external      = false;
@@ -119,8 +105,6 @@ struct ShaderPixelInputInfo {
 	uint32_t                                       ps_perspective_center_vgpr   = UINT32_MAX;
 	uint8_t                                        target_output_mode[8]        = {};
 	std::array<Prospero::ColorComponentMapping, 8> target_export_mapping        = {};
-	uint32_t                                       mrt_output_mask              = 0;
-	uint32_t                                       push_constant_offset         = 0;
 	uint32_t                                       scratch_size_dwords          = 0;
 	bool                                           ps_pos_x                     = false;
 	bool                                           ps_pos_y                     = false;

src/graphics/shader/shaderCompiler.h

@@ -1,10 +1,8 @@
 #ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_SHADERCOMPILER_H_
 #define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_SHADERCOMPILER_H_
 
-#include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/shader/shader.h"
 
-#include <memory>
 #include <span>
 #include <vector>
 
@@ -28,26 +26,11 @@ ShaderParams PrepareProgram(const HW::VertexShaderInfo& regs, const HW::ShaderRe
                             ShaderVertexInputInfo& input_info);
 ShaderParams PrepareProgram(
     const HW::PixelShaderInfo& regs, const HW::ShaderRegisters& sh,
-    const ShaderVertexInputInfo&                        vertex_info,
     std::span<const Prospero::ColorComponentMapping, 8> target_export_mapping,
     ShaderPixelInputInfo&                               input_info);
 ShaderParams PrepareProgram(const HW::ComputeShaderInfo& regs, const HW::ShaderRegisters& sh,
                             ShaderComputeInputInfo& input_info);
 
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderVertexInputInfo& input_info);
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderPixelInputInfo& input_info);
-bool MaterializeProgram(const std::shared_ptr<const ShaderRecompiler::IR::Program>& program,
-                        const ShaderParams& params, ShaderComputeInputInfo& input_info);
-
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderVertexInputInfo& input_info);
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderPixelInputInfo& input_info);
-vk::ShaderModule CompileProgram(vk::Device device, const ShaderParams& params,
-                                ShaderComputeInputInfo& input_info);
-
 } // namespace Libs::Graphics
 
 #endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_SHADERCOMPILER_H_ */

src/graphics/shader/shaderStageRuntime.cpp

@@ -1,32 +0,0 @@
-#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
-#include "graphics/shader/shader.h"
-
-#include <utility>
-
-namespace Libs::Graphics {
-
-bool ShaderMaterializeStageRuntime(std::shared_ptr<const ShaderRecompiler::IR::Program> program,
-                                   std::span<const uint32_t> user_data, uint64_t shader_base,
-                                   ShaderStageRuntime& stage,
-                                   ShaderSpecializationMemoryReader read_specialization_memory,
-                                   void*                            read_memory_data) {
-	if (program == nullptr) {
-		return false;
-	}
-	ShaderRecompiler::IR::SrtRuntime runtime;
-	runtime.user_data                  = user_data;
-	runtime.shader_base                = shader_base;
-	runtime.read_specialization_memory = read_specialization_memory;
-	runtime.userdata                   = read_memory_data;
-	ShaderRecompiler::IR::ResourceSnapshot snapshot;
-	if (!ShaderRecompiler::IR::MaterializeResources(*program, runtime, snapshot) ||
-	    !ShaderRecompiler::IR::ValidateResourceSpecialization(*program, snapshot)) {
-		return false;
-	}
-	auto resources =
-	    std::make_shared<const ShaderRecompiler::IR::ResourceSnapshot>(std::move(snapshot));
-	stage = {std::move(program), std::move(resources)};
-	return true;
-}
-
-} // namespace Libs::Graphics

src/kernel/memory.cpp

@@ -2445,6 +2445,24 @@ int KYTY_SYSV_ABI KernelSetVirtualRangeName(const void* addr, uint64_t len, cons
 	return OK;
 }
 
+int KYTY_SYSV_ABI KernelClearVirtualRangeName(const void* addr, uint64_t len) {
+	PRINT_NAME();
+
+	std::lock_guard<std::recursive_mutex> memory_operation_lock(g_memory_operation_mutex);
+
+	auto vaddr = reinterpret_cast<uint64_t>(addr);
+
+	LOGF("\t addr = 0x%016" PRIx64 "\n"
+	     "\t len  = 0x%016" PRIx64 "\n",
+	     vaddr, len);
+
+	g_physical_memory->SetVirtualRangeName(vaddr, len, "");
+	g_flexible_memory->SetVirtualRangeName(vaddr, len, "");
+	g_virtual_ranges->Rename(vaddr, len, "");
+
+	return OK;
+}
+
 static bool FreeGuestMemoryOwner(uint64_t vaddr, uint64_t size) {
 	return g_guest_address_space->ReleaseCommitted(vaddr, size) &&
 	       g_virtual_ranges->Remove(vaddr, size);

src/kernel/memory.h

@@ -121,6 +121,7 @@ int KYTY_SYSV_ABI KernelMapNamedFlexibleMemory(void** addr_in_out, size_t len, i
                                                const char* name);
 int KYTY_SYSV_ABI KernelMapFlexibleMemory(void** addr_in_out, size_t len, int prot, int flags);
 int KYTY_SYSV_ABI KernelSetVirtualRangeName(const void* addr, uint64_t len, const char* name);
+int KYTY_SYSV_ABI KernelClearVirtualRangeName(const void* addr, uint64_t len);
 int KYTY_SYSV_ABI KernelMunmap(uint64_t vaddr, size_t len);
 size_t KYTY_SYSV_ABI KernelGetDirectMemorySize();
 int KYTY_SYSV_ABI    KernelAvailableDirectMemorySize(int64_t search_start, int64_t search_end,

src/kernel/pthread.cpp

@@ -2573,6 +2573,11 @@ int KYTY_SYSV_ABI PthreadRwlockRdlock(PthreadRwlock* rwlock) {
 int KYTY_SYSV_ABI PthreadRwlockTimedrdlock(PthreadRwlock* rwlock, KernelUseconds usec) {
 	PRINT_NAME();
 
+	auto* pthread_static_objects = g_pthread_context->GetPthreadStaticObjects();
+
+	rwlock = static_cast<PthreadRwlock*>(
+	    pthread_static_objects->CreateObject(rwlock, PthreadStaticObject::Type::Rwlock));
+
 	if (rwlock == nullptr) {
 		return KERNEL_ERROR_EINVAL;
 	}
@@ -2585,6 +2590,11 @@ int KYTY_SYSV_ABI PthreadRwlockTimedrdlock(PthreadRwlock* rwlock, KernelUseconds
 int KYTY_SYSV_ABI PthreadRwlockTimedwrlock(PthreadRwlock* rwlock, KernelUseconds usec) {
 	PRINT_NAME();
 
+	auto* pthread_static_objects = g_pthread_context->GetPthreadStaticObjects();
+
+	rwlock = static_cast<PthreadRwlock*>(
+	    pthread_static_objects->CreateObject(rwlock, PthreadStaticObject::Type::Rwlock));
+
 	if (rwlock == nullptr) {
 		return KERNEL_ERROR_EINVAL;
 	}
@@ -2597,6 +2607,11 @@ int KYTY_SYSV_ABI PthreadRwlockTimedwrlock(PthreadRwlock* rwlock, KernelUseconds
 int KYTY_SYSV_ABI PthreadRwlockTryrdlock(PthreadRwlock* rwlock) {
 	PRINT_NAME();
 
+	auto* pthread_static_objects = g_pthread_context->GetPthreadStaticObjects();
+
+	rwlock = static_cast<PthreadRwlock*>(
+	    pthread_static_objects->CreateObject(rwlock, PthreadStaticObject::Type::Rwlock));
+
 	if (rwlock == nullptr) {
 		return KERNEL_ERROR_EINVAL;
 	}

src/libs/controller.cpp

@@ -39,11 +39,42 @@ struct PadControllerInformation {
 	uint8_t  reserve[8];
 };
 
+struct PadLightBarParam {
+	uint8_t r;
+	uint8_t g;
+	uint8_t b;
+	uint8_t reserve;
+};
+
 struct PadVibrationParam {
 	uint8_t large_motor;
 	uint8_t small_motor;
 };
 
+struct PadTriggerEffectCommand {
+	uint32_t mode;
+	uint8_t  reserve[4];
+	uint8_t  data[48];
+};
+
+struct PadTriggerEffectParam {
+	uint8_t                 trigger_mask;
+	uint8_t                 reserve[7];
+	PadTriggerEffectCommand command[2];
+};
+
+static_assert(sizeof(PadTriggerEffectCommand) == 56);
+static_assert(sizeof(PadTriggerEffectParam) == 120);
+
+struct DualSenseEffects {
+	uint8_t enable_bits;
+	uint8_t reserve[9];
+	uint8_t right_trigger[11];
+	uint8_t left_trigger[11];
+};
+
+static_assert(sizeof(DualSenseEffects) == 32);
+
 struct ControllerState {
 	struct Touch {
 		uint8_t  id   = 0;
@@ -73,6 +104,8 @@ public:
 	void ResetInputState();
 	void GetConnectionInfo(bool* flag, int* count);
 	void SetVibration(uint8_t large_motor, uint8_t small_motor);
+	void SetLightBar(uint8_t r, uint8_t g, uint8_t b);
+	bool SetTriggerEffect(const PadTriggerEffectParam& param);
 	void ReadState(ControllerState* state, bool* flag, int* count);
 	int  ReadStates(ControllerState* states, int states_num, bool* flag, int* count);
 
@@ -125,6 +158,92 @@ static void pad_fill_data(PadData* data, const ControllerState& state, bool conn
 	data->device_unique_data_len = 0;
 }
 
+static bool trigger_effect_zones(uint8_t* effect, const uint8_t* strengths, uint8_t type,
+                                 uint8_t frequency = 0) {
+	uint16_t active = 0;
+	uint32_t packed = 0;
+	for (int i = 0; i < 10; i++) {
+		if (strengths[i] > 8) {
+			return false;
+		}
+		if (strengths[i] != 0) {
+			active |= static_cast<uint16_t>(1u << i);
+			packed |= static_cast<uint32_t>(strengths[i] - 1u) << (3 * i);
+		}
+	}
+
+	effect[0] = active != 0 && (type != 0x26 || frequency != 0) ? type : 0x05;
+	effect[1] = static_cast<uint8_t>(active);
+	effect[2] = static_cast<uint8_t>(active >> 8u);
+	effect[3] = static_cast<uint8_t>(packed);
+	effect[4] = static_cast<uint8_t>(packed >> 8u);
+	effect[5] = static_cast<uint8_t>(packed >> 16u);
+	effect[6] = static_cast<uint8_t>(packed >> 24u);
+	effect[9] = frequency;
+	return true;
+}
+
+static bool trigger_effect_to_dualsense(const PadTriggerEffectCommand& command, uint8_t* effect) {
+	std::memset(effect, 0, 11);
+	effect[0] = 0x05;
+
+	uint8_t strengths[10] = {};
+	switch (command.mode) {
+		case 0: return true;
+		case 1:
+			if (command.data[0] > 9 || command.data[1] > 8) {
+				return false;
+			}
+			std::fill(strengths + command.data[0], strengths + 10, command.data[1]);
+			return trigger_effect_zones(effect, strengths, 0x21);
+		case 2: {
+			const auto start    = command.data[0];
+			const auto end      = command.data[1];
+			const auto strength = command.data[2];
+			if (start < 2 || start > 7 || end <= start || end > 8 || strength > 8) {
+				return false;
+			}
+			if (strength == 0) {
+				return true;
+			}
+			const uint16_t zones = static_cast<uint16_t>((1u << start) | (1u << end));
+			effect[0]            = 0x25;
+			effect[1]            = static_cast<uint8_t>(zones);
+			effect[2]            = static_cast<uint8_t>(zones >> 8u);
+			effect[3]            = strength - 1u;
+			return true;
+		}
+		case 3:
+			if (command.data[0] > 9 || command.data[1] > 8) {
+				return false;
+			}
+			std::fill(strengths + command.data[0], strengths + 10, command.data[1]);
+			return trigger_effect_zones(effect, strengths, 0x26, command.data[2]);
+		case 4: return trigger_effect_zones(effect, command.data, 0x21);
+		case 5: {
+			const int start          = command.data[0];
+			const int end            = command.data[1];
+			const int start_strength = command.data[2];
+			const int end_strength   = command.data[3];
+			if (start > 8 || end <= start || end > 9 || start_strength < 1 || start_strength > 8 ||
+			    end_strength < 1 || end_strength > 8) {
+				return false;
+			}
+			for (int i = start; i < 10; i++) {
+				const int delta  = (end_strength - start_strength) * (i - start);
+				const int length = end - start;
+				strengths[i]     = static_cast<uint8_t>(
+				    i >= end ? end_strength
+				             : start_strength +
+				                   (delta + (delta < 0 ? -length / 2 : length / 2)) / length);
+			}
+			return trigger_effect_zones(effect, strengths, 0x21);
+		}
+		case 6: return trigger_effect_zones(effect, command.data + 1, 0x26, command.data[0]);
+		default: return false;
+	}
+}
+
 void Initialize() {
 	EXIT_IF(g_controller != nullptr);
 
@@ -304,6 +423,44 @@ void GameController::SetVibration(uint8_t large_motor, uint8_t small_motor) {
 	}
 }
 
+void GameController::SetLightBar(uint8_t r, uint8_t g, uint8_t b) {
+	Common::LockGuard lock(m_mutex);
+	if (auto* pad = SDL_GameControllerFromInstanceID(static_cast<SDL_JoystickID>(m_active_id));
+	    pad != nullptr) {
+		(void)SDL_GameControllerSetLED(pad, r, g, b);
+	}
+}
+
+bool GameController::SetTriggerEffect(const PadTriggerEffectParam& param) {
+	if ((param.trigger_mask & ~0x03u) != 0) {
+		return false;
+	}
+
+	DualSenseEffects effect {};
+	if ((param.trigger_mask & 0x01u) != 0) {
+		effect.enable_bits |= 0x08;
+		if (!trigger_effect_to_dualsense(param.command[0], effect.left_trigger)) {
+			return false;
+		}
+	}
+	if ((param.trigger_mask & 0x02u) != 0) {
+		effect.enable_bits |= 0x04;
+		if (!trigger_effect_to_dualsense(param.command[1], effect.right_trigger)) {
+			return false;
+		}
+	}
+	if (effect.enable_bits == 0) {
+		return true;
+	}
+
+	Common::LockGuard lock(m_mutex);
+	auto* pad = SDL_GameControllerFromInstanceID(static_cast<SDL_JoystickID>(m_active_id));
+	if (pad != nullptr && SDL_GameControllerGetType(pad) == SDL_CONTROLLER_TYPE_PS5) {
+		(void)SDL_GameControllerSendEffect(pad, &effect, sizeof(effect));
+	}
+	return true;
+}
+
 void GameController::GetConnectionInfo(bool* flag, int* count) {
 	EXIT_IF(flag == nullptr);
 	EXIT_IF(count == nullptr);
@@ -358,44 +515,31 @@ int GameController::ReadStates(ControllerState* states, int states_num, bool* fl
 	return ret_num;
 }
 
-void ControllerConnect(int id) {
-	EXIT_IF(g_controller == nullptr);
-
+void Connect(int id) {
 	g_controller->Connect(id);
 }
 
-void ControllerDisconnect(int id) {
-	EXIT_IF(g_controller == nullptr);
-
+void Disconnect(int id) {
 	g_controller->Disconnect(id);
 }
 
-void ControllerButton(int id, uint32_t button, bool down) {
-	EXIT_IF(g_controller == nullptr);
-
+void SetButton(int id, uint32_t button, bool down) {
 	g_controller->Button(id, button, down);
 }
 
-void ControllerAxis(int id, Axis axis, int value) {
-	EXIT_IF(g_controller == nullptr);
-
+void SetAxis(int id, Axis axis, int value) {
 	g_controller->Axis(id, axis, value);
 }
 
-void ControllerRightStick(int id, int x, int y) {
-	EXIT_IF(g_controller == nullptr);
-
+void SetRightStick(int id, int x, int y) {
 	g_controller->RightStick(id, x, y);
 }
 
-void ControllerTouchPad(int id, int finger, bool down, float x, float y) {
-	EXIT_IF(g_controller == nullptr);
-
+void SetTouchPad(int id, int finger, bool down, float x, float y) {
 	g_controller->TouchPad(id, finger, down, x, y);
 }
 
-void ControllerResetInputState() {
-	EXIT_IF(g_controller == nullptr);
+void ResetInputState() {
 	g_controller->ResetInputState();
 }
 
@@ -490,8 +634,6 @@ int KYTY_SYSV_ABI PadResetOrientation(int handle) {
 int KYTY_SYSV_ABI PadGetControllerInformation(int handle, PadControllerInformation* info) {
 	PRINT_NAME();
 
-	EXIT_IF(g_controller == nullptr);
-
 	int  connected_count = 0;
 	bool connected       = false;
 
@@ -529,8 +671,6 @@ int KYTY_SYSV_ABI PadReadState(int handle, PadData* data) {
 		return PAD_ERROR_INVALID_ARG;
 	}
 
-	EXIT_IF(g_controller == nullptr);
-
 	int             connected_count = 0;
 	bool            connected       = false;
 	ControllerState state;
@@ -555,8 +695,6 @@ int KYTY_SYSV_ABI PadRead(int handle, PadData* data, int num) {
 
 	std::memset(data, 0, sizeof(PadData) * static_cast<size_t>(num));
 
-	EXIT_IF(g_controller == nullptr);
-
 	int             connected_count = 0;
 	bool            connected       = false;
 	ControllerState states[64]      = {};
@@ -591,7 +729,6 @@ int KYTY_SYSV_ABI PadSetVibration(int handle, const PadVibrationParam* param) {
 	     "\t small_motor = %d\n",
 	     static_cast<int>(param->large_motor), static_cast<int>(param->small_motor));
 
-	EXIT_IF(g_controller == nullptr);
 	g_controller->SetVibration(param->large_motor, param->small_motor);
 
 	return OK;
@@ -617,7 +754,22 @@ int KYTY_SYSV_ABI PadSetLightBar(int handle, const PadLightBarParam* param) {
 		return PAD_ERROR_INVALID_ARG;
 	}
 
+	g_controller->SetLightBar(param->r, param->g, param->b);
+
 	return OK;
 }
 
+int KYTY_SYSV_ABI PadSetTriggerEffect(int handle, const PadTriggerEffectParam* param) {
+	PRINT_NAME();
+
+	if (handle != 1) {
+		return PAD_ERROR_INVALID_HANDLE;
+	}
+	if (param == nullptr) {
+		return PAD_ERROR_INVALID_ARG;
+	}
+
+	return g_controller->SetTriggerEffect(*param) ? OK : PAD_ERROR_INVALID_ARG;
+}
+
 } // namespace Libs::Controller

src/libs/controller.h

@@ -48,6 +48,7 @@ struct PadControllerInformation;
 struct PadData;
 struct PadVibrationParam;
 struct PadLightBarParam;
+struct PadTriggerEffectParam;
 
 inline int controller_get_axis(int min, int max, int value) {
 	int v = (255 * (value - min)) / (max - min);
@@ -60,13 +61,13 @@ inline int controller_get_axis(int min, int max, int value) {
 	return v;
 }
 
-void ControllerConnect(int id);
-void ControllerDisconnect(int id);
-void ControllerButton(int id, uint32_t button, bool down);
-void ControllerAxis(int id, Axis axis, int value);
-void ControllerRightStick(int id, int x, int y);
-void ControllerTouchPad(int id, int finger, bool down, float x, float y);
-void ControllerResetInputState();
+void Connect(int id);
+void Disconnect(int id);
+void SetButton(int id, uint32_t button, bool down);
+void SetAxis(int id, Axis axis, int value);
+void SetRightStick(int id, int x, int y);
+void SetTouchPad(int id, int finger, bool down, float x, float y);
+void ResetInputState();
 
 int KYTY_SYSV_ABI PadInit();
 int KYTY_SYSV_ABI PadOpen(int user_id, int type, int index, const void* param);
@@ -78,6 +79,7 @@ int KYTY_SYSV_ABI PadGetControllerInformation(int handle, PadControllerInformati
 int KYTY_SYSV_ABI PadReadState(int handle, PadData* data);
 int KYTY_SYSV_ABI PadRead(int handle, PadData* data, int num);
 int KYTY_SYSV_ABI PadSetVibration(int handle, const PadVibrationParam* param);
+int KYTY_SYSV_ABI PadSetTriggerEffect(int handle, const PadTriggerEffectParam* param);
 int KYTY_SYSV_ABI PadResetLightBar(int handle);
 int KYTY_SYSV_ABI PadSetLightBar(int handle, const PadLightBarParam* param);
 

src/libs/libAmpr.cpp

@@ -2644,7 +2644,7 @@ static int KYTY_SYSV_ABI AmmWaitCommandBufferCompletion(uint32_t submission_id)
 
 } // namespace Ampr
 
-LIB_DEFINE(InitAmpr_1_Ampr) {
+LIB_DEFINE(InitAmpr_1) {
 	LIB_FUNC("8aI7R7WaOlc", Ampr::CommandBufferConstructor);
 	LIB_FUNC("a8uLzYY--tM", Ampr::AprCommandBufferConstructor);
 	LIB_FUNC("Qs1xtplKo0U", Ampr::AprCommandBufferDestructor);
@@ -2742,8 +2742,4 @@ LIB_DEFINE(InitAmpr_1_Ampr) {
 
 } // namespace LibAmpr
 
-LIB_DEFINE(InitAmpr_1) {
-	LibAmpr::InitAmpr_1_Ampr(s);
-}
-
 } // namespace Libs

src/libs/libC.cpp

@@ -808,7 +808,7 @@ LIB_DEFINE(InitLibcInternal_1) {
 
 } // namespace LibcInternal
 
-LIB_USING(LibC);
+namespace LibC {
 
 LIB_DEFINE(InitLibC_1) {
 	LibcInternal::InitLibcInternal_1(s);
@@ -835,4 +835,6 @@ LIB_DEFINE(InitLibC_1) {
 	LIB_FUNC("DiGVep5yB5w", LibC::std_execute_once);
 }
 
+} // namespace LibC
+
 } // namespace Libs

src/libs/libConvertKeycode.cpp

@@ -0,0 +1,37 @@
+#include "common/abi.h"
+#include "common/logging/log.h"
+#include "libs/errno.h"
+#include "libs/libs.h"
+#include "loader/symbolDatabase.h"
+
+namespace Libs {
+
+LIB_VERSION("ConvertKeycode", 1, "ConvertKeycode", 1, 0);
+
+namespace ConvertKeycode {
+
+constexpr int CONVERT_KEYCODE_ERROR_INVALID_ADDRESS = -2135162831; // 0x80bc0031
+constexpr int CONVERT_KEYCODE_ERROR_INVALID_USER_ID = -2135162864; // 0x80bc0010
+
+static int KYTY_SYSV_ABI ConvertKeycodeGetImeKeyboardType(int32_t user_id, uint32_t* type) {
+	PRINT_NAME();
+
+	LOGF("\t user_id = %d\n", user_id);
+
+	if (type == nullptr) {
+		return CONVERT_KEYCODE_ERROR_INVALID_ADDRESS;
+	}
+	if (user_id < 0) {
+		return CONVERT_KEYCODE_ERROR_INVALID_USER_ID;
+	}
+	*type = 0;
+	return OK;
+}
+
+} // namespace ConvertKeycode
+
+LIB_DEFINE(InitConvertKeycode_1) {
+	LIB_FUNC("mUuUOWI-C+0", ConvertKeycode::ConvertKeycodeGetImeKeyboardType);
+}
+
+} // namespace Libs

src/libs/libDebug.cpp

@@ -16,14 +16,10 @@ static KYTY_SYSV_ABI uint32_t RazorCpuIsCapturing() {
 	return 0;
 }
 
-LIB_DEFINE(InitLibRazorCpu_1) {
+LIB_DEFINE(InitRazorCpu_1) {
 	LIB_FUNC("EboejOQvLL4", LibRazorCpu::RazorCpuIsCapturing);
 }
 
 } // namespace LibRazorCpu
 
-LIB_DEFINE(InitDebug_1) {
-	LibRazorCpu::InitLibRazorCpu_1(s);
-}
-
 } // namespace Libs

src/libs/libJson2.cpp

@@ -739,6 +739,32 @@ static const JsonValue* KYTY_SYSV_ABI JsonValueIndexUInt(const JsonValue* self,
 	return (index < impl->size() ? (*impl)[static_cast<size_t>(index)] : JsonStaticNullValue());
 }
 
+static JsonValue* KYTY_SYSV_ABI JsonValueReferValueKey(JsonValue* self, const JsonString* key) {
+	PRINT_NAME();
+
+	if (self == nullptr || self->type != JsonValueTypeObject) {
+		return nullptr;
+	}
+	const auto* impl = JsonObjectImpl(self->object);
+	const auto  it   = impl->find(*JsonStringImpl(key));
+	return (it != impl->end() ? it->second : nullptr);
+}
+
+static void KYTY_SYSV_ABI JsonValueToString(const JsonValue* self, JsonString* dst) {
+	PRINT_NAME();
+
+	auto* impl = JsonStringImpl(dst);
+	if (impl == nullptr) {
+		return;
+	}
+	if (self != nullptr && self->type == JsonValueTypeString) {
+		*impl = *JsonStringImpl(self->string);
+	} else {
+		impl->clear();
+		JsonSerializeValue(self, impl);
+	}
+}
+
 static int32_t KYTY_SYSV_ABI JsonValueSerialize(JsonValue* self, JsonString* dst) {
 	PRINT_NAME();
 
@@ -971,6 +997,8 @@ LIB_DEFINE(InitNet_1_Json2) {
 	LIB_FUNC("urOpESTBZmo", LibJson2::JsonObjectAssign);
 	LIB_FUNC("zTwZdI8AZ5Y", LibJson2::JsonValueGetBoolean);
 	LIB_FUNC("R7FDWtcN6f8", LibJson2::JsonValueSerialize);
+	LIB_FUNC("wLsJlmgEIaI", LibJson2::JsonValueReferValueKey);
+	LIB_FUNC("Ncel8t2Rrpc", LibJson2::JsonValueToString);
 	LIB_FUNC("oH8aBmLU+fc", LibJson2::JsonObjectClear);
 	LIB_FUNC("bAM9Qwofus0", LibJson2::JsonArrayBack);
 	LIB_FUNC("UeuWT+yNdCQ", LibJson2::JsonValueBoolCtor);

src/libs/libKernel.cpp

@@ -512,10 +512,6 @@ bool KernelIsDispatchingSignalOnCurrentThread() {
 	return g_dispatching_signal_handler;
 }
 
-static void QueuePendingSignal(Pthread thread, int signum) {
-	PthreadQueuePendingSignal(thread, signum);
-}
-
 #if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
 static void WaitForSignalDispatch(Pthread thread, int signum) {
 	constexpr auto DISPATCH_WAIT_STEP = std::chrono::microseconds(1000);
@@ -529,10 +525,6 @@ static void WaitForSignalDispatch(Pthread thread, int signum) {
 }
 #endif
 
-static bool TakePendingSignal(Pthread thread, int signum) {
-	return PthreadTakePendingSignal(thread, signum);
-}
-
 struct SignalMcontext {
 	uint64_t mc_onstack;
 	uint64_t mc_rdi;
@@ -985,7 +977,7 @@ static void HostSignalDispatchHandler(int /*host_signal*/, siginfo_t* /*info*/,
 	auto* host_ctx = static_cast<ucontext_t*>(native_context);
 
 	for (int signum = 0; signum < static_cast<int>(std::size(g_exception_handlers)); signum++) {
-		if (!TakePendingSignal(current, signum)) {
+		if (!PthreadTakePendingSignal(current, signum)) {
 			continue;
 		}
 
@@ -1046,7 +1038,7 @@ static NtQueueApcThreadExFunc GetNtQueueApcThreadEx() {
 static void SignalApcHandler(void* arg1, void* arg2, void* /*arg3*/, PCONTEXT context) {
 	auto*      thread = static_cast<Pthread>(arg1);
 	const auto signum = static_cast<int>(reinterpret_cast<intptr_t>(arg2));
-	if (!TakePendingSignal(thread, signum)) {
+	if (!PthreadTakePendingSignal(thread, signum)) {
 		return;
 	}
 
@@ -1081,7 +1073,7 @@ void KernelDispatchPendingSignalForCurrentThread() {
 	}
 
 	for (int signum = 0; signum < static_cast<int>(std::size(g_exception_handlers)); signum++) {
-		if (!TakePendingSignal(current, signum)) {
+		if (!PthreadTakePendingSignal(current, signum)) {
 			continue;
 		}
 
@@ -1159,7 +1151,7 @@ static int KYTY_SYSV_ABI KernelRaiseException(Pthread thread, int signum) {
 			return KERNEL_ERROR_EINVAL;
 		}
 
-		QueuePendingSignal(thread, signum);
+		PthreadQueuePendingSignal(thread, signum);
 		KytyUserApcOption option {};
 		option.UserApcFlags = KytyQueueUserApcFlagsSpecialUserApc;
 
@@ -1168,7 +1160,7 @@ static int KYTY_SYSV_ABI KernelRaiseException(Pthread thread, int signum) {
 		                           reinterpret_cast<void*>(static_cast<intptr_t>(signum)), nullptr);
 
 		if (status != 0) {
-			TakePendingSignal(thread, signum);
+			PthreadTakePendingSignal(thread, signum);
 			CloseHandle(target_thread);
 			LOGF("\t NtQueueApcThreadEx failed: target_os_thread=%" PRIu64 ", status=0x%016" PRIx64
 			     "\n",
@@ -1194,9 +1186,9 @@ static int KYTY_SYSV_ABI KernelRaiseException(Pthread thread, int signum) {
 			return KERNEL_ERROR_EINVAL;
 		}
 
-		QueuePendingSignal(thread, signum);
+		PthreadQueuePendingSignal(thread, signum);
 		if (!PthreadKillHost(thread, SignalDispatchHostSignal())) {
-			TakePendingSignal(thread, signum);
+			PthreadTakePendingSignal(thread, signum);
 			LOGF("\t pthread_kill failed for target thread\n");
 			return KERNEL_ERROR_EINVAL;
 		}
@@ -3028,9 +3020,9 @@ namespace EventQueue = LibKernel::EventQueue;
 namespace EventFlag  = LibKernel::EventFlag;
 namespace Semaphore  = LibKernel::Semaphore;
 
-LIB_DEFINE(InitFiber_1) {
-	LIB_USING(Fiber);
+namespace Fiber {
 
+LIB_DEFINE(InitFiber_1) {
 	LIB_FUNC("hVYD7Ou2pCQ", Fiber::FiberInitialize);
 	LIB_FUNC("7+OJIpko9RY", Fiber::FiberInitializeInternal);
 	LIB_FUNC("asjUJJ+aa8s", Fiber::FiberOptParamInitialize);
@@ -3048,13 +3040,17 @@ LIB_DEFINE(InitFiber_1) {
 	LIB_FUNC("0dy4JtMUcMQ", Fiber::FiberGetThreadFramePointerAddress);
 }
 
-LIB_DEFINE(InitCoredump_1) {
-	LIB_USING(Coredump);
+} // namespace Fiber
 
+namespace Coredump {
+
+LIB_DEFINE(InitCoredump_1) {
 	LIB_FUNC("8zLSfEfW5AU", Coredump::sceCoredumpRegisterCoredumpHandler);
 	LIB_FUNC("fFkhOgztiCA", Coredump::sceCoredumpUnregisterCoredumpHandler);
 }
 
+} // namespace Coredump
+
 LIB_DEFINE(InitLibKernel_1_FS) {
 	LIB_FUNC("1G3lF1Gg1k8", FileSystem::KernelOpen);
 	LIB_FUNC("UK2Tl2DWUns", FileSystem::KernelClose);
@@ -3078,6 +3074,7 @@ LIB_DEFINE(InitLibKernel_1_Mem) {
 	LIB_FUNC("mL8NDH86iQI", Memory::KernelMapNamedFlexibleMemory);
 	LIB_FUNC("IWIBBdTHit4", Memory::KernelMapFlexibleMemory);
 	LIB_FUNC("DGMG3JshrZU", Memory::KernelSetVirtualRangeName);
+	LIB_FUNC("mkgXxsoxWHg", Memory::KernelClearVirtualRangeName);
 	// 6xx
 	LIB_FUNC("4h6F1LLbTiw", Memory::KernelMapFlexibleMemory);
 	LIB_FUNC("cQke9UuBQOk", Memory::KernelMunmap);
@@ -3230,6 +3227,9 @@ LIB_DEFINE(InitLibKernel_1_Pthread) {
 	LIB_FUNC("mqdNorrB+gI", LibKernel::PthreadRwlockWrlock);
 	LIB_FUNC("sIlRvQqsN2Y", LibKernel::PthreadRwlockWrlock);
 	LIB_FUNC("bIHoZCTomsI", LibKernel::PthreadRwlockTrywrlock);
+	LIB_FUNC("XD3mDeybCnk", LibKernel::PthreadRwlockTryrdlock);
+	LIB_FUNC("iPtZRWICjrM", LibKernel::PthreadRwlockTimedrdlock);
+	LIB_FUNC("adh--6nIqTk", LibKernel::PthreadRwlockTimedwrlock);
 	LIB_FUNC("i2ifZ3fS2fo", LibKernel::PthreadRwlockattrDestroy);
 	LIB_FUNC("yOfGg-I1ZII", LibKernel::PthreadRwlockattrInit);
 	LIB_FUNC("qsdmgXjqSgk", LibKernel::PthreadRwlockattrDestroy);

src/libs/libPad.cpp

@@ -42,23 +42,6 @@ static int KYTY_SYSV_ABI PadGetTriggerEffectState(int
 	return 0;
 }
 
-static int KYTY_SYSV_ABI PadSetTriggerEffect(int handle, const void* param) {
-	PRINT_NAME();
-
-	LOGF("\t handle = %d\n"
-	     "\t param  = 0x%016" PRIx64 "\n",
-	     handle, reinterpret_cast<uint64_t>(param));
-
-	if (handle != 1) {
-		return -2137915389; /* 0x80920003 */
-	}
-	if (param == nullptr) {
-		return -2137915391; /* 0x80920001 */
-	}
-
-	return OK;
-}
-
 static int KYTY_SYSV_ABI PadSetVibrationTriggerEffectWeakWhileEmbeddedMicInUse(bool enabled) {
 	PRINT_NAME();
 
@@ -198,7 +181,7 @@ LIB_DEFINE(InitPad_1) {
 	LIB_FUNC("rIZnR6eSpvk", Controller::PadResetOrientation);
 	LIB_FUNC("vDLMoJLde8I", PadSetTiltCorrectionState);
 	LIB_FUNC("gjP9-KQzoUk", Controller::PadGetControllerInformation);
-	LIB_FUNC("2JgFB2n9oUM", PadSetTriggerEffect);
+	LIB_FUNC("2JgFB2n9oUM", Controller::PadSetTriggerEffect);
 	LIB_FUNC("YndgXqQVV7c", Controller::PadReadState);
 	LIB_FUNC("q1cHNfGycLI", Controller::PadRead);
 	LIB_FUNC("yFVnOdGxvZY", Controller::PadSetVibration);

src/libs/libRtc.cpp

@@ -78,7 +78,7 @@ static int KYTY_SYSV_ABI RtcCheckValid(const RtcDateTime* time) {
 	return OK;
 }
 
-static int RtcGetDaysInMonth(int year, int month) {
+static int GetDaysInMonth(int year, int month) {
 	if (year <= 0 || year > 9999) {
 		return RTC_ERROR_INVALID_YEAR;
 	}
@@ -106,7 +106,7 @@ static int KYTY_SYSV_ABI RtcIsLeapYear(int year) {
 static int KYTY_SYSV_ABI RtcGetDayOfWeek(int year, int month, int day) {
 	PRINT_NAME();
 
-	const auto days = RtcGetDaysInMonth(year, month);
+	const auto days = GetDaysInMonth(year, month);
 	if (days < 0) {
 		return days;
 	}
@@ -118,10 +118,10 @@ static int KYTY_SYSV_ABI RtcGetDayOfWeek(int year, int month, int day) {
 	return (dow == 7 ? 0 : dow);
 }
 
-static int KYTY_SYSV_ABI RtcGetDaysInMonthExport(int year, int month) {
+static int KYTY_SYSV_ABI RtcGetDaysInMonth(int year, int month) {
 	PRINT_NAME();
 
-	return RtcGetDaysInMonth(year, month);
+	return GetDaysInMonth(year, month);
 }
 
 static int KYTY_SYSV_ABI RtcGetTickResolution() {
@@ -549,7 +549,7 @@ static int KYTY_SYSV_ABI RtcTickAddWeeks(RtcTick* dst, const RtcTick* src, int32
 
 } // namespace Rtc
 
-LIB_DEFINE(InitRtc_1_Rtc) {
+LIB_DEFINE(InitRtc_1) {
 	LIB_FUNC("lPEBYdVX0XQ", Rtc::RtcCheckValid);
 	LIB_FUNC("8Yr143yEnRo", Rtc::RtcConvertLocalTimeToUtc);
 	LIB_FUNC("M1TvFst-jrM", Rtc::RtcConvertUtcToLocalTime);
@@ -560,7 +560,7 @@ LIB_DEFINE(InitRtc_1_Rtc) {
 	LIB_FUNC("zO9UL3qIINQ", Rtc::RtcGetCurrentNetworkTick);
 	LIB_FUNC("CyIK-i4XdgQ", Rtc::RtcGetDayOfWeek);
 	LIB_FUNC("Ug8pCwQvh0c", Rtc::RtcIsLeapYear);
-	LIB_FUNC("3O7Ln8AqJ1o", Rtc::RtcGetDaysInMonthExport);
+	LIB_FUNC("3O7Ln8AqJ1o", Rtc::RtcGetDaysInMonth);
 	LIB_FUNC("8w-H19ip48I", Rtc::RtcGetTick);
 	LIB_FUNC("jMNwqYr4R-k", Rtc::RtcGetTickResolution);
 	LIB_FUNC("BtqmpTRXHgk", Rtc::RtcGetTime_t);
@@ -580,8 +580,4 @@ LIB_DEFINE(InitRtc_1_Rtc) {
 
 } // namespace LibRtc
 
-LIB_DEFINE(InitRtc_1) {
-	LibRtc::InitRtc_1_Rtc(s);
-}
-
 } // namespace Libs

src/libs/libVideoOut.cpp

@@ -47,8 +47,4 @@ LIB_DEFINE(InitVideoOut_1) {
 
 } // namespace LibGen5
 
-LIB_DEFINE(InitVideoOut_1) {
-	LibGen5::InitVideoOut_1(s);
-}
-
 } // namespace Libs

src/libs/libs.cpp

@@ -6,10 +6,6 @@
 
 namespace Libs {
 
-namespace LibcInternal {
-LIB_DEFINE(InitLibcInternal_1);
-} // namespace LibcInternal
-
 namespace LibContentDelete {
 LIB_DEFINE(InitContentDelete_1);
 } // namespace LibContentDelete
@@ -46,15 +42,39 @@ namespace LibPsml {
 LIB_DEFINE(InitPsml_1);
 } // namespace LibPsml
 
+namespace LibC {
 LIB_DEFINE(InitLibC_1);
-LIB_DEFINE(InitAppContent_1);
+} // namespace LibC
+
+namespace LibAmpr {
 LIB_DEFINE(InitAmpr_1);
-LIB_DEFINE(InitAudio_1);
+} // namespace LibAmpr
+
+namespace Coredump {
 LIB_DEFINE(InitCoredump_1);
-LIB_DEFINE(InitDbgAddressSanitizer_1);
-LIB_DEFINE(InitDebug_1);
-LIB_DEFINE(InitDialog_1);
+} // namespace Coredump
+
+namespace LibRazorCpu {
+LIB_DEFINE(InitRazorCpu_1);
+} // namespace LibRazorCpu
+
+namespace Fiber {
 LIB_DEFINE(InitFiber_1);
+} // namespace Fiber
+
+namespace LibRtc {
+LIB_DEFINE(InitRtc_1);
+} // namespace LibRtc
+
+namespace LibGen5 {
+LIB_DEFINE(InitVideoOut_1);
+} // namespace LibGen5
+
+LIB_DEFINE(InitAppContent_1);
+LIB_DEFINE(InitAudio_1);
+LIB_DEFINE(InitConvertKeycode_1);
+LIB_DEFINE(InitDbgAddressSanitizer_1);
+LIB_DEFINE(InitDialog_1);
 LIB_DEFINE(InitFont_1);
 LIB_DEFINE(InitFontFt_1);
 LIB_DEFINE(InitAgcDriver_1);
@@ -65,52 +85,51 @@ LIB_DEFINE(InitPlayGo_1);
 LIB_DEFINE(InitPngDec_1);
 LIB_DEFINE(InitPlatform_1);
 LIB_DEFINE(InitRudp_1);
-LIB_DEFINE(InitRtc_1);
 LIB_DEFINE(InitSaveData_1);
 LIB_DEFINE(InitShare_1);
 LIB_DEFINE(InitSysmodule_1);
 LIB_DEFINE(InitSystemService_1);
 LIB_DEFINE(InitTextToSpeech2_1);
 LIB_DEFINE(InitUserService_1);
-LIB_DEFINE(InitVideoOut_1);
 
 void InitAll(Loader::SymbolDatabase* s) {
-	LIB_LOAD(InitAudio_1);
-	LIB_LOAD(InitAmpr_1);
-	LIB_LOAD(InitAppContent_1);
-	LIB_LOAD(InitCoredump_1);
-	LIB_LOAD(LibContentDelete::InitContentDelete_1);
-	LIB_LOAD(LibContentExport::InitContentExport_1);
-	LIB_LOAD(LibContentSearch::InitContentSearch_1);
-	LIB_LOAD(InitLibC_1);
-	LIB_LOAD(InitDbgAddressSanitizer_1);
-	LIB_LOAD(InitDebug_1);
-	LIB_LOAD(InitDialog_1);
-	LIB_LOAD(InitFiber_1);
-	LIB_LOAD(InitFont_1);
-	LIB_LOAD(InitFontFt_1);
-	LIB_LOAD(InitAgcDriver_1);
-	LIB_LOAD(InitLibKernel_1);
-	LIB_LOAD(LibMouse::InitMouse_1);
-	LIB_LOAD(LibKeyboard::InitKeyboard_1);
-	LIB_LOAD(Ime::InitPlatform_1_Ime);
-	LIB_LOAD(InitNet_1);
-	LIB_LOAD(InitPad_1);
-	LIB_LOAD(InitPlayGo_1);
-	LIB_LOAD(LibPsml::InitPsml_1);
-	LIB_LOAD(InitPngDec_1);
-	LIB_LOAD(InitPlatform_1);
-	LIB_LOAD(InitRudp_1);
-	LIB_LOAD(InitRtc_1);
-	LIB_LOAD(InitSaveData_1);
-	LIB_LOAD(InitShare_1);
-	LIB_LOAD(InitSysmodule_1);
-	LIB_LOAD(InitSystemService_1);
-	LIB_LOAD(InitTextToSpeech2_1);
-	LIB_LOAD(LibUlt::InitUlt_1);
-	LIB_LOAD(InitUserService_1);
-	LIB_LOAD(VideoDec2::InitVideoDec2_1);
-	LIB_LOAD(InitVideoOut_1);
+	InitAudio_1(s);
+	InitConvertKeycode_1(s);
+	LibAmpr::InitAmpr_1(s);
+	InitAppContent_1(s);
+	Coredump::InitCoredump_1(s);
+	LibContentDelete::InitContentDelete_1(s);
+	LibContentExport::InitContentExport_1(s);
+	LibContentSearch::InitContentSearch_1(s);
+	LibC::InitLibC_1(s);
+	InitDbgAddressSanitizer_1(s);
+	LibRazorCpu::InitRazorCpu_1(s);
+	InitDialog_1(s);
+	Fiber::InitFiber_1(s);
+	InitFont_1(s);
+	InitFontFt_1(s);
+	InitAgcDriver_1(s);
+	InitLibKernel_1(s);
+	LibMouse::InitMouse_1(s);
+	LibKeyboard::InitKeyboard_1(s);
+	Ime::InitPlatform_1_Ime(s);
+	InitNet_1(s);
+	InitPad_1(s);
+	InitPlayGo_1(s);
+	LibPsml::InitPsml_1(s);
+	InitPngDec_1(s);
+	InitPlatform_1(s);
+	InitRudp_1(s);
+	LibRtc::InitRtc_1(s);
+	InitSaveData_1(s);
+	InitShare_1(s);
+	InitSysmodule_1(s);
+	InitSystemService_1(s);
+	InitTextToSpeech2_1(s);
+	LibUlt::InitUlt_1(s);
+	InitUserService_1(s);
+	VideoDec2::InitVideoDec2_1(s);
+	LibGen5::InitVideoOut_1(s);
 }
 
 namespace LibContentExport {

src/libs/libs.h

@@ -27,15 +27,6 @@
 	static constexpr int g_module_version_major = mv1;                                             \
 	static constexpr int g_module_version_minor = mv2;
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LIB_USING(n)                                                                               \
-	using n::g_library;                                                                            \
-	using n::g_library_version;                                                                    \
-	using n::g_module;                                                                             \
-	using n::g_module_version_major;                                                               \
-	using n::g_module_version_minor;
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LIB_LOAD(name) name(s)
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define LIB_ADD(n, f, t)                                                                           \
 	{                                                                                              \
 		Loader::SymbolResolve sr {};                                                               \

tests/ResourceMaterializationTests.cpp

@@ -0,0 +1,233 @@
+#include "graphics/shader/recompiler/ir/ShaderIR.h"
+#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <memory>
+
+namespace {
+
+void Check(bool value, const char *text) {
+  if (!value) {
+    std::fprintf(stderr, "ResourceMaterializationTests: failed: %s\n", text);
+    std::abort();
+  }
+}
+
+bool RejectSpecializationRead(void *userdata, uint64_t, uint32_t *) {
+  ++*static_cast<uint32_t *>(userdata);
+  return false;
+}
+
+Libs::Graphics::ShaderRecompiler::IR::Block &
+AddValueBlock(Libs::Graphics::ShaderRecompiler::IR::Program &program) {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  auto block = std::make_unique<Block>();
+  auto *result = block.get();
+  program.blocks.push_back(result);
+  program.block_info.push_back({.id = 0});
+  program.block_storage.push_back(std::move(block));
+  return *result;
+}
+
+Libs::Graphics::ShaderRecompiler::IR::ResourcePlan SrtPlan(uint64_t address) {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  Program program;
+  program.stage = Libs::Graphics::ShaderType::Compute;
+  program.srt_plan_complete = true;
+  program.resource_tracking_complete = true;
+  auto &value_block = AddValueBlock(program);
+
+  MemoryInfo memory;
+  memory.kind = ResourceKind::ScalarAddress;
+  memory.planning_only = true;
+  program.memory_info.push_back(memory);
+  const auto low = Value(static_cast<uint32_t>(address));
+  const auto high = Value(static_cast<uint32_t>(address >> 32u));
+  auto &handle =
+      value_block.AppendNewInst(ValueOpcode::GetAddressResource, {low, high});
+  auto &raw = value_block.AppendNewInst(
+      ValueOpcode::LoadAddressU32,
+      {Value(&handle), Value(0u), Value(0u), Value(true)});
+  raw.SetFlags(MemoryFlags{.index = 0, .pc = 0x40});
+  program.srt_reads.push_back({Value(&raw), 0});
+
+  auto &srt = value_block.AppendNewInst(ValueOpcode::GetSrtResource);
+  auto &flat = value_block.AppendNewInst(ValueOpcode::ReadConst,
+                                         {Value(&srt), Value(0u)});
+  DescriptorSource source;
+  source.dwords[0] = Value(&flat);
+  source.dwords[1] = Value(0u);
+  source.dword_count = 2;
+  program.descriptor_sources.push_back(source);
+  return ExtractResourcePlan(program);
+}
+
+Libs::Graphics::ShaderRecompiler::IR::ResourcePlan UnbasedFlatPlan() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  Program program;
+  program.stage = Libs::Graphics::ShaderType::Compute;
+  program.srt_plan_complete = true;
+  program.resource_tracking_complete = true;
+  AddValueBlock(program);
+  program.info.uses_dma = true;
+  return ExtractResourcePlan(program);
+}
+
+Libs::Graphics::ShaderRecompiler::IR::ResourcePlan UserDataBufferPlan() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  Program program;
+  program.stage = Libs::Graphics::ShaderType::Compute;
+  program.srt_plan_complete = true;
+  program.resource_tracking_complete = true;
+  auto &value_block = AddValueBlock(program);
+
+  auto &user_data = value_block.AppendNewInst(
+      ValueOpcode::GetUserData, {Value(static_cast<ScalarReg>(0))});
+  DescriptorSource source;
+  source.dwords[0] = Value(&user_data);
+  source.dwords[1] = Value(0u);
+  source.dwords[2] = Value(0u);
+  source.dwords[3] = Value(0u);
+  source.dword_count = 4;
+  program.descriptor_sources.push_back(source);
+  program.info.buffers.push_back({.source = 0});
+  return ExtractResourcePlan(program);
+}
+
+Libs::Graphics::ShaderRecompiler::IR::ResourcePlan MixedSamplerPlan() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  Program program;
+  program.stage = Libs::Graphics::ShaderType::Compute;
+  program.srt_plan_complete = true;
+  program.resource_tracking_complete = true;
+  AddValueBlock(program);
+
+  const auto AddSource = [&program](uint32_t dword_count, uint32_t first) {
+    DescriptorSource source;
+    source.dword_count = dword_count;
+    source.dwords[0] = Value(first);
+    for (uint32_t i = 1; i < dword_count; i++) {
+      source.dwords[i] = Value(0u);
+    }
+    program.descriptor_sources.push_back(source);
+    return static_cast<uint32_t>(program.descriptor_sources.size() - 1u);
+  };
+
+  const auto image0 = AddSource(8, 0);
+  const auto image1 = AddSource(8, 0);
+  const auto sampler0 = AddSource(4, 0x11111111u);
+  const auto sampler1 = AddSource(4, 0x22222222u);
+  program.info.images.push_back(
+      {.source = image0,
+       .resource_class = ImageResourceClass::Sampled,
+       .numeric_class = Libs::Graphics::Prospero::TextureNumericClass::Float,
+       .dimension =
+           Libs::Graphics::ShaderRecompiler::Decoder::ImageDimension::Dim2D});
+  program.info.images.push_back(
+      {.source = image1,
+       .resource_class = ImageResourceClass::Sampled,
+       .numeric_class = Libs::Graphics::Prospero::TextureNumericClass::Float,
+       .dimension =
+           Libs::Graphics::ShaderRecompiler::Decoder::ImageDimension::Dim2D,
+       .conversion_format =
+           Libs::Graphics::Prospero::BufferFormat::k8_8_8_8UNorm});
+  program.info.samplers.push_back({.source = sampler0});
+  program.info.samplers.push_back({.source = sampler1});
+  program.info.sampled_pairs.push_back({.image = 0, .sampler = 0});
+  program.info.sampled_pairs.push_back({.image = 0, .sampler = 1});
+  program.info.sampled_pairs.push_back({.image = 1, .sampler = 1});
+  return ExtractResourcePlan(program);
+}
+
+void TestMappedSrtUsesDirectReaderByDefault() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  const uint32_t dword = 0x12345678;
+  auto plan = SrtPlan(reinterpret_cast<uint64_t>(&dword));
+  uint32_t specialization_reads = 0;
+  const SrtRuntime runtime{.userdata = &specialization_reads,
+                           .read_specialization_memory =
+                               RejectSpecializationRead};
+  ResourceSnapshot snapshot;
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(plan, runtime, snapshot, specialization),
+        "mapped SRT stage materialization failed");
+  Check(specialization_reads == 0,
+        "ordinary SRT read used the specialization reader");
+  Check(snapshot.flattened_srt.size() == 1 &&
+            snapshot.flattened_srt[0] == dword,
+        "cache rematerialization did not use the direct reader by default");
+}
+
+void TestUnbasedFlatCacheHitMaterializes() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  auto plan = UnbasedFlatPlan();
+  ResourceSnapshot snapshot;
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(plan, {}, snapshot, specialization),
+        "unbased FLAT stage materialization failed");
+  Check(snapshot.buffers.empty() && snapshot.images.empty(),
+        "unbased FLAT plan produced unexpected descriptors");
+}
+
+void TestFailedMaterializationPreservesPriorStage() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  auto plan = UserDataBufferPlan();
+  ResourceSnapshot snapshot;
+  snapshot.user_data.push_back(0xfeedbeefu);
+  ResourceSpecialization specialization;
+  specialization.buffers.push_back({.packed_stride = 7});
+  Check(!MaterializeResources(plan, {}, snapshot, specialization),
+        "missing runtime user data did not reject the cached stage");
+  Check(snapshot.user_data == std::vector<uint32_t>{0xfeedbeefu} &&
+            specialization.buffers.size() == 1 &&
+            specialization.buffers[0].packed_stride == 7,
+        "failed cache materialization changed its destinations");
+}
+
+void TestMixedSamplerDuplicatesTheCorrectSnapshot() {
+  using namespace Libs::Graphics::ShaderRecompiler::IR;
+  auto plan = MixedSamplerPlan();
+  ResourceSnapshot snapshot;
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(plan, {}, snapshot, specialization),
+        "mixed sampler materialization failed");
+  Check(snapshot.samplers.size() == 3,
+        "mixed sampler materialization appended unrelated samplers");
+  Check(snapshot.samplers[2] == snapshot.samplers[1] &&
+            snapshot.samplers[2] != snapshot.samplers[0],
+        "point sampler variant duplicated the wrong runtime descriptor");
+}
+
+} // namespace
+
+namespace Common {
+
+int DbgExitHandler(const char *, int, std::string_view) { std::abort(); }
+
+int DbgExitHandler(const char *, int, fmt::text_style, std::string_view) {
+  std::abort();
+}
+
+int DbgExitIfHandler(const char *, const char *, int) { return 1; }
+
+void DbgExit(int) { std::abort(); }
+
+} // namespace Common
+
+int main() {
+  TestMappedSrtUsesDirectReaderByDefault();
+  TestUnbasedFlatCacheHitMaterializes();
+  TestFailedMaterializationPreservesPriorStage();
+  TestMixedSamplerDuplicatesTheCorrectSnapshot();
+  std::puts("ResourceMaterializationTests: all cases passed");
+  return 0;
+}
+
+// Keep this focused standalone target self-contained by amalgamating its small
+// typed-IR implementation set.
+#include "graphics/shader/recompiler/ir/Block.cpp"
+#include "graphics/shader/recompiler/ir/Program.cpp"
+#include "graphics/shader/recompiler/ir/Type.cpp"
+#include "graphics/shader/recompiler/ir/Value.cpp"
+#include "graphics/shader/recompiler/ir/opcodes/ValueOpcodes.cpp"

tests/ResourceTrackingTests.cpp

@@ -8,6 +8,7 @@
 #include "graphics/shader/recompiler/ir/passes/SrtWalker.h"
 
 #include <array>
+#include <bit>
 #include <cstring>
 #include <iostream>
 #include <limits>
@@ -29,6 +30,14 @@ void Check(bool condition, const char *message) {
   }
 }
 
+bool SameResourceSnapshot(const ResourceSnapshot &lhs,
+                          const ResourceSnapshot &rhs) {
+  return lhs.buffers == rhs.buffers && lhs.images == rhs.images &&
+         lhs.samplers == rhs.samplers &&
+         lhs.flattened_srt == rhs.flattened_srt &&
+         lhs.user_data == rhs.user_data;
+}
+
 template <typename F>
 void CheckFatal(F &&function, std::string_view expected, const char *message) {
   try {
@@ -250,6 +259,7 @@ MakeIndirectImageFixture(bool malformed, uint32_t material_immediate = 0,
 void TestInvariantIndirectImageMaterialization() {
   auto fixture = MakeIndirectImageFixture(false);
   fixture->PlanAndTrack();
+  auto resource_plan = ExtractResourcePlan(fixture->program);
   EliminateDeadCode(fixture->program.blocks);
   ValidateProgram(fixture->program, true);
 
@@ -298,24 +308,20 @@ void TestInvariantIndirectImageMaterialization() {
                      .userdata = &memory,
                      .read_specialization_memory = ReadLinearTestMemory};
   ResourceSnapshot snapshot;
-  const auto same_snapshot = [](const ResourceSnapshot &lhs,
-                                const ResourceSnapshot &rhs) {
-    return lhs.buffers == rhs.buffers && lhs.images == rhs.images &&
-           lhs.samplers == rhs.samplers &&
-           lhs.flattened_srt == rhs.flattened_srt &&
-           lhs.user_data == rhs.user_data &&
-           lhs.indirect_images.empty() == rhs.indirect_images.empty();
-  };
-  Check(MaterializeResources(fixture->program, runtime, snapshot) &&
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(resource_plan, runtime, snapshot, specialization) &&
             snapshot.images.size() == 1 &&
             std::equal(image_descriptor.begin(), image_descriptor.end(),
                        snapshot.images[0].dwords.begin()),
         "invariant indirect image table did not materialize");
 
   const auto prior_snapshot = snapshot;
+  const auto prior_specialization = specialization;
   memory.fail_address = 0x1004u;
-  Check(!MaterializeResources(fixture->program, runtime, snapshot) &&
-            same_snapshot(snapshot, prior_snapshot),
+  Check(!MaterializeResources(resource_plan, runtime, snapshot,
+                              specialization) &&
+            SameResourceSnapshot(snapshot, prior_snapshot) &&
+            specialization == prior_specialization,
         "rejected planning memory read mutated the snapshot");
   memory.fail_address = UINT64_MAX;
 
@@ -330,8 +336,9 @@ void TestInvariantIndirectImageMaterialization() {
   memory.words[(0x2020u - memory.base) / 4u + 3u] =
       image_descriptor[3] ^ (1u << 28u);
   ResourceSnapshot null_snapshot;
-  Check(MaterializeResources(fixture->program, runtime, null_snapshot) &&
-            null_snapshot.indirect_images.empty() &&
+  ResourceSpecialization null_specialization;
+  Check(MaterializeResources(resource_plan, runtime, null_snapshot,
+                             null_specialization) &&
             std::ranges::all_of(null_snapshot.images[0].dwords,
                                 [](uint32_t dword) { return dword == 0u; }),
         "stale typed null image descriptors were not canonicalized");
@@ -345,19 +352,25 @@ void TestInvariantIndirectImageMaterialization() {
   memory.words[(0x2020u - memory.base) / 4u] ^= 1u;
   memory.words[(0x1000u - memory.base + 36u) / 4u] = 1u;
   ResourceSnapshot dynamic_snapshot;
-  Check(MaterializeResources(fixture->program, runtime, dynamic_snapshot) &&
-            dynamic_snapshot.images.size() == 1 &&
-            dynamic_snapshot.indirect_images.size() == 1 &&
-            dynamic_snapshot.indirect_images[0].descriptors.size() == 2,
+  ResourceSpecialization dynamic_specialization;
+  Check(MaterializeResources(resource_plan, runtime, dynamic_snapshot,
+                             dynamic_specialization) &&
+            dynamic_snapshot.images.size() == 2 &&
+            dynamic_specialization.images.size() == 2,
         "dynamic indirect image table did not materialize");
-  SpecializeResources(fixture->program, dynamic_snapshot);
+  ApplyResourceSpecialization(fixture->program, dynamic_specialization);
   Check(fixture->program.info.images.size() == 2 &&
             fixture->program.info.images[0].indirect_root == 0 &&
-            fixture->program.info.images[0].indirect_mapping_capacity != 0 &&
+            fixture->program.info.images[0].indirect_search_iterations != 0 &&
             fixture->program.info.images[0].indirect_resources.size() == 2 &&
-            dynamic_snapshot.images.size() == 2 &&
-            dynamic_snapshot.indirect_images.empty(),
+            dynamic_snapshot.images.size() == 2,
         "dynamic indirect image table was not specialized transactionally");
+  const auto &mapping = dynamic_specialization.images[0];
+  const auto key_count = dynamic_snapshot.flattened_srt[mapping.indirect_mapping_offset];
+  Check(mapping.indirect_search_iterations == std::bit_width(key_count) &&
+            mapping.indirect_mapping_offset + 1u + key_count * 2u ==
+                dynamic_snapshot.flattened_srt.size(),
+        "indirect image mapping retained worst-case padding");
 
   for (uint32_t dword = 0; dword < image_descriptor.size(); dword++) {
     memory.words[(0x2000u - memory.base) / 4u + dword] =
@@ -368,22 +381,25 @@ void TestInvariantIndirectImageMaterialization() {
   memory.words[(0x2000u - memory.base) / 4u] += 0x100u;
   memory.words[(0x2020u - memory.base) / 4u] += 0x101u;
   ResourceSnapshot rebound_snapshot;
-  Check(MaterializeResources(fixture->program, runtime, rebound_snapshot) &&
-            ValidateResourceSpecialization(fixture->program, rebound_snapshot),
+  ResourceSpecialization rebound_specialization;
+  Check(MaterializeResources(resource_plan, runtime, rebound_snapshot,
+                             rebound_specialization) &&
+            rebound_specialization == dynamic_specialization,
         "stable indirect key mapping did not accept changed image addresses");
   memory.words[(0x2020u - memory.base) / 4u] =
       memory.words[(0x2000u - memory.base) / 4u];
-  Check(MaterializeResources(fixture->program, runtime, rebound_snapshot) &&
-            ValidateResourceSpecialization(fixture->program, rebound_snapshot),
-        "runtime indirect key mapping did not accept collapsed candidates");
-  const auto collapsed_snapshot = rebound_snapshot;
+  Check(MaterializeResources(resource_plan, runtime, rebound_snapshot,
+                             rebound_specialization) &&
+            rebound_specialization != dynamic_specialization,
+        "collapsed indirect candidates did not select a new specialization");
+  const auto collapsed_specialization = rebound_specialization;
   ResourceSnapshot capacity_snapshot;
+  ResourceSpecialization capacity_specialization;
   for (const uint32_t records : {1u, 3u}) {
     user_data[2] = records;
-    Check(
-        MaterializeResources(fixture->program, runtime, capacity_snapshot) &&
-            ValidateResourceSpecialization(fixture->program, capacity_snapshot),
-        "runtime indirect key mapping rejected a fitting material-table size");
+    Check(MaterializeResources(resource_plan, runtime, capacity_snapshot,
+                               capacity_specialization),
+          "runtime indirect key mapping rejected a valid material-table size");
   }
   user_data[2] = 2u;
   memory.words[(0x2020u - memory.base) / 4u] =
@@ -395,13 +411,14 @@ void TestInvariantIndirectImageMaterialization() {
         image_descriptor[dword];
   }
   memory.words[(0x1000u - memory.base + 68u) / 4u] = 2u;
-  Check(
-      !MaterializeResources(fixture->program, runtime, rebound_snapshot) &&
-          same_snapshot(rebound_snapshot, collapsed_snapshot),
-      "larger indirect candidate topology reused or mutated a cached snapshot");
+  Check(MaterializeResources(resource_plan, runtime, rebound_snapshot,
+                             rebound_specialization) &&
+            rebound_specialization != collapsed_specialization,
+        "larger indirect candidate topology reused the old specialization");
 
   auto memory_backed = MakeIndirectImageFixture(false, 0u, true);
   memory_backed->PlanAndTrack();
+  auto memory_backed_plan = ExtractResourcePlan(memory_backed->program);
   EliminateDeadCode(memory_backed->program.blocks);
   std::array<uint32_t, 11> memory_backed_user_data{0x1000u, 224u << 16u, 2u, 0u,
                                                    0x2000u, 16u << 16u,  4u, 0u,
@@ -413,9 +430,12 @@ void TestInvariantIndirectImageMaterialization() {
                                    .userdata = &memory,
                                    .read_specialization_memory =
                                        ReadLinearTestMemory};
-  Check(!MaterializeResources(memory_backed->program, memory_backed_runtime,
-                              snapshot) &&
-            same_snapshot(snapshot, prior_snapshot),
+  const auto memory_backed_prior_snapshot = snapshot;
+  const auto memory_backed_prior_specialization = specialization;
+  Check(!MaterializeResources(memory_backed_plan, memory_backed_runtime,
+                              snapshot, specialization) &&
+            SameResourceSnapshot(snapshot, memory_backed_prior_snapshot) &&
+            specialization == memory_backed_prior_specialization,
         "rejected indirect table descriptor read mutated the snapshot");
   memory.fail_address = UINT64_MAX;
 
@@ -584,7 +604,7 @@ void TestImagesSamplersAndAliases() {
 
   const auto storage = fixture.Image(image_words, 16);
   MemoryInfo storage_memory;
-  storage_memory.kind = ResourceKind::StorageImageUint;
+  storage_memory.kind = ResourceKind::Image;
   storage_memory.image_dimension = Decoder::ImageDimension::Dim2D;
   fixture.Emit(ValueOpcode::ImageAtomicIAdd32,
                {storage, image_address, Value(1u), Value(true)},
@@ -713,7 +733,7 @@ void TestDynamicStorageMipTracking() {
         {Value(0u), Value(0u), lod, Value(0u), Value(0u), Value(0u), Value(0u),
          Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u)});
     MemoryInfo memory;
-    memory.kind = ResourceKind::StorageImage;
+    memory.kind = ResourceKind::Image;
     memory.image_dimension = Decoder::ImageDimension::Dim2D;
     memory.image_address_components = has_mip ? 3u : 2u;
     memory.image_has_mip = has_mip;
@@ -728,6 +748,7 @@ void TestDynamicStorageMipTracking() {
   const auto mip2 = AddStore(12, true, Value(2u));
   const auto dynamic = AddStore(16, true, fixture.UserData(8));
   fixture.PlanAndTrack();
+  auto resource_plan = ExtractResourcePlan(fixture.program);
 
   const auto &images = fixture.program.info.images;
   Check(images.size() == 2 && images[0].mip_mode == ImageMipMode::None &&
@@ -758,47 +779,83 @@ void TestDynamicStorageMipTracking() {
        << 28u);
   descriptor.dwords[5] = 3u << 4u;
   descriptor.dword_count = 8;
+  std::array<uint32_t, 9> user_data{};
+  std::copy(descriptor.dwords.begin(), descriptor.dwords.end(),
+            user_data.begin());
+  user_data[8] = 2u;
+  SrtRuntime runtime{.user_data = user_data};
   ResourceSnapshot snapshot;
-  snapshot.images.assign(images.size(), descriptor);
-  SpecializeResources(fixture.program, snapshot);
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(resource_plan, runtime, snapshot,
+                             specialization),
+        "dynamic storage resources did not materialize");
+  ApplyResourceSpecialization(fixture.program, specialization);
   Check(fixture.program.info.images[1].mip_count == 3 &&
-            ValidateResourceSpecialization(fixture.program, snapshot),
+            snapshot.images.size() == fixture.program.info.images.size(),
         "base-1 through last-3 dynamic storage range was not specialized");
   ShaderComputeInputInfo compute{};
   CollectShaderInfo(fixture.program, {.compute = &compute});
-  AllocateBindings(fixture.program, 0);
+  AllocateBindings(fixture.program);
+  const auto storage_kind = DescriptorBindingForImage(images[0]);
+  Check(storage_kind.has_value(), "storage image has no descriptor binding");
   const auto *storage_binding =
-      FindBinding(fixture.program.bindings, DescriptorBindingKind::Storage2D);
+      FindBinding(fixture.program.bindings, *storage_kind);
   Check(storage_binding != nullptr &&
             storage_binding->resources == std::vector<uint32_t>({0, 1, 1, 1}),
         "dynamic storage mip descriptors were not expanded consecutively");
 
-  Program null_program;
-  null_program.resource_tracking_complete = true;
-  ImageResource null_image;
-  null_image.kind = ResourceKind::StorageImage;
-  null_image.dimension = Decoder::ImageDimension::Dim2D;
-  null_image.mip_mode = ImageMipMode::DynamicStorage;
-  null_image.written = true;
-  null_program.info.images.push_back(null_image);
+  Fixture null_fixture;
+  const auto null_handle = null_fixture.Image(
+      {Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
+       Value(0u), Value(0u)});
+  const auto null_address = null_fixture.Emit(
+      ValueOpcode::MakeImageAddress,
+      {Value(0u), Value(0u), null_fixture.UserData(0), Value(0u), Value(0u),
+       Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
+       Value(0u), Value(0u)});
+  MemoryInfo null_memory;
+  null_memory.kind = ResourceKind::Image;
+  null_memory.image_dimension = Decoder::ImageDimension::Dim2D;
+  null_memory.image_address_components = 3u;
+  null_memory.image_has_mip = true;
+  const auto null_data = null_fixture.Emit(
+      ValueOpcode::CompositeConstructU32x4,
+      {Value(1u), Value(2u), Value(3u), Value(4u)});
+  null_fixture.Emit(ValueOpcode::ImageWrite,
+                    {null_handle, null_address, null_data, Value(true)},
+                    null_fixture.AddMemory(null_memory, 4));
+  null_fixture.PlanAndTrack();
+  auto null_plan = ExtractResourcePlan(null_fixture.program);
   ResourceSnapshot null_snapshot;
-  DescriptorValue null_descriptor{};
-  null_descriptor.dword_count = 8;
-  null_snapshot.images.push_back(null_descriptor);
-  SpecializeResources(null_program, null_snapshot);
-  Check(null_program.info.images[0].mip_count == 1 &&
-            ValidateResourceSpecialization(null_program, null_snapshot),
+  ResourceSpecialization null_specialization;
+  const std::array<uint32_t, 1> null_user_data{0u};
+  Check(MaterializeResources(null_plan, {.user_data = null_user_data},
+                             null_snapshot, null_specialization),
+        "canonical null dynamic storage image did not materialize");
+  ApplyResourceSpecialization(null_fixture.program, null_specialization);
+  Check(null_fixture.program.info.images[0].mip_count == 1 &&
+            null_snapshot.images.size() == 1,
         "canonical null dynamic storage image did not retain one descriptor");
 
-  snapshot.images[1].dwords[3] =
-      (snapshot.images[1].dwords[3] & ~(0xfu << 16u)) | (2u << 16u);
-  Check(!ValidateResourceSpecialization(fixture.program, snapshot),
-        "a changed dynamic storage mip count reused the specialization");
-  snapshot.images[1].dwords[3] =
-      (snapshot.images[1].dwords[3] & ~((0xfu << 12u) | (0xfu << 16u))) |
+  auto changed_user_data = user_data;
+  changed_user_data[3] =
+      (changed_user_data[3] & ~(0xfu << 16u)) | (2u << 16u);
+  ResourceSnapshot changed_snapshot;
+  ResourceSpecialization changed_specialization;
+  Check(MaterializeResources(resource_plan, {.user_data = changed_user_data},
+                             changed_snapshot, changed_specialization) &&
+            changed_specialization != specialization,
+        "a changed dynamic storage mip count reused the specialization key");
+  changed_user_data[3] =
+      (changed_user_data[3] & ~((0xfu << 12u) | (0xfu << 16u))) |
       (4u << 12u) | (3u << 16u);
-  Check(!ValidateResourceSpecialization(fixture.program, snapshot),
-        "an inverted dynamic storage mip range was accepted");
+  const auto valid_snapshot = changed_snapshot;
+  const auto valid_specialization = changed_specialization;
+  Check(!MaterializeResources(resource_plan, {.user_data = changed_user_data},
+                              changed_snapshot, changed_specialization) &&
+            SameResourceSnapshot(changed_snapshot, valid_snapshot) &&
+            changed_specialization == valid_specialization,
+        "an inverted dynamic storage mip range was accepted or mutated output");
 }
 
 void TestSrtFlatteningAndRuntimeMemoization() {
@@ -841,7 +898,7 @@ void TestSrtFlatteningAndRuntimeMemoization() {
                      .userdata = &memory};
   std::vector<DescriptorValue> descriptors;
   std::vector<uint32_t> flat;
-  const DescriptorSourceRequest request{fixture.program.info.buffers[0].source};
+  const uint32_t request = fixture.program.info.buffers[0].source;
   Check(EvaluateRuntimeSources(fixture.program, std::span{&request, 1}, runtime,
                                descriptors, flat, {}),
         "typed runtime source evaluation failed");
@@ -861,7 +918,7 @@ void TestSrtFlatteningAndRuntimeMemoization() {
 
   ShaderComputeInputInfo compute{};
   CollectShaderInfo(fixture.program, {.compute = &compute});
-  AllocateBindings(fixture.program, 0);
+  AllocateBindings(fixture.program);
   Check(FindBinding(fixture.program.bindings,
                     DescriptorBindingKind::FlattenedSrt) != nullptr,
         "flattened typed SRT reads did not receive a binding");
@@ -904,7 +961,7 @@ void TestDynamicSrtReadRemainsExplicit() {
 
   ShaderComputeInputInfo compute{};
   CollectShaderInfo(fixture.program, {.compute = &compute});
-  AllocateBindings(fixture.program, 0);
+  AllocateBindings(fixture.program);
   Check(FindBinding(fixture.program.bindings,
                     DescriptorBindingKind::FlattenedSrt) == nullptr &&
             FindBinding(fixture.program.bindings,
@@ -1021,15 +1078,18 @@ void TestDmaAddressMaterialization() {
                {unbased, Value(0u), Value(0u), Value(9u), Value(true)},
                fixture.AddMemory(flat, 8));
   fixture.PlanAndTrack();
+  auto resource_plan = ExtractResourcePlan(fixture.program);
 
   Check(fixture.program.info.uses_dma,
         "typed address operations did not enable DMA");
   std::array<uint32_t, 2> user_data{0x2008u, 0u};
   SrtRuntime runtime{.user_data = user_data};
   ResourceSnapshot snapshot;
-  Check(MaterializeResources(fixture.program, runtime, snapshot),
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(resource_plan, runtime, snapshot,
+                             specialization),
         "DMA shader resources did not materialize");
-  SpecializeResources(fixture.program, snapshot);
+  ApplyResourceSpecialization(fixture.program, specialization);
 }
 
 void TestDynamicFlatAddressesUseDma() {
@@ -1051,13 +1111,16 @@ void TestDynamicFlatAddressesUseDma() {
   fixture.Emit(ValueOpcode::LoadAddressU8, {address, low, high, active},
                fixture.AddMemory(flat, 0xa4));
   fixture.PlanAndTrack();
+  auto resource_plan = ExtractResourcePlan(fixture.program);
 
   Check(fixture.program.info.uses_dma,
         "exec-masked FLAT address did not enable DMA");
   std::array<uint32_t, 3> user_data{0x23456780u, 1u, 1u};
   SrtRuntime runtime{.user_data = user_data};
   ResourceSnapshot snapshot;
-  Check(MaterializeResources(fixture.program, runtime, snapshot),
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(resource_plan, runtime, snapshot,
+                             specialization),
         "exec-masked FLAT shader resources did not materialize");
 
   Fixture mismatch;
@@ -1093,6 +1156,7 @@ void TestBufferSwizzleSpecialization() {
                {handle, Value(0u), Value(0u), Value(0u), Value(true)},
                fixture.AddMemory(memory, 4));
   fixture.PlanAndTrack();
+  auto resource_plan = ExtractResourcePlan(fixture.program);
 
   constexpr auto swizzle = Libs::Graphics::DstSel(4, 5, 0, 1);
   std::array<uint32_t, 4> user_data{
@@ -1104,16 +1168,22 @@ void TestBufferSwizzleSpecialization() {
           (1u << 24u)};
   SrtRuntime runtime{.user_data = user_data};
   ResourceSnapshot snapshot;
-  Check(MaterializeResources(fixture.program, runtime, snapshot),
+  ResourceSpecialization specialization;
+  Check(MaterializeResources(resource_plan, runtime, snapshot,
+                             specialization),
         "buffer resources did not materialize");
-  SpecializeResources(fixture.program, snapshot);
+  ApplyResourceSpecialization(fixture.program, specialization);
   Check(fixture.program.info.buffers[0].descriptor_swizzle == swizzle &&
-            ValidateResourceSpecialization(fixture.program, snapshot),
+            specialization.buffers[0].descriptor_swizzle == swizzle,
         "buffer destination selectors were not specialized");
 
-  snapshot.buffers[0].dwords[3] ^= 1u << 9u;
-  Check(!ValidateResourceSpecialization(fixture.program, snapshot),
-        "buffer swizzle change did not invalidate specialization");
+  user_data[3] ^= 1u << 9u;
+  ResourceSnapshot changed_snapshot;
+  ResourceSpecialization changed_specialization;
+  Check(MaterializeResources(resource_plan, runtime, changed_snapshot,
+                             changed_specialization) &&
+            changed_specialization != specialization,
+        "buffer swizzle change did not select a new specialization key");
 }
 
 void TestShaderInfoAndBindingLayout() {
@@ -1145,15 +1215,14 @@ void TestShaderInfoAndBindingLayout() {
                 StageInputKind::GlobalInvocationId,
         "typed shader values were not reflected in shader info");
 
-  AllocateBindings(fixture.program, 0);
+  AllocateBindings(fixture.program);
   Check(FindBinding(fixture.program.bindings, DescriptorBindingKind::Buffers) !=
                 nullptr &&
             FindBinding(fixture.program.bindings, DescriptorBindingKind::Gds) !=
                 nullptr &&
             FindBinding(fixture.program.bindings,
-                        DescriptorBindingKind::UserData) == nullptr &&
-            fixture.program.bindings.push_constant_size ==
-                fixture.program.bindings.ShaderDataDwords() * sizeof(uint32_t),
+                        DescriptorBindingKind::ShaderData) == nullptr &&
+	        fixture.program.bindings.UsesPushData(),
         "typed resources were not assigned native bindings");
   Check(NativeBinding(ShaderType::Compute, DescriptorBindingKind::Buffers) ==
                 static_cast<uint32_t>(DescriptorBindingKind::Buffers) &&
@@ -1168,6 +1237,113 @@ void TestShaderInfoAndBindingLayout() {
         "binding layout did not collect live typed user-data values");
 }
 
+void TestImageBindingAbi() {
+  using NumericClass = Libs::Graphics::Prospero::TextureNumericClass;
+
+  Check(ImageBindingCount == 36u &&
+            static_cast<uint32_t>(DescriptorBindingKind::Buffers) == 0u &&
+            static_cast<uint32_t>(DescriptorBindingKind::Samplers) == 37u &&
+            static_cast<uint32_t>(DescriptorBindingKind::Gds) == 38u &&
+            static_cast<uint32_t>(DescriptorBindingKind::BdaPagetable) == 39u &&
+            static_cast<uint32_t>(DescriptorBindingKind::FaultBuffer) == 40u &&
+            static_cast<uint32_t>(DescriptorBindingKind::FlattenedSrt) == 41u &&
+            static_cast<uint32_t>(DescriptorBindingKind::ShaderData) == 42u &&
+            static_cast<uint32_t>(DescriptorBindingKind::Count) == 43u,
+        "native descriptor binding anchors changed");
+
+  const std::array sampled_dimensions{
+      Decoder::ImageDimension::Dim1D,
+      Decoder::ImageDimension::Dim1DArray,
+      Decoder::ImageDimension::Dim2D,
+      Decoder::ImageDimension::Dim2DArray,
+      Decoder::ImageDimension::Dim2DMsaa,
+      Decoder::ImageDimension::Dim2DMsaaArray,
+      Decoder::ImageDimension::Dim3D,
+  };
+  const std::array storage_dimensions{
+      Decoder::ImageDimension::Dim1D, Decoder::ImageDimension::Dim1DArray,
+      Decoder::ImageDimension::Dim2D, Decoder::ImageDimension::Dim2DArray,
+      Decoder::ImageDimension::Dim3D,
+  };
+  const std::array sampled_classes{NumericClass::Float, NumericClass::Uint,
+                                   NumericClass::Sint};
+  const std::array storage_classes{NumericClass::Float, NumericClass::Uint};
+  uint32_t index = 0;
+  const auto CheckBinding =
+      [&](ImageResourceClass resource_class, NumericClass numeric_class,
+          Decoder::ImageDimension dimension, bool atomic) {
+        ImageResource image;
+        image.resource_class = resource_class;
+        image.numeric_class = numeric_class;
+        image.dimension = dimension;
+        image.atomic = atomic;
+        const auto kind = DescriptorBindingForImage(image);
+        Check(kind.has_value() &&
+                  static_cast<uint32_t>(*kind) == FirstImageBinding + index &&
+                  ImageBindingIndex(*kind) == index &&
+                  ImageBindingResourceClass(*kind) == resource_class &&
+                  NativeBinding(ShaderType::Compute, *kind) ==
+                      FirstImageBinding + index &&
+                  NativeBinding(ShaderType::Pixel, *kind) ==
+                      static_cast<uint32_t>(DescriptorBindingKind::Count) +
+                          FirstImageBinding + index,
+              "generated image descriptor binding changed ABI");
+        index++;
+      };
+  for (const auto numeric_class : sampled_classes) {
+    for (const auto dimension : sampled_dimensions) {
+      CheckBinding(ImageResourceClass::Sampled, numeric_class, dimension,
+                   false);
+    }
+  }
+  for (const auto numeric_class : storage_classes) {
+    for (const auto dimension : storage_dimensions) {
+      CheckBinding(ImageResourceClass::Storage, numeric_class, dimension,
+                   false);
+    }
+  }
+  for (const auto dimension : storage_dimensions) {
+    CheckBinding(ImageResourceClass::Storage, NumericClass::Uint, dimension,
+                 true);
+  }
+  Check(index == ImageBindingCount, "image descriptor ABI case count changed");
+
+  const auto Invalid = [](ImageResource image) {
+    return !DescriptorBindingForImage(image).has_value();
+  };
+  ImageResource image;
+  Check(Invalid(image), "untyped image received a descriptor binding");
+  image.resource_class = ImageResourceClass::Sampled;
+  image.numeric_class = NumericClass::Float;
+  image.dimension = Decoder::ImageDimension::Unknown;
+  Check(Invalid(image),
+        "unknown sampled dimension received a descriptor binding");
+  image.dimension = Decoder::ImageDimension::Dim2D;
+  image.numeric_class = NumericClass::Unsupported;
+  Check(Invalid(image),
+        "unsupported sampled class received a descriptor binding");
+  image.numeric_class = static_cast<NumericClass>(UINT32_MAX);
+  Check(Invalid(image), "invalid sampled class received a descriptor binding");
+  image.numeric_class = NumericClass::Float;
+  image.dimension = static_cast<Decoder::ImageDimension>(UINT32_MAX);
+  Check(Invalid(image),
+        "invalid sampled dimension received a descriptor binding");
+  image.dimension = Decoder::ImageDimension::Dim2D;
+  image.atomic = true;
+  Check(Invalid(image), "atomic sampled image received a descriptor binding");
+  image.resource_class = ImageResourceClass::Storage;
+  image.atomic = false;
+  image.numeric_class = NumericClass::Sint;
+  Check(Invalid(image), "signed storage image received a descriptor binding");
+  image.numeric_class = NumericClass::Float;
+  image.dimension = Decoder::ImageDimension::Dim2DMsaa;
+  Check(Invalid(image),
+        "multisampled storage image received a descriptor binding");
+  image.dimension = Decoder::ImageDimension::Dim2D;
+  image.atomic = true;
+  Check(Invalid(image), "float atomic image received a descriptor binding");
+}
+
 void TestGraphicsPushConstantLayout() {
   const auto AddUserData = [](Fixture &fixture, uint32_t count) {
     for (uint32_t index = 0; index < count; index++) {
@@ -1175,58 +1351,53 @@ void TestGraphicsPushConstantLayout() {
     }
     fixture.program.shader_info_complete = true;
   };
-  Fixture vertex(ShaderType::Vertex);
-  AddUserData(vertex, 9);
-  AllocateBindings(vertex.program, 0);
-  Check(vertex.program.bindings.push_constant_offset == 0 &&
-            vertex.program.bindings.push_constant_size == 9 * sizeof(uint32_t),
-        "vertex shader was not placed at the start of the graphics push bank");
-
-  const auto pixel_offset = vertex.program.bindings.push_constant_size;
+  uint32_t cursor = 0;
   Fixture pixel(ShaderType::Pixel);
   AddUserData(pixel, 4);
-  AllocateBindings(pixel.program, pixel_offset);
+  AllocateBindings(pixel.program, cursor);
   Check(
-      pixel.program.bindings.push_constant_offset == pixel_offset &&
-          pixel.program.bindings.push_constant_size == 4 * sizeof(uint32_t) &&
+      pixel.program.bindings.UsesPushData() &&
+          pixel.program.bindings.push_data_start_dword == 0 &&
           FindBinding(pixel.program.bindings,
-                      DescriptorBindingKind::UserData) == nullptr,
-      "pixel shader did not follow the vertex data in the graphics push bank");
+                      DescriptorBindingKind::ShaderData) == nullptr,
+      "pixel shader did not start the shared push-data block");
+  pixel.program.bindings.AdvancePushData(cursor);
+
+  Fixture vertex(ShaderType::Vertex);
+  AddUserData(vertex, 9);
+  AllocateBindings(vertex.program, cursor);
+  Check(vertex.program.bindings.UsesPushData() &&
+            vertex.program.bindings.push_data_start_dword == 4,
+        "vertex shader did not follow pixel data in the shared push-data block");
+  vertex.program.bindings.AdvancePushData(cursor);
+  Check(cursor == 13, "graphics push-data cursor advanced incorrectly");
 
   Fixture edge(ShaderType::Pixel);
-  AddUserData(edge, 1);
-  AllocateBindings(edge.program, NativePushConstantSize - sizeof(uint32_t));
-  Check(edge.program.bindings.push_constant_size == sizeof(uint32_t),
-        "last aligned push-constant dword did not fit in the graphics bank");
+  AddUserData(edge, NativePushConstantSize / sizeof(uint32_t));
+  AllocateBindings(edge.program);
+  Check(edge.program.bindings.UsesPushData() &&
+            FindBinding(edge.program.bindings,
+                        DescriptorBindingKind::ShaderData) == nullptr,
+        "the full shared push-data block did not fit");
 
   Fixture spill(ShaderType::Pixel);
-  AddUserData(spill, 32);
-  AllocateBindings(spill.program, pixel_offset);
+  AddUserData(spill, 20);
+  AllocateBindings(spill.program, cursor);
   Check(
-      spill.program.bindings.push_constant_size == 0 &&
+      !spill.program.bindings.UsesPushData() &&
+          spill.program.bindings.push_data_start_dword == PushData::NoStart &&
           FindBinding(spill.program.bindings,
-                      DescriptorBindingKind::UserData) != nullptr,
-      "pixel shader overlapping the vertex push data did not spill to storage");
+                      DescriptorBindingKind::ShaderData) != nullptr,
+      "a stage that exceeded the remaining shared push data did not spill to storage");
+  const auto spill_layout = spill.program.bindings;
+  spill.program.bindings.AdvancePushData(cursor);
+  Check(cursor == 13, "a spilled stage consumed shared push-data space");
 
-  Fixture full(ShaderType::Pixel);
-  AddUserData(full, 1);
-  AllocateBindings(full.program, NativePushConstantSize);
-  Check(full.program.bindings.push_constant_size == 0 &&
-            FindBinding(full.program.bindings,
-                        DescriptorBindingKind::UserData) != nullptr,
-        "full graphics push bank did not spill pixel user data to storage");
-
-  Fixture invalid(ShaderType::Pixel);
-  AddUserData(invalid, 1);
-  CheckFatal(
-      [&] {
-        AllocateBindings(invalid.program,
-                         NativePushConstantSize + sizeof(uint32_t));
-      },
-      "push-constant offset",
-      "push-constant placement beyond the graphics bank was accepted");
-  Check(!invalid.program.binding_layout_complete,
-        "push-constant placement beyond the graphics bank was accepted");
+  Fixture repeated_spill(ShaderType::Pixel);
+  AddUserData(repeated_spill, 20);
+  AllocateBindings(repeated_spill.program, 20);
+  Check(repeated_spill.program.bindings == spill_layout,
+        "storage fallback retained an irrelevant attempted push-data position");
 }
 
 void TestResourceLimitIsTransactional() {
@@ -1283,40 +1454,6 @@ void TestMalformedMemoryKindsRejected() {
         "image operation has invalid resource kind",
         "resource tracking accepted an image opcode with address metadata");
   }
-  {
-    Fixture fixture;
-    const auto image =
-        fixture.Image({Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
-                       Value(0u), Value(0u), Value(0u)},
-                      12);
-    MemoryInfo memory;
-    memory.kind = ResourceKind::StorageImage;
-    fixture.Emit(ValueOpcode::ImageRead,
-                 {image, fixture.ImageAddress(), Value(true)},
-                 fixture.AddMemory(memory, 12));
-    BuildSrtPlan(fixture.program);
-    CheckFatal(
-        [&] { TrackResources(fixture.program); },
-        "image operation has invalid resource kind",
-        "resource tracking accepted a sampled read with storage metadata");
-  }
-  {
-    Fixture fixture;
-    const auto image =
-        fixture.Image({Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
-                       Value(0u), Value(0u), Value(0u)},
-                      16);
-    MemoryInfo memory;
-    memory.kind = ResourceKind::StorageImage;
-    fixture.Emit(ValueOpcode::ImageAtomicIAdd32,
-                 {image, fixture.ImageAddress(), Value(1u), Value(true)},
-                 fixture.AddMemory(memory, 16));
-    BuildSrtPlan(fixture.program);
-    CheckFatal(
-        [&] { TrackResources(fixture.program); },
-        "image operation has invalid resource kind",
-        "resource tracking accepted a uint atomic with float storage metadata");
-  }
 }
 
 } // namespace
@@ -1346,6 +1483,7 @@ int main() {
     Run("dynamic FLAT address", TestDynamicFlatAddressesUseDma);
     Run("buffer swizzle specialization", TestBufferSwizzleSpecialization);
     Run("shader info and bindings", TestShaderInfoAndBindingLayout);
+    Run("image binding ABI", TestImageBindingAbi);
     Run("graphics push constants", TestGraphicsPushConstantLayout);
     Run("resource limit", TestResourceLimitIsTransactional);
     Run("malformed memory kinds", TestMalformedMemoryKindsRejected);

tests/ScalarProvenanceTests.cpp

@@ -319,6 +319,84 @@ void TestRuntime64BitDescriptorOps() {
         "64-bit typed descriptor arithmetic evaluation is incorrect");
 }
 
+void TestUniformFirstLaneSamplerLod() {
+  Fixture fixture;
+  const auto active = fixture.Emit(ValueOpcode::WqmMask, {Value(true)});
+  const auto stale = fixture.Emit(
+      ValueOpcode::GetVectorRegister, {Value(static_cast<VectorReg>(0))});
+  const auto write = [&](Value value, Value previous) {
+    return fixture.Emit(ValueOpcode::SelectU32, {active, value, previous});
+  };
+  const auto user = fixture.Emit(
+      ValueOpcode::GetUserData, {Value(static_cast<ScalarReg>(8))});
+  const auto as_float = fixture.Emit(ValueOpcode::ConvertF32U32, {user});
+  const auto initial = write(
+      fixture.Emit(ValueOpcode::BitCastU32F32, {as_float}), stale);
+  const auto initial_float =
+      fixture.Emit(ValueOpcode::BitCastF32U32, {initial});
+  const auto scaled = fixture.Emit(ValueOpcode::FPMul32,
+                                   {Value::F32(256.0f), initial_float});
+  const auto scaled_write = write(
+      fixture.Emit(ValueOpcode::BitCastU32F32, {scaled}), initial);
+  const auto scaled_float =
+      fixture.Emit(ValueOpcode::BitCastF32U32, {scaled_write});
+  const auto nan = fixture.Emit(ValueOpcode::FPIsNan32, {scaled_float});
+  const auto low = fixture.Emit(ValueOpcode::FPOrdLessThanEqual32,
+                                {scaled_float, Value::F32(0.0f)});
+  const auto high = fixture.Emit(ValueOpcode::FPOrdGreaterThanEqual32,
+                                 {scaled_float, Value::F32(4294967296.0f)});
+  const auto truncated = fixture.Emit(ValueOpcode::FPTrunc32, {scaled_float});
+  const auto safe_low = fixture.Emit(
+      ValueOpcode::SelectF32,
+      {fixture.Emit(ValueOpcode::LogicalOr, {nan, low}), Value::F32(0.0f),
+       truncated});
+  const auto safe = fixture.Emit(
+      ValueOpcode::SelectF32,
+      {high, Value::F32(4294967040.0f), safe_low});
+  const auto converted = fixture.Emit(ValueOpcode::ConvertU32F32, {safe});
+  const auto saturated = write(
+      fixture.Emit(ValueOpcode::SelectU32,
+                   {high, Value(UINT32_MAX), converted}),
+      scaled_write);
+  const auto lod = fixture.Emit(ValueOpcode::UMin32,
+                                {saturated, Value(0xfffu)});
+  const auto lod_write = write(lod, saturated);
+  const auto masked = fixture.Emit(ValueOpcode::BitwiseAnd32,
+                                   {lod_write, Value(0xfffu)});
+  const auto masked_write = write(masked, lod_write);
+  const auto packed = write(
+      fixture.Emit(
+          ValueOpcode::BitwiseOr32,
+          {fixture.Emit(ValueOpcode::ShiftLeftLogical32,
+                        {masked_write, Value(12u)}),
+           masked_write}),
+      masked_write);
+  const auto first = fixture.Emit(ValueOpcode::ReadFirstLane,
+                                  {packed, active});
+  const auto divergent = fixture.Emit(
+      ValueOpcode::ReadFirstLane, {stale, active});
+  fixture.Plan();
+
+  Check(ValidateRuntimeValue(fixture.program, first),
+        "uniform sampler LOD construction was rejected");
+  Check(!ValidateRuntimeValue(fixture.program, divergent),
+        "divergent first-lane value was accepted as uniform");
+  fixture.program.descriptor_sources.push_back(
+      {.dwords = {first}, .dword_count = 1});
+
+  std::array<uint32_t, 7> user_data{};
+  user_data[6] = 3u;
+  SrtRuntime runtime{.user_data = user_data};
+  DescriptorValue result;
+  Check(EvaluateDescriptorSource(fixture.program, 0, runtime, result) &&
+            result.dwords[0] == 0x00300300u,
+        "uniform sampler LOD evaluated incorrectly");
+  user_data[6] = 20u;
+  Check(EvaluateDescriptorSource(fixture.program, 0, runtime, result) &&
+            result.dwords[0] == 0x00ffffffu,
+        "uniform sampler LOD clamp evaluated incorrectly");
+}
+
 void TestConstantBufferBounds() {
   Fixture fixture;
   const auto memory = fixture.AddMemory(ResourceKind::ScalarBuffer);
@@ -475,6 +553,7 @@ int main() {
     TestInvariantAndDivergentPhi();
     TestControlDependentStandaloneLoadStaysTyped();
     TestRuntime64BitDescriptorOps();
+    TestUniformFirstLaneSamplerLod();
     TestConstantBufferBounds();
     TestReadLaneElimination();
     TestOptimizationPipeline();

tests/ShaderStageRuntimeTests.cpp

@@ -1,178 +0,0 @@
-#include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
-#include "graphics/shader/shader.h"
-
-#include <cstdio>
-#include <cstdlib>
-#include <memory>
-
-namespace {
-
-void Check(bool value, const char *text) {
-  if (!value) {
-    std::fprintf(stderr, "ShaderStageRuntimeTests: failed: %s\n", text);
-    std::abort();
-  }
-}
-
-bool RejectSpecializationRead(void *userdata, uint64_t, uint32_t *) {
-  ++*static_cast<uint32_t *>(userdata);
-  return false;
-}
-
-Libs::Graphics::ShaderRecompiler::IR::Block &
-AddValueBlock(Libs::Graphics::ShaderRecompiler::IR::Program &program) {
-  using namespace Libs::Graphics::ShaderRecompiler::IR;
-  auto block = std::make_unique<Block>();
-  auto *result = block.get();
-  program.blocks.push_back(result);
-  program.block_info.push_back({.id = 0});
-  program.block_storage.push_back(std::move(block));
-  return *result;
-}
-
-std::shared_ptr<const Libs::Graphics::ShaderRecompiler::IR::Program>
-SrtProgram(uint64_t address) {
-  using namespace Libs::Graphics::ShaderRecompiler::IR;
-  Program program;
-  program.stage = Libs::Graphics::ShaderType::Compute;
-  program.srt_plan_complete = true;
-  program.resource_tracking_complete = true;
-  auto &value_block = AddValueBlock(program);
-
-  MemoryInfo memory;
-  memory.kind = ResourceKind::ScalarAddress;
-  memory.planning_only = true;
-  program.memory_info.push_back(memory);
-  const auto low = Value(static_cast<uint32_t>(address));
-  const auto high = Value(static_cast<uint32_t>(address >> 32u));
-  auto &handle =
-      value_block.AppendNewInst(ValueOpcode::GetAddressResource, {low, high});
-  auto &raw = value_block.AppendNewInst(
-      ValueOpcode::LoadAddressU32,
-      {Value(&handle), Value(0u), Value(0u), Value(true)});
-  raw.SetFlags(MemoryFlags{.index = 0, .pc = 0x40});
-  program.srt_reads.push_back({Value(&raw), 0});
-
-  auto &srt = value_block.AppendNewInst(ValueOpcode::GetSrtResource);
-  auto &flat = value_block.AppendNewInst(ValueOpcode::ReadConst,
-                                         {Value(&srt), Value(0u)});
-  DescriptorSource source;
-  source.dwords[0] = Value(&flat);
-  source.dwords[1] = Value(0u);
-  source.dword_count = 2;
-  program.descriptor_sources.push_back(source);
-  return std::make_shared<const Program>(std::move(program));
-}
-
-std::shared_ptr<const Libs::Graphics::ShaderRecompiler::IR::Program>
-UnbasedFlatProgram() {
-  using namespace Libs::Graphics::ShaderRecompiler::IR;
-  Program program;
-  program.stage = Libs::Graphics::ShaderType::Compute;
-  program.srt_plan_complete = true;
-  program.resource_tracking_complete = true;
-  AddValueBlock(program);
-  program.info.uses_dma = true;
-  return std::make_shared<const Program>(std::move(program));
-}
-
-std::shared_ptr<const Libs::Graphics::ShaderRecompiler::IR::Program>
-UserDataBufferProgram() {
-  using namespace Libs::Graphics::ShaderRecompiler::IR;
-  Program program;
-  program.stage = Libs::Graphics::ShaderType::Compute;
-  program.srt_plan_complete = true;
-  program.resource_tracking_complete = true;
-  auto &value_block = AddValueBlock(program);
-
-  auto &user_data = value_block.AppendNewInst(
-      ValueOpcode::GetUserData, {Value(static_cast<ScalarReg>(0))});
-  DescriptorSource source;
-  source.dwords[0] = Value(&user_data);
-  source.dwords[1] = Value(0u);
-  source.dwords[2] = Value(0u);
-  source.dwords[3] = Value(0u);
-  source.dword_count = 4;
-  program.descriptor_sources.push_back(source);
-  program.info.buffers.push_back({.source = 0});
-  return std::make_shared<const Program>(std::move(program));
-}
-
-void TestMappedSrtUsesDirectReaderByDefault() {
-  using namespace Libs::Graphics;
-  const uint32_t dword = 0x12345678;
-  auto cached_program = SrtProgram(reinterpret_cast<uint64_t>(&dword));
-  ShaderStageRuntime stage;
-  uint32_t specialization_reads = 0;
-  Check(ShaderMaterializeStageRuntime(cached_program, {}, 0, stage,
-                                      RejectSpecializationRead,
-                                      &specialization_reads),
-        "mapped SRT stage materialization failed");
-  Check(specialization_reads == 0,
-        "ordinary SRT read used the specialization reader");
-  Check(stage.program == cached_program && stage.resources != nullptr,
-        "cache rematerialization did not publish the mapped stage");
-  Check(stage.resources->flattened_srt.size() == 1 &&
-            stage.resources->flattened_srt[0] == dword,
-        "cache rematerialization did not use the direct reader by default");
-}
-
-void TestUnbasedFlatCacheHitMaterializes() {
-  using namespace Libs::Graphics;
-  auto cached_program = UnbasedFlatProgram();
-  auto prior_program = std::make_shared<const ShaderRecompiler::IR::Program>();
-  auto prior_resources =
-      std::make_shared<const ShaderRecompiler::IR::ResourceSnapshot>();
-  ShaderStageRuntime stage{prior_program, prior_resources};
-  Check(ShaderMaterializeStageRuntime(cached_program, {}, 0, stage),
-        "unbased FLAT stage materialization failed");
-  Check(stage.program == cached_program && stage.resources != prior_resources,
-        "unbased FLAT cache hit did not publish its BDA stage snapshot");
-}
-
-void TestFailedMaterializationPreservesPriorStage() {
-  using namespace Libs::Graphics;
-  auto cached_program = UserDataBufferProgram();
-  auto prior_program = std::make_shared<const ShaderRecompiler::IR::Program>();
-  auto prior_resources =
-      std::make_shared<const ShaderRecompiler::IR::ResourceSnapshot>();
-  ShaderStageRuntime stage{prior_program, prior_resources};
-
-  Check(!ShaderMaterializeStageRuntime(cached_program, {}, 0, stage),
-        "missing runtime user data did not reject the cached stage");
-  Check(stage.program == prior_program && stage.resources == prior_resources,
-        "failed cache materialization replaced the prior stage");
-}
-
-} // namespace
-
-namespace Common {
-
-int DbgExitHandler(const char *, int, std::string_view) { std::abort(); }
-
-int DbgExitHandler(const char *, int, fmt::text_style, std::string_view) {
-  std::abort();
-}
-
-int DbgExitIfHandler(const char *, const char *, int) { return 1; }
-
-void DbgExit(int) { std::abort(); }
-
-} // namespace Common
-
-int main() {
-  TestMappedSrtUsesDirectReaderByDefault();
-  TestUnbasedFlatCacheHitMaterializes();
-  TestFailedMaterializationPreservesPriorStage();
-  std::puts("ShaderStageRuntimeTests: all cases passed");
-  return 0;
-}
-
-// Keep this focused standalone target self-contained by amalgamating its small
-// typed-IR implementation set.
-#include "graphics/shader/recompiler/ir/Block.cpp"
-#include "graphics/shader/recompiler/ir/Program.cpp"
-#include "graphics/shader/recompiler/ir/Type.cpp"
-#include "graphics/shader/recompiler/ir/Value.cpp"
-#include "graphics/shader/recompiler/ir/opcodes/ValueOpcodes.cpp"