shader: remove recompiler error-string propagation

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

@@ -1,7 +1,6 @@
+#include "common/assert.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 
-#include "graphics/shader/shader.h"
-
 #include <fmt/format.h>
 #include <map>
 #include <new>
@@ -11,10 +10,13 @@
 
 namespace Libs::Graphics::ShaderRecompiler::IR {
 
-using ShaderError::Fail;
-
 namespace {
 
+[[noreturn]] void Fail(std::string_view message) {
+	EXIT("shader IR validation failed: %s", std::string(message).c_str());
+	std::abort();
+}
+
 bool IsRegisterStatePseudo(ValueOpcode opcode) {
 	switch (opcode) {
 		case ValueOpcode::GetThreadBitScalarRegister:
@@ -153,10 +155,10 @@ Value ResolveInvariantPhi(const Program& program, Value value) {
 	return invariant;
 }
 
-bool ValidateProgram(const Program& program, bool require_ssa, std::string* error) {
+void ValidateProgram(const Program& program, bool require_ssa) {
 	if (program.blocks.size() != program.block_info.size() ||
 	    program.blocks.size() != program.block_storage.size()) {
-		return Fail(error, "value IR block storage is inconsistent");
+		return Fail("value IR block storage is inconsistent");
 	}
 	std::unordered_set<const Block*>           blocks;
 	std::unordered_map<const Block*, size_t>   block_indices;
@@ -166,26 +168,26 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 		const auto* block = program.blocks[block_index];
 		if (block == nullptr || program.block_storage[block_index] == nullptr ||
 		    block != program.block_storage[block_index].get()) {
-			return Fail(error, "value IR block pointer is inconsistent");
+			return Fail("value IR block pointer is inconsistent");
 		}
 		if (!blocks.insert(block).second) {
-			return Fail(error, "value IR block pointer is duplicated");
+			return Fail("value IR block pointer is duplicated");
 		}
 		block_indices.emplace(block, block_index);
 		if (program.block_info[block_index].id == UINT32_MAX) {
-			return Fail(error, "value IR block uses the reserved exit id");
+			return Fail("value IR block uses the reserved exit id");
 		}
 		if (!blocks_by_id.emplace(program.block_info[block_index].id, block).second) {
-			return Fail(error, "value IR block id is duplicated");
+			return Fail("value IR block id is duplicated");
 		}
 		for (const auto& inst: *block) {
 			if (!instructions.insert(&inst).second) {
-				return Fail(error, "value IR instruction is duplicated");
+				return Fail("value IR instruction is duplicated");
 			}
 		}
 	}
 	if (!program.blocks.empty() && !program.blocks.front()->ImmPredecessors().empty()) {
-		return Fail(error, "value IR entry block has a predecessor");
+		return Fail("value IR entry block has a predecessor");
 	}
 
 	for (size_t block_index = 0; block_index < program.blocks.size(); block_index++) {
@@ -193,28 +195,28 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 		std::unordered_set<const Block*> predecessors;
 		for (const auto* predecessor: block->ImmPredecessors()) {
 			if (predecessor == nullptr || !blocks.contains(predecessor)) {
-				return Fail(error, "value IR block has a foreign predecessor");
+				return Fail("value IR block has a foreign predecessor");
 			}
 			if (!predecessors.insert(predecessor).second) {
-				return Fail(error, "value IR block predecessor is duplicated");
+				return Fail("value IR block predecessor is duplicated");
 			}
 			if (std::ranges::find(predecessor->ImmSuccessors(), block) ==
 			    predecessor->ImmSuccessors().end()) {
-				return Fail(error, "value IR predecessor edge is not reciprocal");
+				return Fail("value IR predecessor edge is not reciprocal");
 			}
 		}
 
 		std::unordered_set<const Block*> successors;
 		for (const auto* successor: block->ImmSuccessors()) {
 			if (successor == nullptr || !blocks.contains(successor)) {
-				return Fail(error, "value IR block has a foreign successor");
+				return Fail("value IR block has a foreign successor");
 			}
 			if (!successors.insert(successor).second) {
-				return Fail(error, "value IR block successor is duplicated");
+				return Fail("value IR block successor is duplicated");
 			}
 			if (std::ranges::find(successor->ImmPredecessors(), block) ==
 			    successor->ImmPredecessors().end()) {
-				return Fail(error, "value IR successor edge is not reciprocal");
+				return Fail("value IR successor edge is not reciprocal");
 			}
 		}
 
@@ -238,41 +240,40 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 		switch (terminator.kind) {
 			case CFG::TerminatorKind::Branch:
 				if (!add_target(terminator.true_block)) {
-					return Fail(error, "value IR branch target is missing");
+					return Fail("value IR branch target is missing");
 				}
 				break;
 			case CFG::TerminatorKind::ConditionalBranch:
 				if (!add_target(terminator.true_block) || !add_target(terminator.false_block)) {
-					return Fail(error, "value IR conditional branch target is missing");
+					return Fail("value IR conditional branch target is missing");
 				}
 				if (!validate_control_value(program.block_info[block_index].condition, Type::U1)) {
-					return Fail(error, "value IR conditional branch condition is invalid");
+					return Fail("value IR conditional branch condition is invalid");
 				}
 				break;
 			case CFG::TerminatorKind::IndirectBranch: {
 				if (!validate_control_value(program.block_info[block_index].indirect_target,
 				                            Type::U32)) {
-					return Fail(error, "value IR indirect branch selector is invalid");
+					return Fail("value IR indirect branch selector is invalid");
 				}
 				std::unordered_set<uint32_t> indirect_targets;
 				for (const auto target: terminator.indirect_targets) {
 					if (!indirect_targets.insert(target).second) {
-						return Fail(error, "value IR indirect branch target is duplicated");
+						return Fail("value IR indirect branch target is duplicated");
 					}
 					if (!add_target(target)) {
-						return Fail(error, "value IR indirect branch target is missing");
+						return Fail("value IR indirect branch target is missing");
 					}
 				}
 				if (terminator.indirect_selector_values.size() !=
 				    terminator.indirect_selector_targets.size()) {
-					return Fail(error, "value IR indirect selector table is inconsistent");
+					return Fail("value IR indirect selector table is inconsistent");
 				}
 				for (const auto target: terminator.indirect_selector_targets) {
 					const auto found = blocks_by_id.find(target);
 					if (found == blocks_by_id.end() ||
 					    !expected_successors.contains(found->second)) {
-						return Fail(error,
-						            "value IR indirect selector target is not a CFG successor");
+						return Fail("value IR indirect selector target is not a CFG successor");
 					}
 				}
 				break;
@@ -284,73 +285,73 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 		     !blocks_by_id.contains(terminator.merge_block)) ||
 		    (terminator.continue_block != UINT32_MAX &&
 		     !blocks_by_id.contains(terminator.continue_block))) {
-			return Fail(error, "value IR structured control target is missing");
+			return Fail("value IR structured control target is missing");
 		}
 		if (successors != expected_successors) {
-			return Fail(error, "value IR terminator and successor graph disagree");
+			return Fail("value IR terminator and successor graph disagree");
 		}
 
 		bool saw_non_phi = false;
 		for (const auto& inst: *block) {
 			if (inst.Parent() != block) {
-				return Fail(error, "value IR instruction has the wrong parent block");
+				return Fail("value IR instruction has the wrong parent block");
 			}
 			if (inst.GetOpcode() == ValueOpcode::Phi) {
 				if (saw_non_phi) {
-					return Fail(error, "value IR Phi appears after a non-Phi instruction");
+					return Fail("value IR Phi appears after a non-Phi instruction");
 				}
 				if (inst.NumPhiBlocks() != inst.NumArgs()) {
-					return Fail(error, "value IR Phi parent table is inconsistent");
+					return Fail("value IR Phi parent table is inconsistent");
 				}
 				if (inst.NumArgs() == 0) {
-					return Fail(error, "value IR Phi has no incoming values");
+					return Fail("value IR Phi has no incoming values");
 				}
 				std::unordered_set<const Block*> incoming_blocks;
 				for (size_t arg_index = 0; arg_index < inst.NumArgs(); arg_index++) {
 					const auto* predecessor = inst.PhiBlock(arg_index);
 					if (predecessor == nullptr || !blocks.contains(predecessor) ||
 					    !predecessors.contains(predecessor)) {
-						return Fail(error, "value IR Phi has a foreign or non-predecessor parent");
+						return Fail("value IR Phi has a foreign or non-predecessor parent");
 					}
 					if (!incoming_blocks.insert(predecessor).second) {
-						return Fail(error, "value IR Phi parent is duplicated");
+						return Fail("value IR Phi parent is duplicated");
 					}
 					if (inst.Arg(arg_index).GetType() != inst.GetType()) {
-						return Fail(error, "value IR Phi incoming type does not match its result");
+						return Fail("value IR Phi incoming type does not match its result");
 					}
 				}
 				if (incoming_blocks != predecessors) {
-					return Fail(error, "value IR Phi does not cover every predecessor");
+					return Fail("value IR Phi does not cover every predecessor");
 				}
 			} else {
 				saw_non_phi = true;
 			}
 			if (require_ssa && IsRegisterStatePseudo(inst.GetOpcode())) {
-				return Fail(error, fmt::format("register-state pseudo {} survived SSA rewrite",
-				                               ValueOpcodeName(inst.GetOpcode())));
+				return Fail(fmt::format("register-state pseudo {} survived SSA rewrite",
+				                        ValueOpcodeName(inst.GetOpcode())));
 			}
 			if (inst.GetOpcode() != ValueOpcode::Phi && inst.GetOpcode() != ValueOpcode::Identity &&
 			    inst.GetType() == Type::Opaque) {
-				return Fail(error, fmt::format("untyped opcode {} survived translation",
-				                               ValueOpcodeName(inst.GetOpcode())));
+				return Fail(fmt::format("untyped opcode {} survived translation",
+				                        ValueOpcodeName(inst.GetOpcode())));
 			}
 			const bool fixed_signature =
 			    inst.GetOpcode() != ValueOpcode::Phi && inst.GetOpcode() != ValueOpcode::Identity;
 			if (fixed_signature && inst.NumArgs() != NumArgsOf(inst.GetOpcode())) {
-				return Fail(error, fmt::format("{} has {} arguments, expected {}",
-				                               ValueOpcodeName(inst.GetOpcode()), inst.NumArgs(),
-				                               NumArgsOf(inst.GetOpcode())));
+				return Fail(fmt::format("{} has {} arguments, expected {}",
+				                        ValueOpcodeName(inst.GetOpcode()), inst.NumArgs(),
+				                        NumArgsOf(inst.GetOpcode())));
 			}
 			if (inst.GetOpcode() == ValueOpcode::ReadConstBuffer) {
 				const auto memory_index = inst.Flags<MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, fmt::format("{} has an invalid memory-info index",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid memory-info index",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if (memory.kind != ResourceKind::ScalarBuffer) {
-					return Fail(error, fmt::format("{} has an invalid scalar-memory resource kind",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid scalar-memory resource kind",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const bool valid_group_width =
 				    memory.component_count == 1u || memory.component_count == 2u ||
@@ -358,23 +359,23 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 				    memory.component_count == 16u;
 				if (memory.data_bits != 32u || memory.data_dwords != 1u || !valid_group_width ||
 				    memory.component_index >= memory.component_count) {
-					return Fail(error, fmt::format("{} has inconsistent scalar-memory metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has inconsistent scalar-memory metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 			}
 			const auto address_info = AddressOpcodeInfoOf(inst.GetOpcode());
 			if (address_info.access != AddressAccess::None) {
 				const auto memory_index = inst.Flags<MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, fmt::format("{} has an invalid memory-info index",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid memory-info index",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if (!IsAddressResourceKind(memory.kind) ||
 				    (memory.kind == ResourceKind::ScalarAddress &&
 				     inst.GetOpcode() != ValueOpcode::LoadAddressU32)) {
-					return Fail(error, fmt::format("{} has an invalid address resource kind",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid address resource kind",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const bool scalar_address = memory.kind == ResourceKind::ScalarAddress;
 				const bool valid_group_width =
@@ -386,50 +387,50 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 				if (memory.data_bits != address_info.data_bits || memory.data_dwords != 1u ||
 				    !valid_group_width || memory.component_index >= memory.component_count ||
 				    memory.sampler != 0u) {
-					return Fail(error, fmt::format("{} has inconsistent address-memory metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has inconsistent address-memory metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 			}
 			const auto buffer_components = BufferComponentCount(inst.GetOpcode());
 			if (buffer_components != 0u) {
 				const auto memory_index = inst.Flags<MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, fmt::format("{} has an invalid memory-info index",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid memory-info index",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if (memory.kind != ResourceKind::Buffer &&
 				    memory.kind != ResourceKind::ScalarBuffer) {
-					return Fail(error, fmt::format("{} has a non-buffer resource kind",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has a non-buffer resource kind",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				if (buffer_components > 1u &&
 				    (memory.kind != ResourceKind::Buffer || memory.data_bits != 32u ||
 				     memory.data_dwords != buffer_components || memory.component_index != 0u)) {
-					return Fail(error, fmt::format("{} has inconsistent native-wide metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has inconsistent native-wide metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				if (buffer_components == 1u &&
 				    (inst.GetOpcode() == ValueOpcode::LoadBufferU32 ||
 				     inst.GetOpcode() == ValueOpcode::StoreBufferU32) &&
 				    memory.data_dwords != 1u) {
-					return Fail(error, fmt::format("{} retains scalar-sibling width metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} retains scalar-sibling width metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 			}
 			const auto shared_components = SharedComponentCount(inst.GetOpcode());
 			if (shared_components != 0u) {
 				const auto memory_index = inst.Flags<MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, fmt::format("{} has an invalid memory-info index",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid memory-info index",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if ((memory.kind != ResourceKind::Lds && memory.kind != ResourceKind::Gds) ||
 				    memory.resource != 0u || memory.sampler != 0u || memory.component_count == 0u ||
 				    memory.component_index >= memory.component_count) {
-					return Fail(error, fmt::format("{} has invalid shared-memory metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has invalid shared-memory metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				uint32_t expected_bits = 32u;
 				if (inst.GetOpcode() == ValueOpcode::LoadSharedU8 ||
@@ -441,26 +442,26 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 				}
 				if (memory.data_bits != expected_bits || memory.data_dwords != shared_components ||
 				    (shared_components > 1u && memory.component_index != 0u)) {
-					return Fail(error, fmt::format("{} has inconsistent shared-memory width",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has inconsistent shared-memory width",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 			}
 			const auto image_info = ImageOpcodeInfoOf(inst.GetOpcode());
 			if (image_info.access != ImageAccess::None) {
 				const auto memory_index = inst.Flags<MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, fmt::format("{} has an invalid memory-info index",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has an invalid memory-info index",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if (!ImageResourceKindMatches(memory.kind, image_info.resource_class)) {
-					return Fail(error, fmt::format("{} has invalid image-memory metadata",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(fmt::format("{} has invalid image-memory metadata",
+					                        ValueOpcodeName(inst.GetOpcode())));
 				}
 			}
 			if (inst.GetOpcode() == ValueOpcode::SetAttribute &&
 			    inst.Flags<ExportFlags>().index >= program.export_info.size()) {
-				return Fail(error, "SetAttribute has an invalid export-info index");
+				return Fail("SetAttribute has an invalid export-info index");
 			}
 			uint32_t composite_components = 0u;
 			switch (inst.GetOpcode()) {
@@ -473,25 +474,24 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 			if (composite_components != 0u &&
 			    (!inst.Arg(1).IsImmediate() || inst.Arg(1).GetType() != Type::U32 ||
 			     inst.Arg(1).U32() >= composite_components)) {
-				return Fail(error, fmt::format("{} has an invalid component index",
-				                               ValueOpcodeName(inst.GetOpcode())));
+				return Fail(fmt::format("{} has an invalid component index",
+				                        ValueOpcodeName(inst.GetOpcode())));
 			}
 			for (size_t arg_index = 0; arg_index < inst.NumArgs(); arg_index++) {
 				const auto arg = inst.Arg(arg_index);
 				if (arg.IsEmpty()) {
-					return Fail(error, fmt::format("{} has an empty argument",
-					                               ValueOpcodeName(inst.GetOpcode())));
+					return Fail(
+					    fmt::format("{} has an empty argument", ValueOpcodeName(inst.GetOpcode())));
 				}
 				if (fixed_signature && arg.GetType() != ArgTypeOf(inst.GetOpcode(), arg_index)) {
-					return Fail(error,
-					            fmt::format("{} argument {} has type {}, expected {}",
+					return Fail(fmt::format("{} argument {} has type {}, expected {}",
 					                        ValueOpcodeName(inst.GetOpcode()), arg_index,
 					                        TypeName(arg.GetType()),
 					                        TypeName(ArgTypeOf(inst.GetOpcode(), arg_index))));
 				}
 				if (const auto* definition = arg.TryInstruction();
 				    definition != nullptr && !instructions.contains(definition)) {
-					return Fail(error, "value IR argument has a foreign definition");
+					return Fail("value IR argument has a foreign definition");
 				}
 				if (const auto* definition = arg.TryInstruction(); definition != nullptr) {
 					const auto& uses = definition->Uses();
@@ -499,8 +499,7 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 						return candidate.user == &inst && candidate.operand == arg_index;
 					});
 					if (use == uses.end()) {
-						return Fail(error,
-						            fmt::format("{} argument {} is absent from {} reverse uses",
+						return Fail(fmt::format("{} argument {} is absent from {} reverse uses",
 						                        ValueOpcodeName(inst.GetOpcode()), arg_index,
 						                        ValueOpcodeName(definition->GetOpcode())));
 					}
@@ -510,7 +509,7 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 	}
 
 	if (program.blocks.empty()) {
-		return true;
+		return;
 	}
 
 	std::vector<bool>   reachable(program.blocks.size(), false);
@@ -527,7 +526,7 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 		}
 	}
 	if (!std::ranges::all_of(reachable, [](bool value) { return value; })) {
-		return Fail(error, "value IR contains an unreachable block");
+		return Fail("value IR contains an unreachable block");
 	}
 
 	std::vector<std::vector<bool>> dominators(program.blocks.size(),
@@ -581,28 +580,25 @@ bool ValidateProgram(const Program& program, bool require_ssa, std::string* erro
 					const auto* predecessor = inst.PhiBlock(arg_index);
 					if (definition->Parent() != predecessor &&
 					    !dominates(definition->Parent(), predecessor)) {
-						return Fail(error,
-						            "value IR Phi incoming definition does not dominate its edge");
+						return Fail("value IR Phi incoming definition does not dominate its edge");
 					}
 				} else if (definition->Parent() == block) {
 					if (instruction_positions.at(definition) >= instruction_positions.at(&inst)) {
-						return Fail(error,
-						            "value IR instruction uses a same-block definition before it");
+						return Fail("value IR instruction uses a same-block definition before it");
 					}
 				} else if (!dominates(definition->Parent(), block)) {
-					return Fail(error, "value IR instruction definition does not dominate its use");
+					return Fail("value IR instruction definition does not dominate its use");
 				}
 			}
 		}
 		const auto& info = program.block_info[block_index];
 		if (!info.condition.IsEmpty() && !control_dominates(info.condition, block)) {
-			return Fail(error, "value IR branch condition definition does not dominate its use");
+			return Fail("value IR branch condition definition does not dominate its use");
 		}
 		if (!info.indirect_target.IsEmpty() && !control_dominates(info.indirect_target, block)) {
-			return Fail(error, "value IR indirect selector definition does not dominate its use");
+			return Fail("value IR indirect selector definition does not dominate its use");
 		}
 	}
-	return true;
 }
 
 void ResolveControlFlowIdentities(Program& program) {

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

@@ -477,7 +477,6 @@ struct DescriptorSource {
 struct SrtRead {
 	Value    value;
 	uint32_t flat_offset = 0;
-	uint32_t use_pc      = 0;
 
 	bool operator==(const SrtRead& other) const = default;
 };
@@ -523,7 +522,7 @@ struct Program {
 
 std::string ProgramToString(const Program& program);
 
-bool  ValidateProgram(const Program& program, bool require_ssa, std::string* error);
+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);

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

@@ -1,5 +1,6 @@
 #include "graphics/shader/recompiler/ir/passes/BindingLayout.h"
 
+#include "common/assert.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 
 #include <algorithm>
@@ -9,12 +10,17 @@
 namespace Libs::Graphics::ShaderRecompiler::IR {
 namespace {
 
-constexpr auto     FirstImageBinding     = DescriptorBindingKind::Sampled1D;
+constexpr auto     FirstImageBinding = DescriptorBindingKind::Sampled1D;
 constexpr uint32_t ImageBindingCount =
     static_cast<uint32_t>(DescriptorBindingKind::StorageAtomic3D) -
     static_cast<uint32_t>(FirstImageBinding) + 1u;
 
-bool CollectUserData(const Program& program, std::vector<uint32_t>& result) {
+[[noreturn]] void BindingFail(const char* message) {
+	EXIT("shader binding layout failed: %s", message);
+	std::abort();
+}
+
+std::vector<uint32_t> CollectUserData(const Program& program) {
 	std::array<bool, NumScalarRegs> registers {};
 	for (const auto* block: program.blocks) {
 		for (const auto& inst: *block) {
@@ -22,22 +28,22 @@ bool CollectUserData(const Program& program, std::vector<uint32_t>& result) {
 				continue;
 			}
 			if (inst.Arg(0).GetType() != Type::ScalarReg) {
-				return false;
+				BindingFail("typed shader contains an invalid user-data register");
 			}
 			const auto index = RegIndex(inst.Arg(0).ScalarRegister());
 			if (index >= NumScalarRegs) {
-				return false;
+				BindingFail("typed shader contains an invalid user-data register");
 			}
 			registers[index] = true;
 		}
 	}
-	result.clear();
+	std::vector<uint32_t> result;
 	for (uint32_t index = 0; index < registers.size(); index++) {
 		if (registers[index]) {
 			result.push_back(index);
 		}
 	}
-	return true;
+	return result;
 }
 
 void AddBinding(BindingLayout& layout, DescriptorBindingKind kind,
@@ -45,8 +51,8 @@ void AddBinding(BindingLayout& layout, DescriptorBindingKind kind,
 	layout.descriptors.push_back({kind, std::move(resources)});
 }
 
-bool UsesGds(const Program& program, bool& uses_gds) {
-	uses_gds = false;
+bool UsesGds(const Program& program) {
+	bool uses_gds = false;
 	for (const auto* block: program.blocks) {
 		for (const auto& inst: *block) {
 			if (SharedAccessOf(inst.GetOpcode()) == SharedAccess::None) {
@@ -54,44 +60,36 @@ bool UsesGds(const Program& program, bool& uses_gds) {
 			}
 			const auto index = inst.Flags<MemoryFlags>().index;
 			if (index >= program.memory_info.size()) {
-				return false;
+				BindingFail("typed shader contains invalid shared-memory metadata");
 			}
 			const auto kind = program.memory_info[index].kind;
 			if (kind != ResourceKind::Lds && kind != ResourceKind::Gds) {
-				return false;
+				BindingFail("typed shader contains invalid shared-memory metadata");
 			}
 			uses_gds |= kind == ResourceKind::Gds;
 		}
 	}
-	return true;
+	return uses_gds;
 }
 
 } // namespace
 
-bool AllocateBindings(Program& program, uint32_t push_constant_offset, std::string* error) {
+void AllocateBindings(Program& program, uint32_t push_constant_offset) {
 	if (!program.shader_info_complete || program.binding_layout_complete) {
-		if (error != nullptr) {
-			*error = !program.shader_info_complete ? "shader info is not ready"
-			                                       : "binding layout already allocated";
-		}
-		return false;
+		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) {
-		if (error != nullptr) {
-			*error = "push-constant offset exceeds the Vulkan minimum guarantee or is unaligned";
-		}
-		return false;
+		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;
-	if (!CollectUserData(program, next.user_data_registers)) {
-		if (error != nullptr) {
-			*error = "typed shader contains an invalid user-data register";
-		}
-		return false;
-	}
+	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());
 
@@ -107,26 +105,18 @@ bool AllocateBindings(Program& program, uint32_t push_constant_offset, std::stri
 	for (uint32_t i = 0; i < program.info.images.size(); i++) {
 		const auto kind = DescriptorBindingForImage(program.info.images[i]);
 		if (!kind.has_value()) {
-			if (error != nullptr) {
-				*error = "shader info contains an invalid image binding class";
-			}
-			return false;
+			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);
 		if (group >= image_groups.size()) {
-			if (error != nullptr) {
-				*error = "shader info contains an unmapped image binding class";
-			}
-			return false;
+			EXIT("shader binding layout failed: image %u has an unmapped binding class", i);
 		}
 		auto&      resources = image_groups[group];
 		const auto dynamic   = program.info.images[i].mip_mode == ImageMipMode::DynamicStorage;
 		const auto count     = dynamic ? program.info.images[i].mip_count : 1u;
 		if (count == 0u || (!dynamic && program.info.images[i].mip_count != 1u)) {
-			if (error != nullptr) {
-				*error = "image has an invalid specialized mip descriptor count";
-			}
-			return false;
+			EXIT("shader binding layout failed: image %u has invalid specialized mip count %u", i,
+			     program.info.images[i].mip_count);
 		}
 		resources.insert(resources.end(), count, i);
 	}
@@ -146,14 +136,7 @@ bool AllocateBindings(Program& program, uint32_t push_constant_offset, std::stri
 		}
 		AddBinding(next, DescriptorBindingKind::Samplers, std::move(resources));
 	}
-	bool uses_gds = false;
-	if (!UsesGds(program, uses_gds)) {
-		if (error != nullptr) {
-			*error = "typed shader contains invalid shared-memory metadata";
-		}
-		return false;
-	}
-	if (uses_gds) {
+	if (UsesGds(program)) {
 		AddBinding(next, DescriptorBindingKind::Gds);
 	}
 	if (program.info.uses_dma) {
@@ -178,7 +161,6 @@ bool AllocateBindings(Program& program, uint32_t push_constant_offset, std::stri
 
 	program.bindings                = std::move(next);
 	program.binding_layout_complete = true;
-	return true;
 }
 
 const DescriptorBinding* FindBinding(const BindingLayout& layout, DescriptorBindingKind kind) {

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

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

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

@@ -1,5 +1,6 @@
 #include "graphics/shader/recompiler/ir/passes/ResourceMaterialization.h"
 
+#include "common/assert.h"
 #include "graphics/guest_gpu/gpu_format.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 #include "graphics/shader/shaderBindings.h"
@@ -18,6 +19,11 @@ 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();
+}
+
 Decoder::ImageDimension DescriptorDimension(const DescriptorValue&  descriptor,
                                             Decoder::ImageDimension requested) {
 	const bool is_array = requested == Decoder::ImageDimension::Dim1DArray ||
@@ -79,7 +85,7 @@ uint32_t DescriptorImageSwizzle(const DescriptorValue& descriptor) {
 
 Prospero::BufferFormat ImageConversionFormat(Prospero::BufferFormat format) {
 	return Prospero::RemapTextureFormat(format) != format ? format
-	                                                     : Prospero::BufferFormat::kInvalid;
+	                                                      : Prospero::BufferFormat::kInvalid;
 }
 
 bool DescriptorIsCube(const DescriptorValue& descriptor) {
@@ -153,8 +159,7 @@ bool ReadSpecializationWord(const SrtRuntime& runtime, uint64_t address, uint32_
 }
 
 bool ReadScalarBufferWord(const ShaderBufferResource& descriptor, uint32_t dynamic_offset,
-                          uint32_t immediate_offset, const SrtRuntime& runtime, uint32_t& word,
-                          std::string* error, uint32_t use_pc) {
+                          uint32_t immediate_offset, const SrtRuntime& runtime, uint32_t& word) {
 	const auto byte_offset = static_cast<uint64_t>(dynamic_offset) + immediate_offset;
 	const auto aligned     = byte_offset & ~uint64_t {3};
 	const auto size        = ScalarBufferSize(descriptor);
@@ -164,20 +169,10 @@ bool ReadScalarBufferWord(const ShaderBufferResource& descriptor, uint32_t dynam
 	}
 	const auto base = descriptor.Base48() & ~uint64_t {3};
 	if (aligned > AddressMask - base) {
-		if (error != nullptr) {
-			*error = fmt::format("indirect image scalar read at pc 0x{:08x} exceeds the "
-			                     "48-bit address space",
-			                     use_pc);
-		}
 		return false;
 	}
 	const auto address = base + aligned;
 	if (!ReadSpecializationWord(runtime, address, word)) {
-		if (error != nullptr) {
-			*error = fmt::format("indirect image scalar read at pc 0x{:08x} failed at "
-			                     "0x{:016x}",
-			                     use_pc, address);
-		}
 		return false;
 	}
 	return true;
@@ -186,23 +181,14 @@ 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, std::string* error,
-                              uint32_t use_pc) {
+                              ResourceSnapshot::IndirectImage& result) {
 	ShaderBufferResource material;
 	ShaderBufferResource heap;
 	if (!DecodeBufferDescriptor(material_value, material) ||
 	    !DecodeBufferDescriptor(heap_value, heap)) {
-		if (error != nullptr) {
-			*error = fmt::format("indirect image tables at pc 0x{:08x} have invalid descriptors",
-			                     use_pc);
-		}
 		return false;
 	}
 	if (material.Stride() != indirect.selector_stride) {
-		if (error != nullptr) {
-			*error =
-			    fmt::format("indirect image material table at pc 0x{:08x} changed stride", use_pc);
-		}
 		return false;
 	}
 
@@ -215,11 +201,6 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 	const auto limit       = std::min<uint64_t>(UINT32_MAX, size + 3u);
 	const auto probe_count = residue <= limit ? (limit - residue) / step + 1u : 0u;
 	if (probe_count > MaxIndirectImageProbes) {
-		if (error != nullptr) {
-			*error = fmt::format("indirect image material table at pc 0x{:08x} requires {} "
-			                     "bounded probes",
-			                     use_pc, probe_count);
-		}
 		return false;
 	}
 
@@ -227,8 +208,7 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 	std::unordered_set<uint32_t> seen {0u};
 	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, error,
-		                          use_pc)) {
+		if (!ReadScalarBufferWord(material, static_cast<uint32_t>(offset), 0u, runtime, key)) {
 			return false;
 		}
 		if (seen.insert(key).second) {
@@ -248,7 +228,7 @@ bool MaterializeIndirectImage(const DescriptorSource::IndirectImage& indirect,
 		const auto heap_offset = key << 5u;
 		for (uint32_t dword = 0; dword < candidate.dword_count; dword++) {
 			if (!ReadScalarBufferWord(heap, heap_offset, dword * sizeof(uint32_t), runtime,
-			                          candidate.dwords[dword], error, use_pc)) {
+			                          candidate.dwords[dword])) {
 				return false;
 			}
 		}
@@ -281,35 +261,22 @@ size_t FlattenedRuntimeDwords(const Program& program) {
 
 } // namespace
 
-bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot,
-                              std::string* error) {
+bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot) {
 	if (!program.resource_tracking_complete) {
-		if (error != nullptr) {
-			*error = "shader resources were not tracked";
-		}
 		return false;
 	}
 	if (snapshot.buffers.size() != program.info.buffers.size() ||
 	    snapshot.images.size() != program.info.images.size() ||
 	    snapshot.samplers.size() != program.info.samplers.size()) {
-		if (error != nullptr) {
-			*error = "resource snapshot does not match dense shader topology";
-		}
 		return false;
 	}
 	if (snapshot.flattened_srt.size() != FlattenedRuntimeDwords(program)) {
-		if (error != nullptr) {
-			*error = "flattened SRT snapshot does not match the shader plan";
-		}
 		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()) {
-				if (error != nullptr) {
-					*error = fmt::format("runtime snapshot is missing user SGPR {}", reg);
-				}
 				return false;
 			}
 		}
@@ -317,19 +284,12 @@ bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& sn
 	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()) {
-			if (error != nullptr) {
-				*error = fmt::format("buffer resource {} has invalid image alias {}", i, alias);
-			}
 			return false;
 		}
 	}
-	const auto CheckWidth = [&](const auto& values, uint32_t width, const char* kind) {
+	const auto CheckWidth = [&](const auto& values, uint32_t width) {
 		for (uint32_t i = 0; i < values.size(); i++) {
 			if (values[i].dword_count != width) {
-				if (error != nullptr) {
-					*error = fmt::format("{} descriptor {} has {} dwords", kind, i,
-					                     values[i].dword_count);
-				}
 				return false;
 			}
 		}
@@ -345,56 +305,37 @@ bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& sn
 		    table.keys.empty() || table.keys.size() != table.candidates.size() ||
 		    table.capacity < table.keys.size() || table.descriptors.empty() ||
 		    !indirect_resources.insert(table.resource).second) {
-			if (error != nullptr) {
-				*error = "indirect image snapshot does not match the shader plan";
-			}
 			return false;
 		}
 		for (const auto candidate: table.candidates) {
 			if (candidate >= table.descriptors.size()) {
-				if (error != nullptr) {
-					*error = "indirect image snapshot has an invalid candidate";
-				}
 				return false;
 			}
 		}
 		if (snapshot.images[table.resource] != table.descriptors[table.candidates[0]]) {
-			if (error != nullptr) {
-				*error = "indirect image snapshot has an inconsistent root descriptor";
-			}
 			return false;
 		}
 	}
-	return CheckWidth(snapshot.buffers, 4, "buffer") && CheckWidth(snapshot.images, 8, "image") &&
-	       CheckWidth(snapshot.samplers, 4, "sampler");
+	return CheckWidth(snapshot.buffers, 4) && CheckWidth(snapshot.images, 8) &&
+	       CheckWidth(snapshot.samplers, 4);
 }
 
-bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot,
-                                    std::string* error) {
-	if (!ValidateResourceSnapshot(program, snapshot, error)) {
+bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot) {
+	if (!ValidateResourceSnapshot(program, snapshot)) {
 		return false;
 	}
 	if (!snapshot.indirect_images.empty()) {
-		if (error != nullptr) {
-			*error = "indirect image snapshot was not specialized";
-		}
 		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)) {
-			if (error != nullptr) {
-				*error = fmt::format("buffer descriptor {} has invalid width", i);
-			}
 			return false;
 		}
 		if (buffer.packed_stride != descriptor.PackedStride() ||
 		    buffer.descriptor_format != descriptor.Format() ||
 		    buffer.descriptor_swizzle != descriptor.DstSelXYZW()) {
-			if (error != nullptr) {
-				*error = fmt::format("buffer descriptor {} no longer matches specialization", i);
-			}
 			return false;
 		}
 	}
@@ -403,9 +344,6 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 		const auto& descriptor = snapshot.images[i];
 		const auto  mip_count  = StorageMipCount(image, descriptor);
 		if (mip_count == 0u || mip_count != image.mip_count) {
-			if (error != nullptr) {
-				*error = fmt::format("storage image descriptor {} changed mip range", i);
-			}
 			return false;
 		}
 		if (NullImageDescriptor(descriptor)) {
@@ -419,10 +357,6 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 				    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) {
-					if (error != nullptr) {
-						*error = fmt::format(
-						    "null indirect image descriptor {} changed binding class", i);
-					}
 					return false;
 				}
 				continue;
@@ -434,10 +368,6 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			}
 			if (image.dimension != Decoder::ImageDimension::Dim2D || image.cube ||
 			    !canonical_kind) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "image descriptor {} no longer matches canonical null specialization", i);
-				}
 				return false;
 			}
 			continue;
@@ -445,14 +375,6 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 		const auto dimension = DescriptorDimension(descriptor, image.dimension);
 		if (dimension == Decoder::ImageDimension::Unknown || dimension != image.dimension ||
 		    DescriptorIsCube(descriptor) != image.cube) {
-			if (error != nullptr) {
-				*error =
-				    fmt::format("image descriptor {} no longer matches specialized dimension: "
-				                "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-				                i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-				                descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-				                descriptor.dwords[6], descriptor.dwords[7]);
-			}
 			return false;
 		}
 		if (image.kind == ResourceKind::Image || image.kind == ResourceKind::ImageUint ||
@@ -463,49 +385,25 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			const auto format =
 			    static_cast<Prospero::BufferFormat>((descriptor.dwords[1] >> 20u) & 0x1ffu);
 			if (image.atomic && format != Prospero::BufferFormat::k32UInt) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "atomic image descriptor {} changed to unsupported format {}", i,
-					    static_cast<uint32_t>(format));
-				}
 				return false;
 			}
 			const auto conversion_format = ImageConversionFormat(format);
 			if (image.conversion_format != conversion_format) {
-				if (error != nullptr) {
-					*error = fmt::format("image descriptor {} changed format conversion", i);
-				}
 				return false;
 			}
 			if ((storage || conversion_format != Prospero::BufferFormat::kInvalid) &&
 			    image.shader_swizzle != DescriptorImageSwizzle(descriptor)) {
-				if (error != nullptr) {
-					*error = fmt::format("image descriptor {} changed swizzle", i);
-				}
 				return false;
 			}
-			const bool raw_sint_storage =
-			    storage && format == Prospero::BufferFormat::k32SInt && image.written &&
-			    !image.read && !image.atomic;
-			const bool uint_descriptor =
-			    Prospero::IsUintTextureFormat(format) || raw_sint_storage;
-			const auto uint_program = image.kind == ResourceKind::ImageUint ||
-			                          image.kind == ResourceKind::StorageImageUint;
+			const bool raw_sint_storage = storage && format == Prospero::BufferFormat::k32SInt &&
+			                              image.written && !image.read && !image.atomic;
+			const bool uint_descriptor  = Prospero::IsUintTextureFormat(format) || raw_sint_storage;
+			const auto uint_program     = image.kind == ResourceKind::ImageUint ||
+			                              image.kind == ResourceKind::StorageImageUint;
 			if (uint_descriptor != uint_program && !(image.atomic && uint_program)) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "image descriptor {} no longer matches specialized format: "
-					    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-					    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-					    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-					    descriptor.dwords[6], descriptor.dwords[7]);
-				}
 				return false;
 			}
 			if (image.depth_compare && uint_program) {
-				if (error != nullptr) {
-					*error = fmt::format("integer image descriptor {} uses depth comparison", i);
-				}
 				return false;
 			}
 		}
@@ -514,11 +412,8 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 }
 
 bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
-                          ResourceSnapshot& snapshot, std::string* error) {
+                          ResourceSnapshot& snapshot) {
 	if (!program.resource_tracking_complete) {
-		if (error != nullptr) {
-			*error = "shader resources were not tracked";
-		}
 		return false;
 	}
 
@@ -527,17 +422,12 @@ bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
 	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, buffer.first_use_pc});
+		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) {
-				if (error != nullptr) {
-					*error = fmt::format("indirect image table at pc 0x{:08x} has no clean "
-					                     "memory reader",
-					                     image.first_use_pc);
-				}
 				return false;
 			}
 			MarkCleanFlatSlots(program, Source(program, source->indirect_image->material_source),
@@ -545,16 +435,16 @@ bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
 			MarkCleanFlatSlots(program, Source(program, source->indirect_image->heap_source),
 			                   clean_flat_slots);
 		} else {
-			requests.push_back({image.source, image.first_use_pc});
+			requests.push_back({image.source});
 		}
 	}
 	for (const auto& sampler: program.info.samplers) {
-		requests.push_back({sampler.source, sampler.first_use_pc});
+		requests.push_back({sampler.source});
 	}
 	std::vector<DescriptorValue> values;
 	std::vector<uint32_t>        flattened_srt;
-	if (!EvaluateRuntimeSources(program, requests, runtime, values, flattened_srt, clean_flat_slots,
-	                            error)) {
+	if (!EvaluateRuntimeSources(program, requests, runtime, values, flattened_srt,
+	                            clean_flat_slots)) {
 		return false;
 	}
 
@@ -581,20 +471,19 @@ bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
 				continue;
 			}
 			const std::array requests {
-			    DescriptorSourceRequest {source->indirect_image->material_source,
-			                             image.first_use_pc},
-			    DescriptorSourceRequest {source->indirect_image->heap_source, image.first_use_pc}};
+			    DescriptorSourceRequest {source->indirect_image->material_source},
+			    DescriptorSourceRequest {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, error)) {
+			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,
-			                              error, image.first_use_pc)) {
+			if (!MaterializeIndirectImage(*source->indirect_image, material, heap, runtime,
+			                              table)) {
 				return false;
 			}
 			if (image.indirect_root == ImageResource::NoIndirectImage) {
@@ -608,20 +497,12 @@ bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
 			}
 			if (table.keys.size() > image.indirect_mapping_capacity ||
 			    table.descriptors.size() > image.indirect_resources.size()) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "indirect image table at pc 0x{:08x} changed candidate topology",
-					    image.first_use_pc);
-				}
 				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) {
-					if (error != nullptr) {
-						*error = "indirect image specialization has an invalid candidate resource";
-					}
 					return false;
 				}
 				next.images[resource] =
@@ -649,31 +530,26 @@ bool MaterializeResources(const Program& program, const SrtRuntime& runtime,
 		}
 	}
 	if (std::ranges::find(image_written, uint8_t {0}) != image_written.end()) {
-		if (error != nullptr) {
-			*error = "indirect image specialization left an unmaterialized candidate";
-		}
 		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, error)) {
+	if (!ValidateResourceSnapshot(program, next)) {
 		return false;
 	}
 	snapshot = std::move(next);
 	return true;
 }
 
-bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::string* error) {
+void SpecializeResources(Program& program, ResourceSnapshot& snapshot) {
 	if (!program.resource_tracking_complete || program.shader_info_complete ||
 	    program.binding_layout_complete) {
-		if (error != nullptr) {
-			*error = !program.resource_tracking_complete ? "shader resources were not tracked"
-			                                             : "resource specialization is too late";
-		}
-		return false;
+		return SpecializationFail(!program.resource_tracking_complete
+		                              ? "shader resources were not tracked"
+		                              : "resource specialization is too late");
 	}
-	if (!ValidateResourceSnapshot(program, snapshot, error)) {
-		return false;
+	if (!ValidateResourceSnapshot(program, snapshot)) {
+		return SpecializationFail("invalid resource snapshot");
 	}
 
 	auto next          = program.info;
@@ -681,10 +557,8 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 	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 (error != nullptr) {
-				*error = "indirect image candidates exceed the dense image resource limit";
-			}
-			return false;
+			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());
@@ -720,10 +594,7 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 	for (uint32_t i = 0; i < next.buffers.size(); i++) {
 		ShaderBufferResource descriptor;
 		if (!DecodeBufferDescriptor(next_snapshot.buffers[i], descriptor)) {
-			if (error != nullptr) {
-				*error = fmt::format("buffer descriptor {} has invalid width", i);
-			}
-			return false;
+			return SpecializationFail(fmt::format("buffer descriptor {} has invalid width", i));
 		}
 		next.buffers[i].packed_stride      = descriptor.PackedStride();
 		next.buffers[i].descriptor_format  = descriptor.Format();
@@ -734,10 +605,8 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 		auto&       image      = next.images[i];
 		image.mip_count        = StorageMipCount(image, descriptor);
 		if (image.mip_count == 0u) {
-			if (error != nullptr) {
-				*error = fmt::format("storage image descriptor {} has an invalid mip range", i);
-			}
-			return false;
+			return SpecializationFail(
+			    fmt::format("storage image descriptor {} has an invalid mip range", i));
 		}
 		if (NullImageDescriptor(descriptor)) {
 			image.dimension = Decoder::ImageDimension::Dim2D;
@@ -755,37 +624,31 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 		}
 		const auto descriptor_dimension = DescriptorDimension(descriptor, image.dimension);
 		if (descriptor_dimension == Decoder::ImageDimension::Unknown) {
-			if (error != nullptr) {
-				*error = fmt::format(
-				    "image descriptor {} has unsupported type {}: {:08x},{:08x},{:08x},{:08x},"
-				    "{:08x},{:08x},{:08x},{:08x}",
-				    i, (descriptor.dwords[3] >> 28u) & 0xfu, descriptor.dwords[0],
-				    descriptor.dwords[1], descriptor.dwords[2], descriptor.dwords[3],
-				    descriptor.dwords[4], descriptor.dwords[5], descriptor.dwords[6],
-				    descriptor.dwords[7]);
-			}
-			return false;
+			return SpecializationFail(fmt::format(
+			    "image descriptor {} has unsupported type {}: {:08x},{:08x},{:08x},{:08x},"
+			    "{:08x},{:08x},{:08x},{:08x}",
+			    i, (descriptor.dwords[3] >> 28u) & 0xfu, descriptor.dwords[0], descriptor.dwords[1],
+			    descriptor.dwords[2], descriptor.dwords[3], descriptor.dwords[4],
+			    descriptor.dwords[5], descriptor.dwords[6], descriptor.dwords[7]));
 		}
 		image.dimension = descriptor_dimension;
 		image.cube      = DescriptorIsCube(descriptor);
 		const auto format =
 		    static_cast<Prospero::BufferFormat>((descriptor.dwords[1] >> 20u) & 0x1ffu);
 		if (image.atomic && format != Prospero::BufferFormat::k32UInt) {
-			if (error != nullptr) {
-				*error = fmt::format("atomic image descriptor {} uses unsupported format {}", i,
-				                     static_cast<uint32_t>(format));
-			}
-			return false;
+			return SpecializationFail(
+			    fmt::format("atomic image descriptor {} uses unsupported format {}", i,
+			                static_cast<uint32_t>(format)));
 		}
-		const bool storage = image.kind == ResourceKind::StorageImage ||
-		                     image.kind == ResourceKind::StorageImageUint;
+		const bool storage      = image.kind == ResourceKind::StorageImage ||
+		                          image.kind == ResourceKind::StorageImageUint;
 		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;
-		const bool uint_image = Prospero::IsUintTextureFormat(format) || raw_sint_storage;
+		const bool uint_image       = Prospero::IsUintTextureFormat(format) || raw_sint_storage;
 		if (uint_image) {
 			switch (image.kind) {
 				case ResourceKind::Image: image.kind = ResourceKind::ImageUint; break;
@@ -803,19 +666,13 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 		    static_cast<size_t>(root.indirect_mapping_offset) + 1u +
 		            static_cast<size_t>(root.indirect_mapping_capacity) * 2u >
 		        next_snapshot.flattened_srt.size()) {
-			if (error != nullptr) {
-				*error = "indirect image specialization has an invalid key mapping";
-			}
-			return false;
+			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) {
-				if (error != nullptr) {
-					*error = "indirect image specialization has an invalid candidate";
-				}
-				return false;
+				return SpecializationFail("indirect image specialization has an invalid candidate");
 			}
 			if (!NullImageDescriptor(next_snapshot.images[resource])) {
 				exemplar = resource;
@@ -823,10 +680,7 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 			}
 		}
 		if (exemplar == ImageResource::NoIndirectImage) {
-			if (error != nullptr) {
-				*error = "indirect image specialization has no typed candidate";
-			}
-			return false;
+			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++) {
@@ -849,12 +703,9 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 			    image.shader_swizzle != image_class.shader_swizzle ||
 			    image.depth_compare != image_class.depth_compare ||
 			    image.cube != image_class.cube) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "indirect image table at pc 0x{:08x} has incompatible candidates",
-					    root.first_use_pc);
-				}
-				return false;
+				return SpecializationFail(
+				    fmt::format("indirect image table at pc 0x{:08x} has incompatible candidates",
+				                root.first_use_pc));
 			}
 		}
 	}
@@ -867,11 +718,8 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 	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()) {
-			if (error != nullptr) {
-				*error = fmt::format("sampled resource pair at pc 0x{:08x} is invalid",
-				                     pair.first_use_pc);
-			}
-			return false;
+			return SpecializationFail(
+			    fmt::format("sampled resource pair at pc 0x{:08x} is invalid", pair.first_use_pc));
 		}
 		auto& usage = sampler_usage[pair.sampler];
 		if (next.images[pair.image].conversion_format != Prospero::BufferFormat::kInvalid) {
@@ -891,10 +739,8 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 			continue;
 		}
 		if (next.samplers.size() >= ShaderInfo::MaxSamplers) {
-			if (error != nullptr) {
-				*error = "point-filter sampler variants exceed the dense sampler resource limit";
-			}
-			return false;
+			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];
@@ -915,19 +761,13 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 			}
 			const auto index = inst.Flags<MemoryFlags>().index;
 			if (index >= memory_info.size()) {
-				if (error != nullptr) {
-					*error = fmt::format("typed image instruction has invalid memory metadata {}",
-					                     index);
-				}
-				return false;
+				return SpecializationFail(
+				    fmt::format("typed image instruction has invalid memory metadata {}", index));
 			}
 			auto& memory = memory_info[index];
 			if (memory.resource >= next.images.size()) {
-				if (error != nullptr) {
-					*error = fmt::format("typed image instruction has invalid resource {}",
-					                     memory.resource);
-				}
-				return false;
+				return SpecializationFail(fmt::format(
+				    "typed image instruction has invalid resource {}", memory.resource));
 			}
 			const auto& image = next.images[memory.resource];
 			if (image_opcode.needs_sampler &&
@@ -937,22 +777,18 @@ bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::stri
 			}
 			if (image.indirect_root == memory.resource &&
 			    inst.GetOpcode() != ValueOpcode::ImageSampleRaw) {
-				if (error != nullptr) {
-					*error = fmt::format(
-					    "indirect image table at pc 0x{:08x} is used by unsupported {}",
-					    inst.Flags<MemoryFlags>().pc, ValueOpcodeName(inst.GetOpcode()));
-				}
-				return false;
+				return SpecializationFail(
+				    fmt::format("indirect image table at pc 0x{:08x} is used by unsupported {}",
+				                inst.Flags<MemoryFlags>().pc, ValueOpcodeName(inst.GetOpcode())));
 			}
 			memory.kind            = image.kind;
 			memory.image_dimension = image.dimension;
 			memory.image_cube      = image.cube;
 		}
 	}
-	program.info                = std::move(next);
+	program.info        = std::move(next);
 	program.memory_info = std::move(memory_info);
-	snapshot                    = std::move(next_snapshot);
-	return true;
+	snapshot            = std::move(next_snapshot);
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR

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

@@ -22,19 +22,17 @@ struct ResourceSnapshot {
 	std::vector<IndirectImage>   indirect_images;
 };
 
-bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot,
-                              std::string* error);
-bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot,
-                                    std::string* error);
+bool ValidateResourceSnapshot(const Program& program, const ResourceSnapshot& snapshot);
+bool ValidateResourceSpecialization(const Program& program, const ResourceSnapshot& snapshot);
 
 // 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, std::string* error);
+                          ResourceSnapshot& snapshot);
 
 // Applies runtime descriptor shape/format facts to a copied dense topology before layout and
-// emission. On failure the program is unchanged.
-bool SpecializeResources(Program& program, ResourceSnapshot& snapshot, std::string* error);
+// emission. Invalid specializations are fatal.
+void SpecializeResources(Program& program, ResourceSnapshot& snapshot);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

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

@@ -1,8 +1,8 @@
 #include "graphics/shader/recompiler/ir/passes/ResourceTracking.h"
 
+#include "common/assert.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 #include "graphics/shader/recompiler/ir/passes/SrtWalker.h"
-#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <fmt/format.h>
@@ -12,7 +12,7 @@
 namespace Libs::Graphics::ShaderRecompiler::IR {
 namespace {
 
-constexpr uint32_t SamplerBorderClampMask = (1u << 2u) | (1u << 5u) | (1u << 8u);
+constexpr uint32_t SamplerBorderClampMask    = (1u << 2u) | (1u << 5u) | (1u << 8u);
 constexpr uint32_t SamplerDword3ReservedMask = 0x3ffff000u;
 
 uint32_t PossibleU32Bits(Value value) {
@@ -101,19 +101,17 @@ public:
 		m_info.uses_dma = false;
 	}
 
-	bool Run(std::string* error) {
+	void Run() {
 		if (m_program.resource_tracking_complete) {
-			return Fail(0, error, "resources already tracked");
+			Fail(0, "resources already tracked");
 		}
 		if (!m_program.srt_plan_complete) {
-			return Fail(0, error, "SRT plan is not ready");
+			Fail(0, "SRT plan is not ready");
 		}
 		PlanIndirectImages();
 		for (auto* block: m_program.blocks) {
 			for (auto& inst: *block) {
-				if (!Collect(inst, error)) {
-					return false;
-				}
+				Collect(inst);
 			}
 		}
 		LinkImageAliases();
@@ -145,10 +143,9 @@ public:
 				return std::ranges::find(plan.reads, inst) != plan.reads.end();
 			});
 		});
-		m_program.descriptor_sources          = std::move(m_sources);
+		m_program.descriptor_sources         = std::move(m_sources);
 		m_program.info                       = std::move(m_info);
 		m_program.resource_tracking_complete = true;
-		return true;
 	}
 
 private:
@@ -173,18 +170,19 @@ private:
 		std::array<const Inst*, 8> reads {};
 	};
 
-	bool Fail(uint32_t pc, std::string* error, const std::string& reason) const {
-		return ShaderError::Fail(
-		    error, fmt::format("shader resource tracking: hash=0x{:016x} stage={} pc=0x{:08x} {}",
-		                       m_program.shader_hash, StageName(m_program.stage), pc, reason));
+	[[noreturn]] void Fail(uint32_t pc, const std::string& reason) const {
+		const auto message =
+		    fmt::format("shader resource tracking: hash=0x{:016x} stage={} pc=0x{:08x} {}",
+		                m_program.shader_hash, StageName(m_program.stage), pc, reason);
+		EXIT("%s", message.c_str());
+		std::abort();
 	}
 
-	bool MakeSource(const Inst& handle, uint32_t width, bool sampler, bool sample_adjust,
-	                DescriptorSource& descriptor, uint32_t pc, std::string* error) const {
+	void MakeSource(const Inst& handle, uint32_t width, bool sampler, bool sample_adjust,
+	                DescriptorSource& descriptor, uint32_t pc) const {
 		if (handle.NumArgs() != width) {
-			return Fail(pc, error,
-			            fmt::format("{} has {} descriptor dwords, expected {}",
-			                        ValueOpcodeName(handle.GetOpcode()), handle.NumArgs(), width));
+			Fail(pc, fmt::format("{} has {} descriptor dwords, expected {}",
+			                     ValueOpcodeName(handle.GetOpcode()), handle.NumArgs(), width));
 		}
 		descriptor.dword_count = width;
 		for (uint32_t i = 0; i < width; i++) {
@@ -199,18 +197,15 @@ private:
 			// Border color and its table index are unused unless a clamp axis selects border mode.
 			descriptor.dwords[3] = Value(0u);
 		}
-		return true;
 	}
 
-	bool ValidateSource(const DescriptorSource& descriptor, std::string& reason,
-	                    uint32_t& bad_dword) const {
+	bool ValidateSource(const DescriptorSource& descriptor, uint32_t& bad_dword) const {
 		for (uint32_t i = 0; i < descriptor.dword_count; i++) {
 			bad_dword = i;
 			if (descriptor.dwords[i].Resolve().GetType() != Type::U32) {
-				reason = "is not U32";
 				return false;
 			}
-			if (!ValidateRuntimeValue(m_program, descriptor.dwords[i], reason)) {
+			if (!ValidateRuntimeValue(m_program, descriptor.dwords[i])) {
 				return false;
 			}
 		}
@@ -286,13 +281,12 @@ private:
 
 	bool MakeRuntimeBufferSource(const Inst& handle, uint32_t pc, uint32_t& source,
 	                             DescriptorSource& descriptor) {
-		if (handle.GetOpcode() != ValueOpcode::GetBufferResource ||
-		    !MakeSource(handle, 4u, false, false, descriptor, pc, nullptr)) {
+		if (handle.GetOpcode() != ValueOpcode::GetBufferResource) {
 			return false;
 		}
-		std::string reason;
-		uint32_t    bad_dword = 0;
-		if (!ValidateSource(descriptor, reason, bad_dword)) {
+		MakeSource(handle, 4u, false, false, descriptor, pc);
+		uint32_t bad_dword = 0;
+		if (!ValidateSource(descriptor, bad_dword)) {
 			return false;
 		}
 		source = InternSource(descriptor);
@@ -469,38 +463,30 @@ private:
 		}
 	}
 
-	bool GetHandle(Value value, ValueOpcode expected, uint32_t width, uint32_t pc, Inst*& handle,
-	               uint32_t& source, std::string* error, bool sampler = false,
-	               bool sample_adjust = false) {
+	void GetHandle(Value value, ValueOpcode expected, uint32_t width, uint32_t pc, Inst*& handle,
+	               uint32_t& source, bool sampler = false, bool sample_adjust = false) {
 		handle = value.Resolve().TryInstruction();
 		if (handle == nullptr || handle->GetOpcode() != expected) {
-			return Fail(pc, error,
-			            fmt::format("memory operation requires {}", ValueOpcodeName(expected)));
+			Fail(pc, fmt::format("memory operation requires {}", ValueOpcodeName(expected)));
 		}
 		DescriptorSource descriptor;
-		if (!MakeSource(*handle, width, sampler, sample_adjust, descriptor, pc, error)) {
-			return false;
-		}
-		std::string reason;
-		uint32_t    bad_dword = 0;
-		if (!ValidateSource(descriptor, reason, bad_dword)) {
-			return Fail(
-			    pc, error,
-			    fmt::format("{} dword {} {}", ValueOpcodeName(expected), bad_dword, reason));
+		MakeSource(*handle, width, sampler, sample_adjust, descriptor, pc);
+		uint32_t bad_dword = 0;
+		if (!ValidateSource(descriptor, bad_dword)) {
+			Fail(pc, fmt::format("{} dword {} is not a valid runtime value",
+			                     ValueOpcodeName(expected), bad_dword));
 		}
 		source = InternSource(descriptor);
-		return true;
 	}
 
-	bool ValidateAddressHandle(Value value, uint32_t pc, std::string* error) const {
+	void ValidateAddressHandle(Value value, uint32_t pc) const {
 		const auto* handle = value.Resolve().TryInstruction();
 		if (handle == nullptr || handle->GetOpcode() != ValueOpcode::GetAddressResource) {
-			return Fail(pc, error, "address operation requires GetAddressResource");
+			Fail(pc, "address operation requires GetAddressResource");
 		}
 		if (handle->NumArgs() != 2) {
-			return Fail(pc, error, "GetAddressResource must have two address dwords");
+			Fail(pc, "GetAddressResource must have two address dwords");
 		}
-		return true;
 	}
 
 	uint32_t AddBuffer(uint32_t source, const MemoryInfo& memory, ValueOpcode op, uint32_t pc) {
@@ -540,7 +526,7 @@ private:
 		const auto mip   = MipMode(memory);
 		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];
+			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 &&
@@ -593,155 +579,139 @@ private:
 		return static_cast<uint32_t>(m_info.samplers.size() - 1);
 	}
 
-	bool AddSampledPair(uint32_t image, uint32_t sampler, uint32_t pc, std::string* error) {
+	void AddSampledPair(uint32_t image, uint32_t sampler, uint32_t pc) {
 		for (auto& pair: m_info.sampled_pairs) {
 			if (pair.image == image && pair.sampler == sampler) {
 				pair.first_use_pc = std::min(pair.first_use_pc, pc);
-				return true;
+				return;
 			}
 		}
 		if (m_info.sampled_pairs.size() >= ShaderInfo::MaxSampledPairs) {
-			return Fail(pc, error, "sampled image/sampler pair limit exceeded");
+			Fail(pc, "sampled image/sampler pair limit exceeded");
 		}
 		m_info.sampled_pairs.push_back({image, sampler, pc});
-		return true;
 	}
 
-	bool AddHandlePatch(Inst* handle, uint32_t resource, uint32_t pc, std::string* error) {
+	void AddHandlePatch(Inst* handle, uint32_t resource, uint32_t pc) {
 		for (const auto& patch: m_handle_patches) {
 			if (patch.handle == handle) {
-				return patch.resource == resource ||
-				       Fail(pc, error,
-				            fmt::format("{} is reused with incompatible resource classes",
-				                        ValueOpcodeName(handle->GetOpcode())));
+				if (patch.resource != resource) {
+					Fail(pc, fmt::format("{} is reused with incompatible resource classes",
+					                     ValueOpcodeName(handle->GetOpcode())));
+				}
+				return;
 			}
 		}
 		m_handle_patches.push_back({handle, resource});
-		return true;
 	}
 
-	bool AddMemoryPatch(uint32_t index, uint32_t resource, uint32_t sampler, bool has_sampler,
-	                    uint32_t pc, std::string* error) {
+	void AddMemoryPatch(uint32_t index, uint32_t resource, uint32_t sampler, bool has_sampler,
+	                    uint32_t pc) {
 		for (auto& patch: m_memory_patches) {
 			if (patch.index != index) {
 				continue;
 			}
 			if (patch.resource != resource ||
 			    (has_sampler && patch.has_sampler && patch.sampler != sampler)) {
-				return Fail(pc, error, "memory metadata is reused with incompatible resources");
+				Fail(pc, "memory metadata is reused with incompatible resources");
 			}
 			if (has_sampler) {
 				patch.sampler     = sampler;
 				patch.has_sampler = true;
 			}
-			return true;
+			return;
 		}
 		m_memory_patches.push_back({index, resource, sampler, has_sampler});
-		return true;
 	}
 
-	bool Collect(Inst& inst, std::string* error) {
+	void Collect(Inst& inst) {
 		const auto op           = inst.GetOpcode();
 		const auto buffer       = BufferAccessOf(op);
 		const auto address_info = AddressOpcodeInfoOf(op);
 		const auto image_info   = ImageOpcodeInfoOf(op);
 		if (buffer == BufferAccess::None && address_info.access == AddressAccess::None &&
 		    image_info.access == ImageAccess::None) {
-			return true;
+			return;
 		}
 		const auto flags = inst.Flags<MemoryFlags>();
 		if (flags.index >= m_program.memory_info.size()) {
-			return Fail(flags.pc, error,
-			            fmt::format("memory metadata index {} is out of range", flags.index));
+			Fail(flags.pc, fmt::format("memory metadata index {} is out of range", flags.index));
 		}
 		if (inst.NumArgs() == 0) {
-			return Fail(flags.pc, error, "memory operation has no resource handle");
+			Fail(flags.pc, "memory operation has no resource handle");
 		}
 		const auto& memory = m_program.memory_info[flags.index];
 		if (memory.planning_only || IsIndirectPlanningMemory(flags.index)) {
-			return true;
+			return;
 		}
 		Inst*    handle   = nullptr;
 		uint32_t source   = 0;
 		uint32_t resource = 0;
 
 		if (buffer != BufferAccess::None) {
-			if (!GetHandle(inst.Arg(0), ValueOpcode::GetBufferResource, 4, flags.pc, handle, source,
-			               error)) {
-				return false;
-			}
+			GetHandle(inst.Arg(0), ValueOpcode::GetBufferResource, 4, flags.pc, handle, source);
 			resource = AddBuffer(source, memory, op, flags.pc);
 			if (resource == UINT32_MAX) {
-				return Fail(flags.pc, error, "buffer resource limit exceeded");
+				Fail(flags.pc, "buffer resource limit exceeded");
 			}
-			return AddHandlePatch(handle, resource, flags.pc, error) &&
-			       AddMemoryPatch(flags.index, resource, 0, false, flags.pc, error);
+			AddHandlePatch(handle, resource, flags.pc);
+			AddMemoryPatch(flags.index, resource, 0, false, flags.pc);
+			return;
 		}
 		if (address_info.access != AddressAccess::None) {
 			if (!IsAddressResourceKind(memory.kind)) {
-				return Fail(flags.pc, error, "address operation has invalid resource kind");
+				Fail(flags.pc, "address operation has invalid resource kind");
 			}
 			if (memory.kind == ResourceKind::Scratch) {
 				handle = inst.Arg(0).Resolve().TryInstruction();
 				if (handle == nullptr || handle->GetOpcode() != ValueOpcode::GetScratchResource ||
 				    handle->NumArgs() != 0) {
-					return Fail(flags.pc, error, "scratch operation requires GetScratchResource");
+					Fail(flags.pc, "scratch operation requires GetScratchResource");
 				}
 				if (m_program.scratch_dwords == 0) {
-					return Fail(flags.pc, error,
-					            "scratch operation requires a nonzero AGC per-thread size");
+					Fail(flags.pc, "scratch operation requires a nonzero AGC per-thread size");
 				}
-				return true;
-			}
-			if (!ValidateAddressHandle(inst.Arg(0), flags.pc, error)) {
-				return false;
+				return;
 			}
+			ValidateAddressHandle(inst.Arg(0), flags.pc);
 			m_info.uses_dma = true;
-			return true;
+			return;
 		}
 
 		if (!ImageResourceKindMatches(memory.kind, image_info.resource_class)) {
-			return Fail(flags.pc, error, "image operation has invalid resource kind");
+			Fail(flags.pc, "image operation has invalid resource kind");
 		}
 		handle               = inst.Arg(0).Resolve().TryInstruction();
 		const auto* indirect = handle != nullptr ? FindIndirectImage(*handle) : nullptr;
 		if (indirect != nullptr) {
 			source = indirect->source;
-		} else if (!GetHandle(inst.Arg(0), ValueOpcode::GetImageResource, 8, flags.pc, handle,
-		                      source, error)) {
-			return false;
+		} else {
+			GetHandle(inst.Arg(0), ValueOpcode::GetImageResource, 8, flags.pc, handle, source);
 		}
 		resource = AddImage(source, memory, op, flags.pc);
 		if (resource == UINT32_MAX) {
-			return Fail(flags.pc, error, "image resource limit exceeded");
-		}
-		if (!AddHandlePatch(handle, resource, flags.pc, error)) {
-			return false;
+			Fail(flags.pc, "image resource limit exceeded");
 		}
+		AddHandlePatch(handle, resource, flags.pc);
 		uint32_t sampler = 0;
 		if (image_info.needs_sampler) {
 			if (inst.NumArgs() < 2) {
-				return Fail(flags.pc, error, "sampled image operation has no sampler handle");
+				Fail(flags.pc, "sampled image operation has no sampler handle");
 			}
-			Inst*    sampler_handle = nullptr;
-			uint32_t sampler_source = 0;
+			Inst*      sampler_handle = nullptr;
+			uint32_t   sampler_source = 0;
 			const bool sample_adjust =
 			    (memory.image_sample_flags & Decoder::ImageSampleFlagAdjust) != 0;
-			if (!GetHandle(inst.Arg(1), ValueOpcode::GetSamplerResource, 4, flags.pc,
-			               sampler_handle, sampler_source, error, true, sample_adjust)) {
-				return false;
-			}
+			GetHandle(inst.Arg(1), ValueOpcode::GetSamplerResource, 4, flags.pc, sampler_handle,
+			          sampler_source, true, sample_adjust);
 			sampler = AddSampler(sampler_source, flags.pc);
 			if (sampler == UINT32_MAX) {
-				return Fail(flags.pc, error, "sampler resource limit exceeded");
-			}
-			if (!AddHandlePatch(sampler_handle, sampler, flags.pc, error) ||
-			    !AddSampledPair(resource, sampler, flags.pc, error)) {
-				return false;
+				Fail(flags.pc, "sampler resource limit exceeded");
 			}
+			AddHandlePatch(sampler_handle, sampler, flags.pc);
+			AddSampledPair(resource, sampler, flags.pc);
 		}
-		return AddMemoryPatch(flags.index, resource, sampler, image_info.needs_sampler, flags.pc,
-		                      error);
+		AddMemoryPatch(flags.index, resource, sampler, image_info.needs_sampler, flags.pc);
 	}
 
 	const DescriptorSource* Source(uint32_t source) const {
@@ -783,8 +753,8 @@ private:
 
 } // namespace
 
-bool TrackResources(Program& program, std::string* error) {
-	return Tracker(program).Run(error);
+void TrackResources(Program& program) {
+	Tracker(program).Run();
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR

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

@@ -7,7 +7,7 @@ namespace Libs::Graphics::ShaderRecompiler::IR {
 
 // Collects immutable resource topology from typed SSA handles, interns their resolved dwords in
 // descriptor_sources, then writes dense indices to handle flags and MemoryInfo.
-bool TrackResources(Program& program, std::string* error);
+void TrackResources(Program& program);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

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

@@ -1,5 +1,6 @@
 #include "graphics/shader/recompiler/ir/passes/ShaderInfoCollection.h"
 
+#include "common/assert.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 
 #include <algorithm>
@@ -8,6 +9,11 @@
 namespace Libs::Graphics::ShaderRecompiler::IR {
 namespace {
 
+[[noreturn]] void Fail(std::string_view message) {
+	EXIT("shader info collection failed: %s", std::string(message).c_str());
+	std::abort();
+}
+
 void AddInput(ShaderInfo& info, StageInputKind kind, uint32_t location, uint32_t components,
               std::string name, bool per_vertex = false) {
 	const auto input = std::find_if(info.inputs.begin(), info.inputs.end(), [=](const auto& value) {
@@ -34,38 +40,38 @@ void AddOutput(ShaderInfo& info, StageOutputKind kind, uint32_t index, uint32_t
 	}
 }
 
-bool ValidateOptions(const Program& program, const ShaderInfoOptions& options, std::string* error) {
-	auto Fail = [&](const char* message) {
-		if (error != nullptr) {
-			*error = message;
-		}
-		return false;
-	};
+void ValidateOptions(const Program& program, const ShaderInfoOptions& options) {
 	switch (program.stage) {
 		case ShaderType::Vertex:
+			if (options.vertex == nullptr) {
+				return Fail("vertex shader has no input metadata");
+			}
 			if (options.vertex->resources_num < 0 ||
 			    options.vertex->resources_num > ShaderVertexInputInfo::RES_MAX) {
 				return Fail("vertex resource count is out of range");
 			}
-			return true;
+			return;
 		case ShaderType::Pixel:
-			return options.pixel->input_num <= std::size(options.pixel->interpolator_settings) ||
-			       Fail("pixel input count is out of range");
+			if (options.pixel == nullptr) {
+				return Fail("pixel shader has no input metadata");
+			}
+			if (options.pixel->input_num > std::size(options.pixel->interpolator_settings)) {
+				return Fail("pixel input count is out of range");
+			}
+			return;
 		case ShaderType::Compute:
-			return (options.compute->thread_ids_num >= 0 && options.compute->thread_ids_num <= 3) ||
-			       Fail("compute thread ID count is out of range");
+			if (options.compute == nullptr) {
+				return Fail("compute shader has no input metadata");
+			}
+			if (options.compute->thread_ids_num < 0 || options.compute->thread_ids_num > 3) {
+				return Fail("compute thread ID count is out of range");
+			}
+			return;
 		default: return Fail("unsupported shader stage for info collection");
 	}
 }
 
-bool ValidateValueReferences(const Program& program, const ShaderInfoOptions& options,
-                             std::string* error) {
-	const auto Fail = [&](const char* message) {
-		if (error != nullptr) {
-			*error = message;
-		}
-		return false;
-	};
+void ValidateValueReferences(const Program& program, const ShaderInfoOptions& options) {
 	for (const auto* block: program.blocks) {
 		for (const auto& inst: *block) {
 			switch (inst.GetOpcode()) {
@@ -148,7 +154,6 @@ bool ValidateValueReferences(const Program& program, const ShaderInfoOptions& op
 			}
 		}
 	}
-	return true;
 }
 
 void CollectVertexInputs(const Program& program, const ShaderVertexInputInfo* vertex,
@@ -269,14 +274,8 @@ void CollectBuiltinInputs(const Program& program, ShaderInfo& info) {
 	}
 }
 
-bool CollectOutputs(const Program& program, const ShaderVertexInputInfo* vertex,
-	                const ShaderPixelInputInfo* pixel, ShaderInfo& info, std::string* error) {
-	auto Fail = [&](std::string message) {
-		if (error != nullptr) {
-			*error = std::move(message);
-		}
-		return false;
-	};
+void CollectOutputs(const Program& program, const ShaderVertexInputInfo* vertex,
+                    const ShaderPixelInputInfo* pixel, ShaderInfo& info) {
 	for (const auto* block: program.blocks) {
 		for (const auto& inst: *block) {
 			if (inst.GetOpcode() != ValueOpcode::SetAttribute) {
@@ -347,31 +346,23 @@ bool CollectOutputs(const Program& program, const ShaderVertexInputInfo* vertex,
 			}
 		}
 	}
-	return true;
 }
 
 } // namespace
 
-bool CollectShaderInfo(Program& program, const ShaderInfoOptions& options, std::string* error) {
+void CollectShaderInfo(Program& program, const ShaderInfoOptions& options) {
 	if (!program.resource_tracking_complete || program.shader_info_complete) {
-		if (error != nullptr) {
-			*error = !program.resource_tracking_complete ? "shader resources were not tracked"
-			                                             : "shader info already collected";
-		}
-		return false;
-	}
-	if (!ValidateOptions(program, options, error)) {
-		return false;
-	}
-	if (!ValidateValueReferences(program, options, error)) {
-		return false;
+		return Fail(!program.resource_tracking_complete ? "shader resources were not tracked"
+		                                                : "shader info already collected");
 	}
+	ValidateOptions(program, options);
+	ValidateValueReferences(program, options);
 
 	auto next = program.info;
 	next.inputs.clear();
 	next.outputs.clear();
-	next.has_bitwise_xor = std::any_of(
-	    program.blocks.begin(), program.blocks.end(), [](const auto* block) {
+	next.has_bitwise_xor =
+	    std::any_of(program.blocks.begin(), program.blocks.end(), [](const auto* block) {
 		    return std::any_of(block->begin(), block->end(), [](const auto& inst) {
 			    return inst.GetOpcode() == ValueOpcode::BitwiseXor32;
 		    });
@@ -380,15 +371,12 @@ bool CollectShaderInfo(Program& program, const ShaderInfoOptions& options, std::
 		case ShaderType::Vertex: CollectVertexInputs(program, options.vertex, next); break;
 		case ShaderType::Pixel: CollectPixelInputs(program, options.pixel, next); break;
 		case ShaderType::Compute: CollectComputeInputs(options.compute, next); break;
-		default: return false;
+		default: return Fail("unsupported shader stage for info collection");
 	}
 	CollectBuiltinInputs(program, next);
-	if (!CollectOutputs(program, options.vertex, options.pixel, next, error)) {
-		return false;
-	}
+	CollectOutputs(program, options.vertex, options.pixel, next);
 	program.info                 = std::move(next);
 	program.shader_info_complete = true;
-	return true;
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR

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

@@ -13,7 +13,7 @@ struct ShaderInfoOptions {
 
 // Completes the immutable shader interface after resource tracking. On failure Program::info and
 // all completion state remain unchanged.
-bool CollectShaderInfo(Program& program, const ShaderInfoOptions& options, std::string* error);
+void CollectShaderInfo(Program& program, const ShaderInfoOptions& options);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR
 

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

@@ -1,7 +1,7 @@
 #include "graphics/shader/recompiler/ir/passes/SrtWalker.h"
 
+#include "common/assert.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <bit>
@@ -120,10 +120,10 @@ class RuntimeValidator {
 public:
 	explicit RuntimeValidator(const Program& program): m_program(program) {}
 
-	bool Run(Value value, std::string& reason) { return Validate(value, reason); }
+	bool Run(Value value) { return Validate(value); }
 
 private:
-	bool Validate(Value value, std::string& reason) {
+	bool Validate(Value value) {
 		value            = value.Resolve();
 		const auto* inst = value.TryInstruction();
 		if (inst == nullptr) {
@@ -133,14 +133,10 @@ private:
 				case Type::U16:
 				case Type::U32:
 				case Type::U64: return true;
-				default:
-					reason = fmt::format("contains a non-integer immediate of type {}",
-					                     TypeName(value.GetType()));
-					return false;
+				default: return false;
 			}
 		}
 		if (!m_visiting.insert(inst).second) {
-			reason = fmt::format("contains a cyclic {} value", ValueOpcodeName(inst->GetOpcode()));
 			return false;
 		}
 		const auto finish = [&](bool valid) {
@@ -151,25 +147,21 @@ private:
 		if (op == ValueOpcode::UndefU1 || op == ValueOpcode::UndefU8 ||
 		    op == ValueOpcode::UndefU16 || op == ValueOpcode::UndefU32 ||
 		    op == ValueOpcode::UndefU64 || op == ValueOpcode::Void) {
-			reason = fmt::format("contains {}", ValueOpcodeName(op));
 			return finish(false);
 		}
 		if (op == ValueOpcode::GetUserData) {
 			if (inst->NumArgs() != 1 || inst->Arg(0).GetType() != Type::ScalarReg) {
-				reason = "contains a malformed GetUserData";
 				return finish(false);
 			}
 			const auto reg = RegIndex(inst->Arg(0).ScalarRegister());
 			if (reg < m_program.user_data_base ||
 			    reg - m_program.user_data_base >= m_program.user_data_count) {
-				reason = fmt::format("references unavailable user SGPR {}", reg);
 				return finish(false);
 			}
 			return finish(true);
 		}
 		if (op == ValueOpcode::GetShaderBase) {
 			if (inst->NumArgs() != 0) {
-				reason = "contains a malformed GetShaderBase";
 				return finish(false);
 			}
 			return finish(true);
@@ -177,14 +169,12 @@ private:
 		if (op == ValueOpcode::Phi) {
 			const auto invariant = ResolveInvariantPhi(m_program, value);
 			if (invariant.IsEmpty()) {
-				reason = "contains a control-dependent phi";
 				return finish(false);
 			}
-			return finish(Validate(invariant, reason));
+			return finish(Validate(invariant));
 		}
 		if (op == ValueOpcode::GetSrtResource) {
 			if (inst->NumArgs() != 0) {
-				reason = "contains a malformed GetSrtResource";
 				return finish(false);
 			}
 			return finish(true);
@@ -196,7 +186,6 @@ private:
 			        ValueOpcode::GetSrtResource ||
 			    !slot.IsImmediate() || slot.GetType() != Type::U32 ||
 			    slot.U32() >= m_program.srt_reads.size()) {
-				reason = "contains a malformed flattened SRT read";
 				return finish(false);
 			}
 		} else if (op == ValueOpcode::LoadAddressU32 || op == ValueOpcode::ReadConstBuffer) {
@@ -206,13 +195,11 @@ private:
 			const auto* handle = inst->NumArgs() != 0 ? inst->Arg(0).ResolveInstruction() : nullptr;
 			if (!IsRawRead(m_program, *inst) || handle == nullptr ||
 			    handle->GetOpcode() != expected) {
-				reason = fmt::format("contains a non-scalar {}", ValueOpcodeName(op));
 				return finish(false);
 			}
 		} else if (op == ValueOpcode::CompositeExtractU64) {
 			const auto index = inst->NumArgs() == 2 ? inst->Arg(1).Resolve() : Value {};
 			if (!index.IsImmediate() || index.GetType() != Type::U32 || index.U32() >= 2u) {
-				reason = "contains an invalid U64 component index";
 				return finish(false);
 			}
 		} else if (op == ValueOpcode::CompositeExtractU32x2) {
@@ -222,7 +209,6 @@ private:
 			    index.U32() >= 2u ||
 			    (source->GetOpcode() != ValueOpcode::CompositeConstructU32x2 &&
 			     source->GetOpcode() != ValueOpcode::IAddCarry32)) {
-				reason = "contains an unsupported composite runtime source";
 				return finish(false);
 			}
 		}
@@ -233,17 +219,14 @@ private:
 			                        : op == ValueOpcode::GetSamplerResource ? 4u
 			                                                                : 2u;
 			if (inst->NumArgs() != expected) {
-				reason = fmt::format("contains a malformed {}", ValueOpcodeName(op));
 				return finish(false);
 			}
 		} else if (op != ValueOpcode::ReadConst && op != ValueOpcode::ReadConstBuffer &&
 		           op != ValueOpcode::LoadAddressU32 && !IsRuntimeIntegerOp(op)) {
-			reason =
-			    fmt::format("contains unsupported or control-dependent {}", ValueOpcodeName(op));
 			return finish(false);
 		}
 		for (size_t index = 0; index < inst->NumArgs(); index++) {
-			if (!Validate(inst->Arg(index), reason)) {
+			if (!Validate(inst->Arg(index))) {
 				return finish(false);
 			}
 		}
@@ -258,7 +241,7 @@ class PlanBuilder {
 public:
 	explicit PlanBuilder(Program& program): m_program(program) {}
 
-	bool Run(std::string* error) {
+	void Run() {
 		m_program.srt_reads.clear();
 		m_program.dynamic_reads.clear();
 		for (auto* block: m_program.blocks) {
@@ -273,34 +256,29 @@ public:
 						                        (op == ValueOpcode::ReadConstBuffer &&
 						                         kind == ResourceKind::ScalarAddress);
 						if (crosswired) {
-							return Fail(flags.pc, error,
-							            fmt::format("{} has incompatible scalar memory metadata",
-							                        ValueOpcodeName(op)));
+							Fail(flags.pc,
+							     fmt::format("{} has incompatible scalar memory metadata",
+							                 ValueOpcodeName(op)));
 						}
 					}
 				}
 				if (IsDescriptorHandle(inst.GetOpcode())) {
 					for (size_t index = 0; index < inst.NumArgs(); index++) {
-						if (!Collect(inst.Arg(index), 0, error)) {
-							return false;
-						}
+						Collect(inst.Arg(index), 0);
 					}
 				}
 			}
 		}
 		for (auto* block: m_program.blocks) {
 			for (auto& inst: *block) {
-				std::string reason;
 				if (inst.GetOpcode() == ValueOpcode::LoadAddressU32 && IsRawRead(m_program, inst) &&
 				    inst.Arg(1).Resolve().IsImmediate() &&
-				    ValidateRuntimeValue(m_program, Value(&inst), reason) &&
-				    !Collect(Value(&inst), inst.Flags<MemoryFlags>().pc, error)) {
-					return false;
+				    ValidateRuntimeValue(m_program, Value(&inst))) {
+					Collect(Value(&inst), inst.Flags<MemoryFlags>().pc);
 				}
 			}
 		}
 		PatchReads();
-		return true;
 	}
 
 private:
@@ -310,18 +288,20 @@ private:
 		bool     keep = false;
 	};
 
-	bool Fail(uint32_t pc, std::string* error, const std::string& message) const {
-		return ShaderError::Fail(error, Diagnostic(m_program, pc, message));
+	[[noreturn]] void Fail(uint32_t pc, const std::string& message) const {
+		const auto diagnostic = Diagnostic(m_program, pc, message);
+		EXIT("shader SRT planning failed: %s", diagnostic.c_str());
+		std::abort();
 	}
 
-	bool Collect(Value value, uint32_t use_pc, std::string* error) {
+	void Collect(Value value, uint32_t use_pc) {
 		value = value.Resolve();
 		if (value.IsImmediate()) {
-			return true;
+			return;
 		}
 		auto* inst = value.TryInstruction();
 		if (inst == nullptr) {
-			return Fail(use_pc, error, "invalid typed planning value");
+			Fail(use_pc, "invalid typed planning value");
 		}
 		const auto cycle = std::ranges::find(m_visiting, inst);
 		if (cycle != m_visiting.end()) {
@@ -329,44 +309,40 @@ private:
 				return value->GetOpcode() == ValueOpcode::Phi;
 			});
 			if (contains_phi) {
-				return true;
+				return;
 			}
-			return Fail(use_pc, error,
-			            fmt::format("cyclic typed planning value {} without a phi",
-			                        ValueOpcodeName(inst->GetOpcode())));
+			Fail(use_pc, fmt::format("cyclic typed planning value {} without a phi",
+			                         ValueOpcodeName(inst->GetOpcode())));
 		}
 		if (std::ranges::find(m_visited, inst) != m_visited.end()) {
-			return true;
+			return;
 		}
 		m_visiting.push_back(inst);
 		for (size_t index = 0; index < inst->NumArgs(); index++) {
-			if (!Collect(inst->Arg(index), use_pc, error)) {
-				return false;
-			}
+			Collect(inst->Arg(index), use_pc);
 		}
 		m_visiting.pop_back();
 		m_visited.push_back(inst);
 		if (!IsRawRead(m_program, *inst)) {
-			return true;
+			return;
 		}
 		const auto offset = inst->Arg(1).Resolve();
 		if (!offset.IsImmediate() || offset.GetType() != Type::U32) {
-			if (std::ranges::find(m_program.dynamic_reads, value) == m_program.dynamic_reads.end()) {
+			if (std::ranges::find(m_program.dynamic_reads, value) ==
+			    m_program.dynamic_reads.end()) {
 				m_program.dynamic_reads.push_back(value);
 			}
-			return true;
+			return;
 		}
-		use_pc = inst->Flags<MemoryFlags>().pc;
 		for (uint32_t slot = 0; slot < m_program.srt_reads.size(); slot++) {
 			if (EquivalentValue(m_program, value, m_program.srt_reads[slot].value)) {
 				m_patches.push_back({inst, slot, false});
-				return true;
+				return;
 			}
 		}
 		const auto slot = static_cast<uint32_t>(m_program.srt_reads.size());
-		m_program.srt_reads.push_back({value, slot, use_pc});
+		m_program.srt_reads.push_back({value, slot});
 		m_patches.push_back({inst, slot, true});
-		return true;
 	}
 
 	void PatchReads() {
@@ -411,14 +387,12 @@ class Evaluator {
 public:
 	Evaluator(const Program& program, const SrtRuntime& runtime,
 	          std::span<const uint8_t> clean_flat_slots = {}, Evaluator* clean_evaluator = nullptr)
-	    : m_program(program), m_runtime(runtime),
-	      m_clean_flat_slots(clean_flat_slots), m_clean_evaluator(clean_evaluator) {}
+	    : m_program(program), m_runtime(runtime), m_clean_flat_slots(clean_flat_slots),
+	      m_clean_evaluator(clean_evaluator) {}
 
-	void SetUsePc(uint32_t pc) { m_use_pc = pc; }
-
-	bool Evaluate(Value value, uint32_t& result, std::string* error) {
+	bool Evaluate(Value value, uint32_t& result) {
 		uint64_t wide = 0;
-		if (!EvaluateWide(value, wide, error)) {
+		if (!EvaluateWide(value, wide)) {
 			return false;
 		}
 		result = static_cast<uint32_t>(wide);
@@ -426,11 +400,7 @@ public:
 	}
 
 private:
-	bool Fail(std::string* error, const std::string& message) const {
-		return ShaderError::Fail(error, Diagnostic(m_program, m_use_pc, message));
-	}
-
-	bool EvaluateWide(Value value, uint64_t& result, std::string* error) {
+	bool EvaluateWide(Value value, uint64_t& result) {
 		value = value.Resolve();
 		if (value.IsImmediate()) {
 			switch (value.GetType()) {
@@ -439,23 +409,23 @@ 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;
-				default: return Fail(error, "non-integer immediate in runtime expression");
+				default: return false;
 			}
 		}
 		auto* inst = value.TryInstruction();
 		if (inst == nullptr) {
-			return Fail(error, "invalid typed runtime value");
+			return false;
 		}
 		if (const auto found = m_cache.find(inst); found != m_cache.end()) {
 			result = found->second;
 			return true;
 		}
 		if (std::ranges::find(m_visiting, inst) != m_visiting.end()) {
-			return Fail(error, "cyclic typed runtime value");
+			return false;
 		}
 		m_visiting.push_back(inst);
 		uint64_t out = 0;
-		if (!EvaluateInst(*inst, out, error)) {
+		if (!EvaluateInst(*inst, out)) {
 			return false;
 		}
 		m_visiting.pop_back();
@@ -464,28 +434,27 @@ private:
 		return true;
 	}
 
-	bool Arg(const Inst& inst, size_t index, uint64_t& result, std::string* error) {
-		return EvaluateWide(inst.Arg(index), result, error);
+	bool Arg(const Inst& inst, size_t index, uint64_t& result) {
+		return EvaluateWide(inst.Arg(index), result);
 	}
 
-	bool EvaluatePhi(const Inst& inst, uint64_t& result, std::string* error) {
+	bool EvaluatePhi(const Inst& inst, uint64_t& result) {
 		const auto value = ResolveInvariantPhi(m_program, Value(const_cast<Inst*>(&inst)));
-		return !value.IsEmpty() ? EvaluateWide(value, result, error)
-		                        : Fail(error, "typed phi has runtime-dependent values");
+		return !value.IsEmpty() && EvaluateWide(value, result);
 	}
 
-	bool EvaluateExtract(const Inst& inst, uint64_t& result, std::string* error) {
+	bool EvaluateExtract(const Inst& inst, uint64_t& result) {
 		const auto index = inst.Arg(1).Resolve();
 		if (!index.IsImmediate() || index.GetType() != Type::U32) {
-			return Fail(error, "dynamic composite extract in runtime expression");
+			return false;
 		}
 		const auto component = index.U32();
 		if (component >= 2u) {
-			return Fail(error, "unsupported composite runtime source");
+			return false;
 		}
 		if (inst.GetOpcode() == ValueOpcode::CompositeExtractU64) {
 			uint64_t packed = 0;
-			if (!Arg(inst, 0, packed, error)) {
+			if (!Arg(inst, 0, packed)) {
 				return false;
 			}
 			result = static_cast<uint32_t>(packed >> (component * 32u));
@@ -493,15 +462,15 @@ private:
 		}
 		const auto* source = inst.Arg(0).ResolveInstruction();
 		if (source == nullptr) {
-			return Fail(error, "unsupported composite runtime source");
+			return false;
 		}
 		if (source->GetOpcode() == ValueOpcode::CompositeConstructU32x2) {
-			return EvaluateWide(source->Arg(component), result, error);
+			return EvaluateWide(source->Arg(component), result);
 		}
 		if (source->GetOpcode() == ValueOpcode::IAddCarry32) {
 			uint64_t lhs = 0;
 			uint64_t rhs = 0;
-			if (!Arg(*source, 0, lhs, error) || !Arg(*source, 1, rhs, error)) {
+			if (!Arg(*source, 0, lhs) || !Arg(*source, 1, rhs)) {
 				return false;
 			}
 			const auto sum =
@@ -510,24 +479,23 @@ private:
 			    component == 0u ? static_cast<uint32_t>(sum) : static_cast<uint32_t>(sum >> 32u);
 			return true;
 		}
-		return Fail(error, "unsupported composite runtime source");
+		return false;
 	}
 
-	bool EvaluateRawRead(const Inst& inst, uint64_t& result, std::string* error) {
+	bool EvaluateRawRead(const Inst& inst, uint64_t& result) {
 		const auto flags = inst.Flags<MemoryFlags>();
 		if (flags.index >= m_program.memory_info.size()) {
-			return Fail(error, "raw scalar read has invalid metadata");
+			return false;
 		}
 		const auto& mem    = m_program.memory_info[flags.index];
 		const auto* handle = inst.Arg(0).ResolveInstruction();
 		if (handle == nullptr) {
-			return Fail(error, "raw scalar read has no descriptor handle");
+			return false;
 		}
 		uint64_t low    = 0;
 		uint64_t high   = 0;
 		uint64_t offset = 0;
-		if (!Arg(*handle, 0, low, error) || !Arg(*handle, 1, high, error) ||
-		    !Arg(inst, 1, offset, error)) {
+		if (!Arg(*handle, 0, low) || !Arg(*handle, 1, high) || !Arg(inst, 1, offset)) {
 			return false;
 		}
 		const auto base      = ((high << 32u) | static_cast<uint32_t>(low)) & AddressMask;
@@ -536,12 +504,11 @@ private:
 		if (inst.GetOpcode() == ValueOpcode::ReadConstBuffer) {
 			uint64_t records = 0;
 			uint64_t word3   = 0;
-			if (handle->NumArgs() != 4u || !Arg(*handle, 2, records, error) ||
-			    !Arg(*handle, 3, word3, error)) {
-				return Fail(error, "constant-buffer descriptor has invalid width");
+			if (handle->NumArgs() != 4u || !Arg(*handle, 2, records) || !Arg(*handle, 3, word3)) {
+				return false;
 			}
 			if (immediate < 0) {
-				return Fail(error, "constant-buffer read has a negative immediate offset");
+				return false;
 			}
 			const auto byte_offset =
 			    static_cast<uint64_t>(immediate) + static_cast<uint32_t>(offset);
@@ -551,21 +518,20 @@ private:
 			                      ? static_cast<uint64_t>(static_cast<uint32_t>(records))
 			                      : static_cast<uint64_t>(stride) * static_cast<uint32_t>(records);
 			if (aligned > size || size - aligned < sizeof(uint32_t)) {
-				return Fail(
-				    error, fmt::format("constant-buffer offset {} exceeds size {}", aligned, size));
+				return false;
 			}
 			address = ((base & ~uint64_t {3}) + byte_offset) & ~uint64_t {3};
 		} else {
 			const auto relative = (immediate & ~int64_t {3}) +
 			                      static_cast<int64_t>(static_cast<uint32_t>(offset) & ~3u);
 			if (!AddSignedAddress(base & ~uint64_t {3}, relative, address)) {
-				return Fail(error, "raw scalar read is outside the 48-bit address space");
+				return false;
 			}
 		}
 		uint32_t word = 0;
 		if (m_runtime.read_memory != nullptr) {
 			if (!m_runtime.read_memory(m_runtime.userdata, address, &word)) {
-				return Fail(error, fmt::format("constant read failed at 0x{:016x}", address));
+				return false;
 			}
 		} else {
 			std::memcpy(&word, reinterpret_cast<const void*>(address), sizeof(word));
@@ -574,28 +540,28 @@ private:
 		return true;
 	}
 
-	bool EvaluateInst(const Inst& inst, uint64_t& result, std::string* error) {
+	bool EvaluateInst(const Inst& inst, uint64_t& result) {
 		uint64_t   a       = 0;
 		uint64_t   b       = 0;
 		uint64_t   c       = 0;
-		const auto binary  = [&]() { return Arg(inst, 0, a, error) && Arg(inst, 1, b, error); };
+		const auto binary  = [&]() { return Arg(inst, 0, a) && Arg(inst, 1, b); };
 		const auto ternary = [&]() {
-			return Arg(inst, 0, a, error) && Arg(inst, 1, b, error) && Arg(inst, 2, c, error);
+			return Arg(inst, 0, a) && Arg(inst, 1, b) && Arg(inst, 2, c);
 		};
 		switch (inst.GetOpcode()) {
 			case ValueOpcode::GetUserData: {
 				const auto reg = RegIndex(inst.Arg(0).ScalarRegister());
 				if (reg < m_program.user_data_base ||
 				    reg - m_program.user_data_base >= m_runtime.user_data.size()) {
-					return Fail(error, fmt::format("user SGPR {} is unavailable", reg));
+					return false;
 				}
 				result = m_runtime.user_data[reg - m_program.user_data_base];
 				return true;
 			}
 			case ValueOpcode::GetShaderBase: result = m_runtime.shader_base; return true;
-			case ValueOpcode::Phi: return EvaluatePhi(inst, result, error);
+			case ValueOpcode::Phi: return EvaluatePhi(inst, result);
 			case ValueOpcode::CompositeExtractU64:
-			case ValueOpcode::CompositeExtractU32x2: return EvaluateExtract(inst, result, error);
+			case ValueOpcode::CompositeExtractU32x2: return EvaluateExtract(inst, result);
 			case ValueOpcode::CompositeConstructU64:
 				if (!binary()) {
 					return false;
@@ -607,20 +573,19 @@ private:
 				const auto slot = inst.Arg(1).Resolve();
 				if (!slot.IsImmediate() || slot.GetType() != Type::U32 ||
 				    slot.U32() >= m_program.srt_reads.size()) {
-					return Fail(error, "invalid flattened SRT index");
+					return false;
 				}
 				if (slot.U32() < m_clean_flat_slots.size() &&
 				    m_clean_flat_slots[slot.U32()] != 0u && m_clean_evaluator != nullptr) {
-					m_clean_evaluator->SetUsePc(m_use_pc);
 					return m_clean_evaluator->EvaluateWide(m_program.srt_reads[slot.U32()].value,
-					                                       result, error);
+					                                       result);
 				}
-				return EvaluateWide(m_program.srt_reads[slot.U32()].value, result, error);
+				return EvaluateWide(m_program.srt_reads[slot.U32()].value, result);
 			}
 			case ValueOpcode::LoadAddressU32:
 			case ValueOpcode::ReadConstBuffer:
 				if (IsRawRead(m_program, inst)) {
-					return EvaluateRawRead(inst, result, error);
+					return EvaluateRawRead(inst, result);
 				}
 				break;
 			case ValueOpcode::IAdd32:
@@ -690,7 +655,7 @@ private:
 				}
 				return false;
 			case ValueOpcode::BitwiseNot32:
-				if (Arg(inst, 0, a, error)) {
+				if (Arg(inst, 0, a)) {
 					result = ~static_cast<uint32_t>(a);
 					return true;
 				}
@@ -737,7 +702,7 @@ private:
 					const auto offset = static_cast<uint32_t>(b);
 					const auto width  = static_cast<uint32_t>(c);
 					if (offset > 32u || width > 32u - offset) {
-						return Fail(error, "invalid unsigned bit-field range");
+						return false;
 					}
 					const auto mask = width == 32u  ? UINT32_MAX
 					                  : width == 0u ? 0u
@@ -751,7 +716,7 @@ private:
 					const auto offset = static_cast<uint32_t>(b);
 					const auto width  = static_cast<uint32_t>(c);
 					if (offset > 32u || width > 32u - offset) {
-						return Fail(error, "invalid signed bit-field range");
+						return false;
 					}
 					if (width == 0u) {
 						result = 0;
@@ -768,13 +733,13 @@ private:
 				return false;
 			case ValueOpcode::BitFieldInsert: {
 				uint64_t d = 0;
-				if (!ternary() || !Arg(inst, 3, d, error)) {
+				if (!ternary() || !Arg(inst, 3, d)) {
 					return false;
 				}
 				const auto offset = static_cast<uint32_t>(c);
 				const auto width  = static_cast<uint32_t>(d);
 				if (offset > 32u || width > 32u - offset) {
-					return Fail(error, "invalid inserted bit-field range");
+					return false;
 				}
 				if (width == 0u) {
 					result = static_cast<uint32_t>(a);
@@ -836,7 +801,7 @@ private:
 				}
 				return false;
 			case ValueOpcode::LogicalNot:
-				if (Arg(inst, 0, a, error)) {
+				if (Arg(inst, 0, a)) {
 					result = a == 0u;
 					return true;
 				}
@@ -845,18 +810,16 @@ private:
 			case ValueOpcode::UndefU8:
 			case ValueOpcode::UndefU16:
 			case ValueOpcode::UndefU32:
-			case ValueOpcode::UndefU64: return Fail(error, "undefined typed runtime value");
+			case ValueOpcode::UndefU64: return false;
 			default: break;
 		}
-		return Fail(error, fmt::format("unsupported typed runtime opcode {}",
-		                               ValueOpcodeName(inst.GetOpcode())));
+		return false;
 	}
 
 	const Program&                            m_program;
 	const SrtRuntime&                         m_runtime;
 	std::span<const uint8_t>                  m_clean_flat_slots;
 	Evaluator*                                m_clean_evaluator = nullptr;
-	uint32_t                                  m_use_pc          = 0;
 	std::unordered_map<const Inst*, uint64_t> m_cache;
 	std::vector<const Inst*>                  m_visiting;
 };
@@ -872,18 +835,12 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
                                 std::span<const DescriptorSourceRequest> requests,
                                 const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
                                 std::vector<uint32_t>& flat, bool evaluate_flat,
-                                std::span<const uint8_t> clean_flat_slots, std::string* error) {
+                                std::span<const uint8_t> clean_flat_slots) {
 	if (!program.srt_plan_complete) {
-		if (error != nullptr) {
-			*error = Diagnostic(program, 0, "typed SRT plan is not ready");
-		}
 		return false;
 	}
 	if (std::ranges::any_of(clean_flat_slots, [](uint8_t clean) { return clean != 0u; }) &&
 	    runtime.read_specialization_memory == nullptr) {
-		if (error != nullptr) {
-			*error = Diagnostic(program, 0, "clean flattened SRT read has no memory reader");
-		}
 		return false;
 	}
 	SrtRuntime clean_runtime  = runtime;
@@ -895,17 +852,12 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
 	for (const auto& request: requests) {
 		const auto* source = Source(program, request.source);
 		if (source == nullptr) {
-			if (error != nullptr) {
-				*error = Diagnostic(program, request.use_pc,
-				                    fmt::format("invalid descriptor source {}", request.source));
-			}
 			return false;
 		}
-		evaluator.SetUsePc(request.use_pc);
 		DescriptorValue value;
 		value.dword_count = source->dword_count;
 		for (uint32_t index = 0; index < source->dword_count; index++) {
-			if (!evaluator.Evaluate(source->dwords[index], value.dwords[index], error)) {
+			if (!evaluator.Evaluate(source->dwords[index], value.dwords[index])) {
 				return false;
 			}
 		}
@@ -918,9 +870,8 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
 			const bool clean    = read.flat_offset < clean_flat_slots.size() &&
 			                      clean_flat_slots[read.flat_offset] != 0u;
 			auto&      selected = clean ? clean_evaluator : evaluator;
-			selected.SetUsePc(read.use_pc);
 			if (read.flat_offset >= flattened.size() ||
-			    !selected.Evaluate(read.value, flattened[read.flat_offset], error)) {
+			    !selected.Evaluate(read.value, flattened[read.flat_offset])) {
 				return false;
 			}
 		}
@@ -934,31 +885,24 @@ bool EvaluateRuntimeSourcesImpl(const Program&                           program
 
 } // namespace
 
-bool ValidateRuntimeValue(const Program& program, Value value, std::string& reason) {
-	return RuntimeValidator(program).Run(value, reason);
+bool ValidateRuntimeValue(const Program& program, Value value) {
+	return RuntimeValidator(program).Run(value);
 }
 
-bool BuildSrtPlan(Program& program, std::string* error) {
+void BuildSrtPlan(Program& program) {
 	if (program.resource_tracking_complete) {
-		if (error != nullptr) {
-			*error = "cannot rebuild SRT after resource tracking";
-		}
-		return false;
+		EXIT("shader SRT planning failed: cannot rebuild SRT after resource tracking");
 	}
 	program.srt_plan_complete = false;
-	if (!PlanBuilder(program).Run(error)) {
-		return false;
-	}
+	PlanBuilder(program).Run();
 	program.srt_plan_complete = true;
-	return true;
 }
 
-bool EvaluateDescriptorSource(const Program& program, uint32_t source, uint32_t use_pc,
-                              const SrtRuntime& runtime, DescriptorValue& result,
-                              std::string* error) {
-	const DescriptorSourceRequest request {source, use_pc};
+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, error)) {
+	if (!EvaluateDescriptorSources(program, std::span {&request, 1}, runtime, results)) {
 		return false;
 	}
 	result = results.front();
@@ -967,26 +911,23 @@ bool EvaluateDescriptorSource(const Program& program, uint32_t source, uint32_t
 
 bool EvaluateDescriptorSources(const Program&                           program,
                                std::span<const DescriptorSourceRequest> requests,
-                               const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
-                               std::string* error) {
+                               const SrtRuntime& runtime, std::vector<DescriptorValue>& results) {
 	std::vector<uint32_t> ignored;
-	return EvaluateRuntimeSourcesImpl(program, requests, runtime, results, ignored, false, {},
-	                                  error);
+	return EvaluateRuntimeSourcesImpl(program, requests, runtime, results, ignored, false, {});
 }
 
 bool EvaluateRuntimeSources(const Program&                           program,
                             std::span<const DescriptorSourceRequest> requests,
                             const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
-                            std::vector<uint32_t>& flat, std::span<const uint8_t> clean_flat_slots,
-                            std::string* error) {
+                            std::vector<uint32_t>&   flat,
+                            std::span<const uint8_t> clean_flat_slots) {
 	return EvaluateRuntimeSourcesImpl(program, requests, runtime, results, flat, true,
-	                                  clean_flat_slots, error);
+	                                  clean_flat_slots);
 }
 
-bool WalkSrt(const Program& program, const SrtRuntime& runtime, std::vector<uint32_t>& flat,
-             std::string* error) {
+bool WalkSrt(const Program& program, const SrtRuntime& runtime, std::vector<uint32_t>& flat) {
 	std::vector<DescriptorValue> ignored;
-	return EvaluateRuntimeSources(program, {}, runtime, ignored, flat, {}, error);
+	return EvaluateRuntimeSources(program, {}, runtime, ignored, flat, {});
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR

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

@@ -13,43 +13,38 @@ using SrtMemoryReader = bool (*)(void* userdata, uint64_t address, uint32_t* val
 
 struct SrtRuntime {
 	std::span<const uint32_t> user_data;
-	uint64_t                  shader_base = 0;
-	SrtMemoryReader           read_memory = nullptr;
-	void*                     userdata    = nullptr;
+	uint64_t                  shader_base                = 0;
+	SrtMemoryReader           read_memory                = nullptr;
+	void*                     userdata                   = nullptr;
 	SrtMemoryReader           read_specialization_memory = nullptr;
 };
 
 struct DescriptorSourceRequest {
 	uint32_t source = 0;
-	uint32_t use_pc = 0;
 };
 
 // Collects reachable ReadConst values. Immediate offsets receive compact flat-buffer slots;
 // dynamic offsets remain explicit and are never assigned a fake slot.
-bool BuildSrtPlan(Program& program, std::string* error);
-bool ValidateRuntimeValue(const Program& program, Value value, std::string& reason);
+void BuildSrtPlan(Program& program);
+bool ValidateRuntimeValue(const Program& program, Value value);
 
-bool EvaluateDescriptorSource(const Program& program, uint32_t source, uint32_t use_pc,
-                              const SrtRuntime& runtime, DescriptorValue& result,
-                              std::string* error);
+bool EvaluateDescriptorSource(const Program& 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,
-                               const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
-                               std::string* error);
+                               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,
                             const SrtRuntime& runtime, std::vector<DescriptorValue>& results,
-                            std::vector<uint32_t>& flat, std::span<const uint8_t> clean_flat_slots,
-                            std::string* error);
+                            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,
-             std::string* error);
+bool WalkSrt(const Program& program, const SrtRuntime& runtime, std::vector<uint32_t>& flat);
 
 } // namespace Libs::Graphics::ShaderRecompiler::IR