shader: rework resource specialization and optimize pipeline caching

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/spirvEmitterImage.cpp

@@ -806,7 +806,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;
@@ -824,7 +824,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 =

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

@@ -341,14 +341,12 @@ constexpr std::array<ImageDimensionInfo, 7> ImageDimensions {{
 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;
@@ -361,7 +359,7 @@ struct EmitterState {
 	uint32_t                                         gds_variable            = 0;
 	uint32_t                                         gds_length              = 0;
 	uint32_t                                         push_constant_variable  = 0;
-	uint32_t                                         vsharp_storage_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;

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;

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,14 +172,14 @@ 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) {
@@ -604,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/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) {

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

@@ -8,11 +8,13 @@
 #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>
@@ -87,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;
 
@@ -139,7 +132,7 @@ struct ImageResource {
 	bool                          r128              = false;
 	uint32_t                      indirect_root     = NoIndirectImage;
 	uint32_t                      indirect_mapping_offset   = 0;
-	uint32_t                      indirect_mapping_capacity = 0;
+	uint32_t                      indirect_search_iterations = 0;
 	std::vector<uint32_t>         indirect_resources;
 
 	bool operator==(const ImageResource& other) const = default;
@@ -149,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;
 };
@@ -270,14 +264,28 @@ enum class DescriptorBindingKind : uint32_t {
 	BdaPagetable,
 	FaultBuffer,
 	FlattenedSrt,
-	UserData,
+	ShaderData,
 	Count,
 };
 
 static_assert(static_cast<uint32_t>(DescriptorBindingKind::Samplers) == 37u);
 static_assert(static_cast<uint32_t>(DescriptorBindingKind::Count) == 43u);
 
-constexpr uint32_t NativePushConstantSize = 128;
+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) +
@@ -375,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;
@@ -385,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;
 };
@@ -454,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();
 
@@ -462,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;
 
@@ -497,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/passes/BindingLayout.cpp

@@ -69,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());
@@ -139,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.cpp

@@ -7,6 +7,8 @@
 
 #include <algorithm>
 #include <array>
+#include <bit>
+#include <cstdio>
 #include <cstring>
 #include <fmt/format.h>
 #include <functional>
@@ -19,9 +21,22 @@ namespace {
 constexpr uint64_t AddressMask            = 0x0000ffffffffffffull;
 constexpr uint64_t MaxIndirectImageProbes = 65536u;
 
-[[noreturn]] void SpecializationFail(std::string_view message) {
-	EXIT("shader resource specialization failed: %s", std::string(message).c_str());
-	std::abort();
+struct IndirectImage {
+	uint32_t                     resource = 0;
+	std::vector<uint32_t>        keys;
+	std::vector<uint32_t>        candidates;
+	std::vector<DescriptorValue> descriptors;
+};
+
+struct MaterializedSnapshot {
+	ResourceSnapshot           resources;
+	std::vector<IndirectImage> indirect_images;
+};
+
+bool SpecializationFail(std::string_view message) {
+	std::fprintf(stderr, "shader resource specialization failed: %.*s\n",
+	             static_cast<int>(message.size()), message.data());
+	return false;
 }
 
 Decoder::ImageDimension DescriptorDimension(const DescriptorValue&  descriptor,
@@ -94,6 +109,11 @@ bool RequiresPointSampler(const ImageResource& image) {
 	       image.conversion_format != Prospero::BufferFormat::kInvalid;
 }
 
+bool RequiresPointSampler(const ResourceSpecialization::Image& image) {
+	return image.numeric_class == Prospero::TextureNumericClass::Sint ||
+	       image.conversion_format != Prospero::BufferFormat::kInvalid;
+}
+
 bool DescriptorIsCube(const DescriptorValue& descriptor) {
 	return static_cast<Prospero::ImageType>((descriptor.dwords[3] >> 28u) & 0xfu) ==
 	       Prospero::ImageType::kCube;
@@ -116,14 +136,14 @@ bool DecodeBufferDescriptor(const DescriptorValue& descriptor, ShaderBufferResou
 	return true;
 }
 
-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];
 }
 
-void MarkCleanFlatSlots(const Program& program, const DescriptorSource* source,
+void MarkCleanFlatSlots(const ResourcePlan& program, const DescriptorSource* source,
                         std::span<uint8_t> slots) {
 	if (source == nullptr) {
 		return;
@@ -186,8 +206,8 @@ bool ReadScalarBufferWord(const ShaderBufferResource& descriptor, uint32_t dynam
 
 bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
                               const DescriptorValue&                 material_value,
-                              const DescriptorValue& heap_value, const SrtRuntime& runtime,
-                              ResourceSnapshot::IndirectImage& result) {
+                              const DescriptorValue& heap_value, bool r128,
+                              const SrtRuntime& runtime, IndirectImage& result) {
 	ShaderBufferResource material;
 	ShaderBufferResource heap;
 	if (!DecodeBufferDescriptor(material_value, material) ||
@@ -212,6 +232,8 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 
 	std::vector<uint32_t>        keys {0u};
 	std::unordered_set<uint32_t> seen {0u};
+	keys.reserve(static_cast<size_t>(probe_count) + 1u);
+	seen.reserve(static_cast<size_t>(probe_count) + 1u);
 	for (uint64_t offset = residue; offset <= limit && probe_count != 0u; offset += step) {
 		uint32_t key = 0;
 		if (!ReadScalarBufferWord(material, static_cast<uint32_t>(offset), 0u, runtime, key)) {
@@ -225,9 +247,11 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 		}
 	}
 
-	ResourceSnapshot::IndirectImage next;
-	next.capacity = static_cast<uint32_t>(probe_count + 1u);
-	next.keys     = std::move(keys);
+	IndirectImage next;
+	next.keys = std::move(keys);
+	next.candidates.reserve(next.keys.size());
+	next.descriptors.reserve(
+	    std::min(next.keys.size(), static_cast<size_t>(ShaderInfo::MaxImages)));
 	for (const auto key: next.keys) {
 		DescriptorValue candidate;
 		candidate.dword_count  = 8u;
@@ -238,11 +262,14 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 				return false;
 			}
 		}
-		if (NullImageDescriptor(candidate) || !ValidImageDescriptor(candidate)) {
+		if (NullImageDescriptor(candidate) || !ValidImageDescriptor(candidate, r128)) {
 			candidate.dwords.fill(0);
 		}
 		const auto found = std::ranges::find(next.descriptors, candidate);
 		if (found == next.descriptors.end()) {
+			if (next.descriptors.size() >= ShaderInfo::MaxImages) {
+				return false;
+			}
 			next.descriptors.push_back(candidate);
 			next.candidates.push_back(static_cast<uint32_t>(next.descriptors.size() - 1u));
 		} else {
@@ -253,339 +280,122 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 	return true;
 }
 
-size_t FlattenedRuntimeDwords(const Program& program) {
-	size_t size = program.srt_reads.size();
-	for (uint32_t resource = 0; resource < program.info.images.size(); resource++) {
-		const auto& image = program.info.images[resource];
-		if (image.indirect_root == resource) {
-			size = std::max(size, static_cast<size_t>(image.indirect_mapping_offset) + 1u +
-			                          static_cast<size_t>(image.indirect_mapping_capacity) * 2u);
-		}
-	}
-	return size;
-}
-
 } // namespace
 
-bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot) {
-	if (!program.resource_tracking_complete) {
-		return false;
-	}
-	if (snapshot.buffers.size() != program.info.buffers.size() ||
-	    snapshot.images.size() != program.info.images.size() ||
-	    snapshot.samplers.size() != program.info.samplers.size()) {
-		return false;
-	}
-	if (snapshot.flattened_srt.size() != FlattenedRuntimeDwords(program)) {
-		return false;
-	}
-	if (program.binding_layout_complete) {
-		for (const auto reg: program.bindings.user_data_registers) {
-			if (reg < program.user_data_base ||
-			    reg - program.user_data_base >= snapshot.user_data.size()) {
-				return false;
-			}
-		}
-	}
-	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
-		const auto alias = program.info.buffers[i].image_alias;
-		if (alias != BufferResource::NoImageAlias && alias >= program.info.images.size()) {
-			return false;
-		}
-	}
-	const auto CheckWidth = [&](const auto& values, uint32_t width) {
-		for (uint32_t i = 0; i < values.size(); i++) {
-			if (values[i].dword_count != width) {
-				return false;
-			}
-		}
-		return true;
-	};
-	std::unordered_set<uint32_t> indirect_resources;
-	for (const auto& table: snapshot.indirect_images) {
-		const auto* source = table.resource < program.info.images.size()
-		                         ? Source(program, program.info.images[table.resource].source)
-		                         : nullptr;
-		if (source == nullptr || !source->indirect_image.has_value() ||
-		    program.info.images[table.resource].indirect_root != ImageResource::NoIndirectImage ||
-		    table.keys.empty() || table.keys.size() != table.candidates.size() ||
-		    table.capacity < table.keys.size() || table.descriptors.empty() ||
-		    !indirect_resources.insert(table.resource).second) {
-			return false;
-		}
-		for (const auto candidate: table.candidates) {
-			if (candidate >= table.descriptors.size()) {
-				return false;
-			}
-		}
-		if (snapshot.images[table.resource] != table.descriptors[table.candidates[0]]) {
-			return false;
-		}
-	}
-	return CheckWidth(snapshot.buffers, 4) && CheckWidth(snapshot.images, 8) &&
-	       CheckWidth(snapshot.samplers, 4);
-}
-
-bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot) {
-	if (!ValidateResourceSnapshot(program, snapshot)) {
-		return false;
-	}
-	if (!snapshot.indirect_images.empty()) {
-		return false;
-	}
-	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
-		const auto&          buffer = program.info.buffers[i];
-		ShaderBufferResource descriptor;
-		if (!DecodeBufferDescriptor(snapshot.buffers[i], descriptor)) {
-			return false;
-		}
-		if (buffer.packed_stride != descriptor.PackedStride() ||
-		    buffer.descriptor_format != descriptor.Format() ||
-		    buffer.descriptor_swizzle != descriptor.DstSelXYZW()) {
-			return false;
-		}
-	}
-	for (uint32_t i = 0; i < program.info.images.size(); i++) {
-		const auto& image      = program.info.images[i];
-		const auto& descriptor = snapshot.images[i];
-		const auto  mip_count  = StorageMipCount(image, descriptor);
-		if (mip_count == 0u || mip_count != image.mip_count) {
-			return false;
-		}
-		if (NullImageDescriptor(descriptor)) {
-			if (image.indirect_root != ImageResource::NoIndirectImage) {
-				const auto root = image.indirect_root;
-				if (root >= program.info.images.size() ||
-				    program.info.images[root].resource_class != image.resource_class ||
-				    program.info.images[root].numeric_class != image.numeric_class ||
-				    program.info.images[root].dimension != image.dimension ||
-				    program.info.images[root].mip_mode != image.mip_mode ||
-				    program.info.images[root].mip_count != image.mip_count ||
-				    program.info.images[root].conversion_format != image.conversion_format ||
-				    program.info.images[root].shader_swizzle != image.shader_swizzle ||
-				    program.info.images[root].cube != image.cube) {
-					return false;
-				}
-				continue;
-			}
-			const auto canonical_numeric = image.atomic ? Prospero::TextureNumericClass::Uint
-			                                            : Prospero::TextureNumericClass::Float;
-			if (image.dimension != Decoder::ImageDimension::Dim2D || image.cube ||
-			    image.resource_class == ImageResourceClass::None ||
-			    image.numeric_class != canonical_numeric) {
-				return false;
-			}
-			continue;
-		}
-		const auto dimension = DescriptorDimension(descriptor, image.dimension);
-		if (dimension == Decoder::ImageDimension::Unknown || dimension != image.dimension ||
-		    DescriptorIsCube(descriptor) != image.cube) {
-			return false;
-		}
-		if (image.resource_class == ImageResourceClass::None) {
-			return false;
-		}
-		const bool storage = image.resource_class == ImageResourceClass::Storage;
-		const auto format =
-		    static_cast<Prospero::BufferFormat>((descriptor.dwords[1] >> 20u) & 0x1ffu);
-		if (image.atomic && format != Prospero::BufferFormat::k32UInt) {
-			return false;
-		}
-		const auto conversion_format = ImageConversionFormat(format);
-		if (image.conversion_format != conversion_format) {
-			return false;
-		}
-		if ((storage || conversion_format != Prospero::BufferFormat::kInvalid) &&
-		    image.shader_swizzle != DescriptorImageSwizzle(descriptor)) {
-			return false;
-		}
-		auto numeric_class = Prospero::SampledTextureNumericClass(format);
-		if (storage) {
-			const bool raw_sint = format == Prospero::BufferFormat::k32SInt && image.written &&
-			                      !image.read && !image.atomic;
-			if ((!raw_sint && numeric_class == Prospero::TextureNumericClass::Sint) ||
-			    numeric_class == Prospero::TextureNumericClass::Unsupported) {
-				return false;
-			}
-			if (raw_sint) {
-				numeric_class = Prospero::TextureNumericClass::Uint;
-			}
-		} else if (image.depth_compare && numeric_class != Prospero::TextureNumericClass::Float) {
-			return false;
-		}
-		if (image.numeric_class != numeric_class) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
-                          ResourceSnapshot& snapshot) {
+static bool MaterializeSnapshot(const ResourcePlan& program, const SrtRuntime& runtime,
+                                MaterializedSnapshot& snapshot) {
 	if (!program.resource_tracking_complete) {
 		return false;
 	}
 
-	std::vector<DescriptorSourceRequest> requests;
-	std::vector<uint8_t>                 clean_flat_slots(program.srt_reads.size());
-	requests.reserve(program.info.buffers.size() + program.info.images.size() * 2u +
-	                 program.info.samplers.size());
-	for (const auto& buffer: program.info.buffers) {
-		requests.push_back({buffer.source});
-	}
-	for (const auto& image: program.info.images) {
-		const auto* source = Source(program, image.source);
-		if (source != nullptr && source->indirect_image.has_value()) {
-			if (runtime.read_specialization_memory == nullptr) {
-				return false;
-			}
-			MarkCleanFlatSlots(program, Source(program, source->indirect_image->material_source),
-			                   clean_flat_slots);
-			MarkCleanFlatSlots(program, Source(program, source->indirect_image->heap_source),
-			                   clean_flat_slots);
-		} else {
-			requests.push_back({image.source});
-		}
-	}
-	for (const auto& sampler: program.info.samplers) {
-		requests.push_back({sampler.source});
+	if (program.requires_specialization_memory && runtime.read_specialization_memory == nullptr) {
+		return false;
 	}
 	std::vector<DescriptorValue> values;
 	std::vector<uint32_t>        flattened_srt;
-	if (!EvaluateRuntimeSources(program, requests, runtime, values, flattened_srt,
-	                            clean_flat_slots)) {
+	if (!EvaluateRuntimeSources(program, program.materialization_sources, runtime, values,
+	                            flattened_srt, program.clean_flat_slots)) {
 		return false;
 	}
 
-	ResourceSnapshot next;
-	auto             cursor = values.begin();
+	auto& next   = snapshot.resources;
+	auto  cursor = values.begin();
 	next.buffers.assign(cursor, cursor + program.info.buffers.size());
 	cursor += program.info.buffers.size();
-	for (auto& descriptor: next.buffers) {
-		ShaderBufferResource buffer;
-		if (DecodeBufferDescriptor(descriptor, buffer) && buffer.Type() != 0) {
-			descriptor.dwords.fill(0);
-		}
-	}
 	next.flattened_srt = std::move(flattened_srt);
-	next.flattened_srt.resize(FlattenedRuntimeDwords(program));
 	next.images.resize(program.info.images.size());
-	std::vector<uint8_t> image_written(program.info.images.size());
 	for (uint32_t image_index = 0; image_index < program.info.images.size(); image_index++) {
 		const auto& image  = program.info.images[image_index];
 		const auto* source = Source(program, image.source);
 		if (source != nullptr && source->indirect_image.has_value()) {
-			if (image.indirect_root != ImageResource::NoIndirectImage &&
-			    image.indirect_root != image_index) {
-				continue;
-			}
-			const std::array requests {
-			    DescriptorSourceRequest {source->indirect_image->material_source},
-			    DescriptorSourceRequest {source->indirect_image->heap_source}};
-			SrtRuntime clean_runtime  = runtime;
-			clean_runtime.read_memory = runtime.read_specialization_memory;
+			const std::array requests {source->indirect_image->material_source,
+			                           source->indirect_image->heap_source};
+			SrtRuntime       clean_runtime = runtime;
+			clean_runtime.read_memory      = runtime.read_specialization_memory;
 			std::vector<DescriptorValue> tables;
 			if (!EvaluateDescriptorSources(program, requests, clean_runtime, tables)) {
 				return false;
 			}
-			const auto&                     material = tables[0];
-			const auto&                     heap     = tables[1];
-			ResourceSnapshot::IndirectImage table;
-			if (!MaterializeIndirectImage(*source->indirect_image, material, heap, runtime,
-			                              table)) {
+			const auto&   material = tables[0];
+			const auto&   heap     = tables[1];
+			IndirectImage table;
+			if (!MaterializeIndirectImage(*source->indirect_image, material, heap, image.r128,
+			                              runtime, table)) {
 				return false;
 			}
-			if (image.indirect_root == ImageResource::NoIndirectImage) {
-				next.images[image_index]   = table.descriptors[table.candidates[0]];
-				image_written[image_index] = 1u;
-				if (table.descriptors.size() > 1u) {
-					table.resource = image_index;
-					next.indirect_images.push_back(std::move(table));
-				}
-				continue;
-			}
-			if (table.keys.size() > image.indirect_mapping_capacity ||
-			    table.descriptors.size() > image.indirect_resources.size()) {
-				return false;
-			}
-			for (uint32_t candidate = 0; candidate < image.indirect_resources.size(); candidate++) {
-				const auto resource = image.indirect_resources[candidate];
-				if (resource >= program.info.images.size() ||
-				    program.info.images[resource].indirect_root != image_index) {
-					return false;
-				}
-				next.images[resource] =
-				    table.descriptors[candidate < table.descriptors.size() ? candidate : 0u];
-				image_written[resource] = 1u;
-			}
-			std::vector<uint32_t> order(table.keys.size());
-			std::iota(order.begin(), order.end(), 0u);
-			std::ranges::sort(order, {}, [&](uint32_t index) { return table.keys[index]; });
-			const auto mapping          = image.indirect_mapping_offset;
-			next.flattened_srt[mapping] = static_cast<uint32_t>(table.keys.size());
-			for (uint32_t entry = 0; entry < order.size(); entry++) {
-				const auto source              = order[entry];
-				const auto offset              = mapping + 1u + entry * 2u;
-				next.flattened_srt[offset]     = table.keys[source];
-				next.flattened_srt[offset + 1] = table.candidates[source];
+			next.images[image_index] = table.descriptors[table.candidates[0]];
+			if (table.descriptors.size() > 1u) {
+				table.resource = image_index;
+				snapshot.indirect_images.push_back(std::move(table));
 			}
 		} else {
 			auto descriptor = *cursor++;
 			if (!ValidImageDescriptor(descriptor, image.r128)) {
 				descriptor.dwords.fill(0);
 			}
-			next.images[image_index]   = descriptor;
-			image_written[image_index] = 1u;
+			next.images[image_index] = descriptor;
 		}
 	}
-	if (std::ranges::find(image_written, uint8_t {0}) != image_written.end()) {
-		return false;
-	}
 	next.samplers.assign(cursor, cursor + program.info.samplers.size());
 	next.user_data.assign(runtime.user_data.begin(), runtime.user_data.end());
-	if (!ValidateResourceSnapshot(program, next)) {
-		return false;
-	}
-	snapshot = std::move(next);
 	return true;
 }
 
-void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
-	if (!program.resource_tracking_complete || program.shader_info_complete ||
-	    program.binding_layout_complete) {
-		return SpecializationFail(!program.resource_tracking_complete
-		                              ? "shader resources were not tracked"
-		                              : "resource specialization is too late");
-	}
-	if (!ValidateResourceSnapshot(program, snapshot)) {
-		return SpecializationFail("invalid resource snapshot");
-	}
+struct SamplerPlan {
+	std::array<uint32_t, ShaderInfo::MaxSamplers> point_sampler {};
+	uint32_t                                      sampler_count = 0;
+};
 
-	auto next          = program.info;
-	auto next_snapshot = snapshot;
+template <typename Images>
+bool BuildSamplerPlan(const ShaderInfo& base, const Images& images, SamplerPlan& plan);
+
+static bool BuildResourceSpecialization(const ResourcePlan& program, MaterializedSnapshot snapshot,
+                                        ResourceSnapshot&       specialized_snapshot,
+                                        ResourceSpecialization& specialization) {
+	auto                   next_snapshot = std::move(snapshot.resources);
+	ResourceSpecialization next_specialization;
+	next_specialization.buffers.reserve(program.info.buffers.size());
+	size_t image_count   = program.info.images.size();
+	size_t mapping_words = 0;
 	for (const auto& table: snapshot.indirect_images) {
-		if (table.resource >= next.images.size() || table.descriptors.size() < 2u ||
-		    next.images.size() + table.descriptors.size() - 1u > ShaderInfo::MaxImages) {
+		if (table.resource >= program.info.images.size() || table.descriptors.size() < 2u ||
+		    image_count + table.descriptors.size() - 1u > ShaderInfo::MaxImages) {
 			return SpecializationFail(
 			    "indirect image candidates exceed the dense image resource limit");
 		}
-		const auto            root_image = next.images[table.resource];
-		std::vector<uint32_t> resources(table.descriptors.size());
-		resources[0] = table.resource;
+		image_count += table.descriptors.size() - 1u;
+		mapping_words += 1u + table.keys.size() * 2u;
+	}
+	next_snapshot.images.reserve(image_count);
+	next_snapshot.flattened_srt.reserve(next_snapshot.flattened_srt.size() + mapping_words);
+	next_specialization.images.reserve(image_count);
+	for (const auto& image: program.info.images) {
+		next_specialization.images.push_back({
+		    .numeric_class              = image.numeric_class,
+		    .dimension                  = image.dimension,
+		    .mip_count                  = image.mip_count,
+		    .conversion_format          = image.conversion_format,
+		    .shader_swizzle             = image.shader_swizzle,
+		    .indirect_root              = image.indirect_root,
+		    .indirect_mapping_offset    = image.indirect_mapping_offset,
+		    .indirect_search_iterations = image.indirect_search_iterations,
+		    .cube                       = image.cube,
+		});
+	}
+	for (const auto& table: snapshot.indirect_images) {
+		const auto root_image = next_specialization.images[table.resource];
 		for (uint32_t candidate = 1; candidate < table.descriptors.size(); candidate++) {
-			resources[candidate] = static_cast<uint32_t>(next.images.size());
-			auto image           = root_image;
-			image.indirect_root  = table.resource;
-			next.images.push_back(std::move(image));
+			auto image          = root_image;
+			image.indirect_root = table.resource;
+			next_specialization.images.push_back(image);
 			next_snapshot.images.push_back(table.descriptors[candidate]);
 		}
-		auto& root                     = next.images[table.resource];
-		root.indirect_root             = table.resource;
-		root.indirect_mapping_offset   = static_cast<uint32_t>(next_snapshot.flattened_srt.size());
-		root.indirect_mapping_capacity = table.capacity;
-		root.indirect_resources        = std::move(resources);
+		auto& root                      = next_specialization.images[table.resource];
+		root.indirect_root              = table.resource;
+		root.indirect_mapping_offset    = static_cast<uint32_t>(next_snapshot.flattened_srt.size());
+		root.indirect_search_iterations = std::bit_width(table.keys.size());
 		next_snapshot.flattened_srt.resize(next_snapshot.flattened_srt.size() + 1u +
-		                                   static_cast<size_t>(table.capacity) * 2u);
+		                                   table.keys.size() * 2u);
 		std::vector<uint32_t> order(table.keys.size());
 		std::iota(order.begin(), order.end(), 0u);
 		std::ranges::sort(order, {}, [&](uint32_t index) { return table.keys[index]; });
@@ -599,36 +409,58 @@ void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 		}
 		next_snapshot.images[table.resource] = table.descriptors[0];
 	}
-	next_snapshot.indirect_images.clear();
-	for (uint32_t i = 0; i < next.buffers.size(); i++) {
+	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
+		auto&                descriptor_value = next_snapshot.buffers[i];
 		ShaderBufferResource descriptor;
-		if (!DecodeBufferDescriptor(next_snapshot.buffers[i], descriptor)) {
+		if (!DecodeBufferDescriptor(descriptor_value, descriptor)) {
 			return SpecializationFail(fmt::format("buffer descriptor {} has invalid width", i));
 		}
-		next.buffers[i].packed_stride      = descriptor.PackedStride();
-		next.buffers[i].descriptor_format  = descriptor.Format();
-		next.buffers[i].descriptor_swizzle = descriptor.DstSelXYZW();
+		if (descriptor.Type() != 0) {
+			descriptor_value.dwords.fill(0);
+			descriptor = {};
+		}
+		auto       packed_stride = descriptor.PackedStride();
+		const auto stride        = packed_stride & 0x3fffu;
+		const bool swizzle       = stride != 0u && ((packed_stride >> 14u) & 1u) != 0u;
+		if (stride == 0u) {
+			packed_stride &= ~((1u << 14u) | (3u << 16u));
+		} else if (!swizzle) {
+			packed_stride &= ~(3u << 16u);
+		}
+		next_specialization.buffers.push_back({
+		    .packed_stride     = packed_stride,
+		    .descriptor_format = program.info.buffers[i].formatted
+		                             ? descriptor.Format()
+		                             : Prospero::BufferFormat::kInvalid,
+		    .descriptor_swizzle =
+		        program.info.buffers[i].formatted ? descriptor.DstSelXYZW() : DstSel(4, 5, 6, 7),
+		});
 	}
-	for (uint32_t i = 0; i < next.images.size(); i++) {
+	for (uint32_t i = 0; i < next_specialization.images.size(); i++) {
 		const auto& descriptor = next_snapshot.images[i];
-		auto&       image      = next.images[i];
-		if (image.resource_class == ImageResourceClass::None ||
-		    (image.atomic && image.resource_class != ImageResourceClass::Storage)) {
+		auto&       image      = next_specialization.images[i];
+		const auto  base_index = i < program.info.images.size() ? i : image.indirect_root;
+		if (base_index >= program.info.images.size()) {
+			return SpecializationFail(fmt::format("image resource {} has an invalid root", i));
+		}
+		const auto& base = program.info.images[base_index];
+		if (base.resource_class == ImageResourceClass::None ||
+		    (base.atomic && base.resource_class != ImageResourceClass::Storage)) {
 			return SpecializationFail(fmt::format("image resource {} has an invalid class", i));
 		}
-		image.mip_count        = StorageMipCount(image, descriptor);
+		image.mip_count = StorageMipCount(base, descriptor);
 		if (image.mip_count == 0u) {
 			return SpecializationFail(
 			    fmt::format("storage image descriptor {} has an invalid mip range", i));
 		}
 		if (NullImageDescriptor(descriptor)) {
-			image.numeric_class = image.atomic ? Prospero::TextureNumericClass::Uint
-			                                   : Prospero::TextureNumericClass::Float;
+			image.numeric_class = base.atomic ? Prospero::TextureNumericClass::Uint
+			                                  : Prospero::TextureNumericClass::Float;
 			image.dimension     = Decoder::ImageDimension::Dim2D;
 			image.cube          = false;
 			continue;
 		}
-		const auto descriptor_dimension = DescriptorDimension(descriptor, image.dimension);
+		const auto descriptor_dimension = DescriptorDimension(descriptor, base.dimension);
 		if (descriptor_dimension == Decoder::ImageDimension::Unknown) {
 			return SpecializationFail(fmt::format(
 			    "image descriptor {} has unsupported type {}: {:08x},{:08x},{:08x},{:08x},"
@@ -641,19 +473,19 @@ void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 		image.cube      = DescriptorIsCube(descriptor);
 		const auto format =
 		    static_cast<Prospero::BufferFormat>((descriptor.dwords[1] >> 20u) & 0x1ffu);
-		if (image.atomic && format != Prospero::BufferFormat::k32UInt) {
+		if (base.atomic && format != Prospero::BufferFormat::k32UInt) {
 			return SpecializationFail(
 			    fmt::format("atomic image descriptor {} uses unsupported format {}", i,
 			                static_cast<uint32_t>(format)));
 		}
-		const bool storage      = image.resource_class == ImageResourceClass::Storage;
+		const bool storage      = base.resource_class == ImageResourceClass::Storage;
 		image.conversion_format = ImageConversionFormat(format);
 		if (storage || image.conversion_format != Prospero::BufferFormat::kInvalid) {
 			image.shader_swizzle = DescriptorImageSwizzle(descriptor);
 		}
 		const bool raw_sint_storage = storage && format == Prospero::BufferFormat::k32SInt &&
-		                              image.written && !image.read && !image.atomic;
-		image.numeric_class = Prospero::SampledTextureNumericClass(format);
+		                              base.written && !base.read && !base.atomic;
+		image.numeric_class         = Prospero::SampledTextureNumericClass(format);
 		if (storage) {
 			if ((!raw_sint_storage && image.numeric_class == Prospero::TextureNumericClass::Sint) ||
 			    image.numeric_class == Prospero::TextureNumericClass::Unsupported) {
@@ -665,46 +497,49 @@ void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 				image.numeric_class = Prospero::TextureNumericClass::Uint;
 			}
 		} else if (image.numeric_class == Prospero::TextureNumericClass::Unsupported ||
-		           (image.depth_compare &&
+		           (base.depth_compare &&
 		            image.numeric_class != Prospero::TextureNumericClass::Float)) {
 			return SpecializationFail(
 			    fmt::format("sampled image descriptor {} uses unsupported format {}", i,
 			                static_cast<uint32_t>(format)));
 		}
 	}
-	for (uint32_t root_index = 0; root_index < next.images.size(); root_index++) {
-		auto& root = next.images[root_index];
+	for (uint32_t root_index = 0; root_index < next_specialization.images.size(); root_index++) {
+		auto& root = next_specialization.images[root_index];
 		if (root.indirect_root != root_index) {
 			continue;
 		}
-		if (root.indirect_mapping_capacity == 0u || root.indirect_resources.size() < 2u ||
+		const auto key_count = root.indirect_mapping_offset < next_snapshot.flattened_srt.size()
+		                           ? next_snapshot.flattened_srt[root.indirect_mapping_offset]
+		                           : 0u;
+		if (root.indirect_search_iterations == 0u || key_count < 2u ||
 		    static_cast<size_t>(root.indirect_mapping_offset) + 1u +
-		            static_cast<size_t>(root.indirect_mapping_capacity) * 2u >
+		            static_cast<size_t>(key_count) * 2u >
 		        next_snapshot.flattened_srt.size()) {
 			return SpecializationFail("indirect image specialization has an invalid key mapping");
 		}
-		uint32_t exemplar = ImageResource::NoIndirectImage;
-		for (const auto resource: root.indirect_resources) {
-			if (resource >= next.images.size() ||
-			    next.images[resource].indirect_root != root_index) {
-				return SpecializationFail("indirect image specialization has an invalid candidate");
+		uint32_t exemplar       = ImageResource::NoIndirectImage;
+		uint32_t resource_count = 0;
+		for (uint32_t resource = 0; resource < next_specialization.images.size(); resource++) {
+			if (next_specialization.images[resource].indirect_root != root_index) {
+				continue;
 			}
-			if (!NullImageDescriptor(next_snapshot.images[resource])) {
+			resource_count++;
+			if (exemplar == ImageResource::NoIndirectImage &&
+			    !NullImageDescriptor(next_snapshot.images[resource])) {
 				exemplar = resource;
-				break;
 			}
 		}
-		if (exemplar == ImageResource::NoIndirectImage) {
+		if (resource_count < 2u || exemplar == ImageResource::NoIndirectImage) {
 			return SpecializationFail("indirect image specialization has no typed candidate");
 		}
-		const auto& image_class = next.images[exemplar];
-		for (uint32_t candidate = 0; candidate < next.images.size(); candidate++) {
-			auto& image = next.images[candidate];
+		const auto& image_class = next_specialization.images[exemplar];
+		for (uint32_t candidate = 0; candidate < next_specialization.images.size(); candidate++) {
+			auto& image = next_specialization.images[candidate];
 			if (image.indirect_root != root_index) {
 				continue;
 			}
 			if (NullImageDescriptor(next_snapshot.images[candidate])) {
-				image.resource_class    = image_class.resource_class;
 				image.numeric_class     = image_class.numeric_class;
 				image.dimension         = image_class.dimension;
 				image.mip_count         = image_class.mip_count;
@@ -712,65 +547,225 @@ void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 				image.shader_swizzle    = image_class.shader_swizzle;
 				image.cube              = image_class.cube;
 			}
-			if (image.resource_class != image_class.resource_class ||
-			    image.numeric_class != image_class.numeric_class ||
+			if (image.numeric_class != image_class.numeric_class ||
 			    image.dimension != image_class.dimension ||
-			    image.mip_mode != image_class.mip_mode ||
 			    image.mip_count != image_class.mip_count ||
 			    image.conversion_format != image_class.conversion_format ||
 			    image.shader_swizzle != image_class.shader_swizzle ||
-			    image.depth_compare != image_class.depth_compare ||
 			    image.cube != image_class.cube) {
 				return SpecializationFail(
 				    fmt::format("indirect image table at pc 0x{:08x} has incompatible candidates",
-				                root.first_use_pc));
+				                program.info.images[root_index].first_use_pc));
 			}
 		}
 	}
-	auto memory_info = program.memory_info;
+	SamplerPlan sampler_plan;
+	if (!BuildSamplerPlan(program.info, next_specialization.images, sampler_plan)) {
+		return SpecializationFail("specialized sampler layout exceeds its resource limit");
+	}
+	for (uint32_t index = 0; index < program.info.samplers.size(); index++) {
+		const auto target = sampler_plan.point_sampler[index];
+		if (target != UINT32_MAX && target >= program.info.samplers.size()) {
+			next_snapshot.samplers.push_back(next_snapshot.samplers[index]);
+		}
+	}
+	specialization       = std::move(next_specialization);
+	specialized_snapshot = std::move(next_snapshot);
+	return true;
+}
 
-	struct SamplerUsage {
-		bool native     = false;
-		bool point_only = false;
-	};
-	std::vector<SamplerUsage> sampler_usage(next.samplers.size());
-	for (const auto& pair: next.sampled_pairs) {
-		if (pair.image >= next.images.size() || pair.sampler >= next.samplers.size()) {
-			return SpecializationFail(
-			    fmt::format("sampled resource pair at pc 0x{:08x} is invalid", pair.first_use_pc));
+template <typename Images>
+bool BuildSamplerPlan(const ShaderInfo& base, const Images& images, SamplerPlan& plan) {
+	if (base.samplers.size() > plan.point_sampler.size()) {
+		return false;
+	}
+	std::array<uint8_t, ShaderInfo::MaxSamplers> usage {};
+	plan.point_sampler.fill(UINT32_MAX);
+	plan.sampler_count = static_cast<uint32_t>(base.samplers.size());
+	for (const auto& pair: base.sampled_pairs) {
+		if (pair.image >= images.size() || pair.sampler >= base.samplers.size()) {
+			return false;
 		}
-		auto& usage = sampler_usage[pair.sampler];
-		if (RequiresPointSampler(next.images[pair.image])) {
-			usage.point_only = true;
+		usage[pair.sampler] |= RequiresPointSampler(images[pair.image]) ? 2u : 1u;
+	}
+	for (uint32_t index = 0; index < base.samplers.size(); index++) {
+		if ((usage[index] & 2u) == 0u) {
+			continue;
+		}
+		if ((usage[index] & 1u) == 0u) {
+			plan.point_sampler[index] = index;
 		} else {
-			usage.native = true;
+			if (plan.sampler_count >= ShaderInfo::MaxSamplers) {
+				return false;
+			}
+			plan.point_sampler[index] = plan.sampler_count++;
 		}
 	}
-	std::vector<uint32_t> point_sampler(next.samplers.size(), UINT32_MAX);
-	for (uint32_t i = 0; i < sampler_usage.size(); i++) {
-		if (!sampler_usage[i].point_only) {
+	return true;
+}
+
+ResourcePlan ExtractResourcePlan(const Program& program) {
+	ResourcePlan plan;
+	plan.stage                      = program.stage;
+	plan.shader_hash                = program.shader_hash;
+	plan.user_data_base             = program.user_data_base;
+	plan.user_data_count            = program.user_data_count;
+	plan.info                       = program.info;
+	plan.memory_info                = program.memory_info;
+	plan.srt_plan_complete          = program.srt_plan_complete;
+	plan.resource_tracking_complete = program.resource_tracking_complete;
+
+	std::unordered_map<const Inst*, Inst*> cloned;
+	std::function<Value(Value)>            Clone = [&](Value value) -> Value {
+		value              = value.Resolve();
+		const auto* source = value.TryInstruction();
+		if (source == nullptr) {
+			return value;
+		}
+		if (source->GetOpcode() == ValueOpcode::Phi) {
+			const auto invariant = ResolveInvariantPhi(program, value);
+			if (!invariant.IsEmpty() && invariant != value) {
+				return Clone(invariant);
+			}
+		}
+		if (const auto found = cloned.find(source); found != cloned.end()) {
+			return Value(found->second);
+		}
+		auto& target =
+		    plan.value_storage.emplace_back(source->GetOpcode(), source->Flags<uint64_t>());
+		cloned.emplace(source, &target);
+		if (source->GetOpcode() == ValueOpcode::Phi) {
+			for (size_t index = 0; index < source->NumArgs(); index++) {
+				target.AddPhiOperand(nullptr, Clone(source->Arg(index)));
+			}
+		} else {
+			for (size_t index = 0; index < source->NumArgs(); index++) {
+				target.SetArg(index, Clone(source->Arg(index)));
+			}
+		}
+		return Value(&target);
+	};
+
+	plan.descriptor_sources.reserve(program.descriptor_sources.size());
+	for (const auto& source: program.descriptor_sources) {
+		auto& target          = plan.descriptor_sources.emplace_back();
+		target.dword_count    = source.dword_count;
+		target.indirect_image = source.indirect_image;
+		for (uint32_t dword = 0; dword < source.dword_count; dword++) {
+			target.dwords[dword] = Clone(source.dwords[dword]);
+		}
+	}
+	plan.srt_reads.reserve(program.srt_reads.size());
+	for (const auto& read: program.srt_reads) {
+		plan.srt_reads.push_back({Clone(read.value), read.flat_offset});
+	}
+	plan.materialization_sources.reserve(plan.info.buffers.size() + plan.info.images.size() +
+	                                     plan.info.samplers.size());
+	for (const auto& buffer: plan.info.buffers) {
+		plan.materialization_sources.push_back(buffer.source);
+	}
+	for (const auto& image: plan.info.images) {
+		const auto* source = Source(plan, image.source);
+		if (source != nullptr && source->indirect_image.has_value()) {
+			plan.requires_specialization_memory = true;
+		} else {
+			plan.materialization_sources.push_back(image.source);
+		}
+	}
+	for (const auto& sampler: plan.info.samplers) {
+		plan.materialization_sources.push_back(sampler.source);
+	}
+	plan.clean_flat_slots.resize(plan.srt_reads.size());
+	for (const auto& image: plan.info.images) {
+		const auto* source = Source(plan, image.source);
+		if (source == nullptr || !source->indirect_image.has_value()) {
 			continue;
 		}
-		if (!sampler_usage[i].native) {
-			next.samplers[i].force_point_filtering = true;
-			point_sampler[i]                       = i;
+		MarkCleanFlatSlots(plan, Source(plan, source->indirect_image->material_source),
+		                   plan.clean_flat_slots);
+		MarkCleanFlatSlots(plan, Source(plan, source->indirect_image->heap_source),
+		                   plan.clean_flat_slots);
+	}
+	return plan;
+}
+
+bool MaterializeResources(const ResourcePlan& program, const SrtRuntime& runtime,
+                          ResourceSnapshot& snapshot, ResourceSpecialization& specialization) {
+	MaterializedSnapshot materialized;
+	if (!MaterializeSnapshot(program, runtime, materialized)) {
+		return false;
+	}
+	return BuildResourceSpecialization(program, std::move(materialized), snapshot, specialization);
+}
+
+void ApplyResourceSpecialization(Program& program, const ResourceSpecialization& specialization) {
+	EXIT_IF(!program.resource_tracking_complete || program.shader_info_complete ||
+	        program.binding_layout_complete);
+	EXIT_IF(program.info.buffers.size() != specialization.buffers.size() ||
+	        program.info.images.size() > specialization.images.size());
+
+	auto buffers = program.info.buffers;
+	for (size_t index = 0; index < buffers.size(); index++) {
+		buffers[index].packed_stride      = specialization.buffers[index].packed_stride;
+		buffers[index].descriptor_format  = specialization.buffers[index].descriptor_format;
+		buffers[index].descriptor_swizzle = specialization.buffers[index].descriptor_swizzle;
+	}
+	auto images = program.info.images;
+	images.reserve(specialization.images.size());
+	for (uint32_t index = 0; index < specialization.images.size(); index++) {
+		const auto& source = specialization.images[index];
+		if (index >= images.size()) {
+			EXIT_IF(source.indirect_root >= program.info.images.size());
+			images.push_back(program.info.images[source.indirect_root]);
+		}
+		auto& image                      = images[index];
+		image.numeric_class              = source.numeric_class;
+		image.dimension                  = source.dimension;
+		image.mip_count                  = source.mip_count;
+		image.conversion_format          = source.conversion_format;
+		image.shader_swizzle             = source.shader_swizzle;
+		image.indirect_root              = source.indirect_root;
+		image.indirect_mapping_offset    = source.indirect_mapping_offset;
+		image.indirect_search_iterations = source.indirect_search_iterations;
+		image.cube                       = source.cube;
+		image.indirect_resources.clear();
+	}
+	for (uint32_t index = 0; index < images.size(); index++) {
+		const auto root = images[index].indirect_root;
+		if (root != ImageResource::NoIndirectImage) {
+			EXIT_IF(root >= images.size());
+			images[root].indirect_resources.push_back(index);
+		}
+	}
+
+	SamplerPlan sampler_plan;
+	EXIT_IF(!BuildSamplerPlan(program.info, images, sampler_plan));
+	auto samplers      = program.info.samplers;
+	auto sampled_pairs = program.info.sampled_pairs;
+	samplers.reserve(sampler_plan.sampler_count);
+	for (uint32_t index = 0; index < program.info.samplers.size(); index++) {
+		const auto target = sampler_plan.point_sampler[index];
+		if (target == UINT32_MAX) {
 			continue;
 		}
-		if (next.samplers.size() >= ShaderInfo::MaxSamplers) {
-			return SpecializationFail(
-			    "point-filter sampler variants exceed the dense sampler resource limit");
-		}
-		point_sampler[i]              = static_cast<uint32_t>(next.samplers.size());
-		auto sampler                  = next.samplers[i];
-		sampler.force_point_filtering = true;
-		next.samplers.push_back(sampler);
-		next_snapshot.samplers.push_back(next_snapshot.samplers[i]);
-	}
-	for (auto& pair: next.sampled_pairs) {
-		if (RequiresPointSampler(next.images[pair.image])) {
-			pair.sampler = point_sampler[pair.sampler];
+		if (target == index) {
+			samplers[index].force_point_filtering = true;
+		} else {
+			EXIT_IF(target != samplers.size());
+			auto sampler                  = samplers[index];
+			sampler.force_point_filtering = true;
+			samplers.push_back(std::move(sampler));
 		}
 	}
+	for (auto& pair: sampled_pairs) {
+		if (RequiresPointSampler(images[pair.image])) {
+			EXIT_IF(sampler_plan.point_sampler[pair.sampler] == UINT32_MAX);
+			pair.sampler = sampler_plan.point_sampler[pair.sampler];
+		}
+		samplers[pair.sampler].depth_compare |= images[pair.image].depth_compare;
+	}
+
+	auto memory_info = program.memory_info;
 	for (const auto* block: program.blocks) {
 		for (const auto& inst: *block) {
 			const auto image_opcode = ImageOpcodeInfoOf(inst.GetOpcode());
@@ -778,31 +773,24 @@ void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 				continue;
 			}
 			const auto index = inst.Flags<MemoryFlags>().index;
-			if (index >= memory_info.size()) {
-				return SpecializationFail(
-				    fmt::format("typed image instruction has invalid memory metadata {}", index));
-			}
+			EXIT_IF(index >= memory_info.size());
 			auto& memory = memory_info[index];
-			if (memory.resource >= next.images.size()) {
-				return SpecializationFail(fmt::format(
-				    "typed image instruction has invalid resource {}", memory.resource));
-			}
-			const auto& image = next.images[memory.resource];
+			EXIT_IF(memory.resource >= images.size());
+			const auto& image = images[memory.resource];
 			if (image_opcode.needs_sampler && RequiresPointSampler(image) &&
-			    memory.sampler < point_sampler.size()) {
-				memory.sampler = point_sampler[memory.sampler];
-			}
-			if (image.indirect_root == memory.resource &&
-			    inst.GetOpcode() != ValueOpcode::ImageSampleRaw) {
-				return SpecializationFail(
-				    fmt::format("indirect image table at pc 0x{:08x} is used by unsupported {}",
-				                inst.Flags<MemoryFlags>().pc, ValueOpcodeName(inst.GetOpcode())));
+			    memory.sampler < program.info.samplers.size()) {
+				EXIT_IF(sampler_plan.point_sampler[memory.sampler] == UINT32_MAX);
+				memory.sampler = sampler_plan.point_sampler[memory.sampler];
 			}
+			EXIT_IF(image.indirect_root == memory.resource &&
+			        inst.GetOpcode() != ValueOpcode::ImageSampleRaw);
 		}
 	}
-	program.info        = std::move(next);
-	program.memory_info = std::move(memory_info);
-	snapshot            = std::move(next_snapshot);
+	program.info.buffers       = std::move(buffers);
+	program.info.images        = std::move(images);
+	program.info.samplers      = std::move(samplers);
+	program.info.sampled_pairs = std::move(sampled_pairs);
+	program.memory_info        = std::move(memory_info);
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR

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

@@ -464,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));

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

@@ -26,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);
 }
@@ -51,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;
@@ -134,7 +134,7 @@ bool IsRuntimeUniformOp(ValueOpcode op) {
 
 class RuntimeValidator {
 public:
-	explicit RuntimeValidator(const Program& program, Value active_mask = {})
+	explicit RuntimeValidator(const ResourcePlan& program, Value active_mask = {})
 	    : m_program(program), m_active_mask(active_mask.Resolve()) {}
 
 	bool Run(Value value) { return Validate(value); }
@@ -262,7 +262,7 @@ private:
 		return finish(true);
 	}
 
-	const Program&                  m_program;
+	const ResourcePlan&             m_program;
 	Value                           m_active_mask;
 	std::unordered_set<const Inst*> m_visiting;
 };
@@ -415,7 +415,7 @@ private:
 
 class Evaluator {
 public:
-	Evaluator(const Program& program, const SrtRuntime& runtime,
+	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),
@@ -435,9 +435,7 @@ private:
 		return std::bit_cast<float>(static_cast<uint32_t>(bits));
 	}
 
-	static uint64_t Float32Bits(float value) {
-		return std::bit_cast<uint32_t>(value);
-	}
+	static uint64_t Float32Bits(float value) { return std::bit_cast<uint32_t>(value); }
 
 	bool EvaluateWide(Value value, uint64_t& result) {
 		value = value.Resolve();
@@ -456,6 +454,11 @@ 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);
@@ -915,24 +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) {
@@ -948,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;
 		}
@@ -985,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);
 }
 
@@ -998,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