shader: remove recompiler error-string propagation

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

@@ -1,19 +1,23 @@
 #include "graphics/shader/recompiler/backend/spirv/SpirvEmitter.h"
 
+#include "common/assert.h"
 #include "graphics/shader/recompiler/backend/spirv/spirvEmitterInternal.h"
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
-#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <array>
 
 namespace Libs::Graphics::ShaderRecompiler::Spirv {
 
-using ShaderError::Fail;
-
 namespace {
 
-bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
+[[noreturn]] void Fail(const IR::Program& program, const char* reason) {
+	EXIT("SPIR-V validation failed: hash=0x%016" PRIx64 " stage=%u reason=%s\n",
+	     program.shader_hash, static_cast<unsigned>(program.stage), reason);
+	std::abort();
+}
+
+void ValidateNativeProgram(const IR::Program& program) {
 	using Kind                                             = IR::DescriptorBindingKind;
 	constexpr auto                               KindCount = static_cast<size_t>(Kind::Count);
 	std::array<std::vector<uint32_t>, KindCount> expected;
@@ -36,13 +40,13 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 	for (uint32_t i = 0; i < program.info.images.size(); i++) {
 		const auto kind = IR::DescriptorBindingForImage(program.info.images[i]);
 		if (!kind.has_value()) {
-			return Fail(error, "native shader plan has an invalid image class");
+			Fail(program, "native shader plan has an invalid image class");
 		}
 		present[static_cast<size_t>(*kind)] = true;
 		const auto dynamic = program.info.images[i].mip_mode == IR::ImageMipMode::DynamicStorage;
 		const auto count   = dynamic ? program.info.images[i].mip_count : 1u;
 		if (count == 0u || (!dynamic && program.info.images[i].mip_count != 1u)) {
-			return Fail(error, "native shader plan has an invalid image mip descriptor count");
+			Fail(program, "native shader plan has an invalid image mip descriptor count");
 		}
 		expected[static_cast<size_t>(*kind)].insert(expected[static_cast<size_t>(*kind)].end(),
 		                                            count, i);
@@ -58,11 +62,11 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 			}
 			const auto index = inst.Flags<IR::MemoryFlags>().index;
 			if (index >= program.memory_info.size()) {
-				return Fail(error, "shared operation has invalid memory metadata");
+				Fail(program, "shared operation has invalid memory metadata");
 			}
 			const auto kind = program.memory_info[index].kind;
 			if (kind != IR::ResourceKind::Lds && kind != IR::ResourceKind::Gds) {
-				return Fail(error, "shared operation has invalid resource kind");
+				Fail(program, "shared operation has invalid resource kind");
 			}
 			uses_gds |= kind == IR::ResourceKind::Gds;
 		}
@@ -91,13 +95,13 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 		const auto kind = static_cast<size_t>(binding.kind);
 		if (kind >= KindCount || seen[kind] || !present[kind] ||
 		    binding.resources != expected[kind]) {
-			return Fail(error, "native descriptor groups do not match shader topology");
+			Fail(program, "native descriptor groups do not match shader topology");
 		}
 		seen[kind] = true;
 	}
 	for (size_t i = 0; i < KindCount; i++) {
 		if (present[i] != seen[i]) {
-			return Fail(error, "native shader plan is missing a required descriptor group");
+			Fail(program, "native shader plan is missing a required descriptor group");
 		}
 	}
 	const auto has_user_storage = present[static_cast<size_t>(Kind::UserData)];
@@ -114,7 +118,7 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 	    std::adjacent_find(program.bindings.user_data_registers.begin(),
 	                       program.bindings.user_data_registers.end()) !=
 	        program.bindings.user_data_registers.end()) {
-		return Fail(error, "native user-data layout is inconsistent");
+		Fail(program, "native user-data layout is inconsistent");
 	}
 
 	const auto planning_only_handle = [&](const IR::Inst& handle) {
@@ -139,7 +143,7 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 						break;
 					}
 					if (dense >= program.info.buffers.size()) {
-						return Fail(error, "typed buffer handle has an invalid dense resource");
+						Fail(program, "typed buffer handle has an invalid dense resource");
 					}
 					break;
 				case IR::ValueOpcode::GetAddressResource:
@@ -147,29 +151,29 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 						break;
 					}
 					if (inst.NumArgs() != 2 || !program.info.uses_dma) {
-						return Fail(error, "typed address handle has invalid DMA metadata");
+						Fail(program, "typed address handle has invalid DMA metadata");
 					}
 					break;
 				case IR::ValueOpcode::GetScratchResource:
 					if (inst.NumArgs() != 0 || program.scratch_dwords == 0) {
-						return Fail(error, "typed scratch handle has invalid shader metadata");
+						Fail(program, "typed scratch handle has invalid shader metadata");
 					}
 					break;
 				case IR::ValueOpcode::GetImageResource:
 					if (dense >= program.info.images.size()) {
-						return Fail(error, "typed image handle has an invalid dense resource");
+						Fail(program, "typed image handle has an invalid dense resource");
 					}
 					break;
 				case IR::ValueOpcode::GetSamplerResource:
 					if (dense >= program.info.samplers.size()) {
-						return Fail(error, "typed sampler handle has an invalid dense resource");
+						Fail(program, "typed sampler handle has an invalid dense resource");
 					}
 					break;
 				case IR::ValueOpcode::ReadConst: {
 					const auto slot = inst.Arg(1).Resolve();
 					if (!slot.IsImmediate() || slot.GetType() != IR::Type::U32 ||
 					    slot.U32() >= program.srt_reads.size()) {
-						return Fail(error, "flattened SRT read has an invalid dense slot");
+						Fail(program, "flattened SRT read has an invalid dense slot");
 					}
 					break;
 				}
@@ -177,12 +181,11 @@ bool ValidateNativeProgram(const IR::Program& program, std::string* error) {
 			}
 		}
 	}
-	return true;
 }
 
 } // namespace
 
-bool AnalyzeProgramRequirements(IR::Program& program, std::string* error) {
+void AnalyzeProgramRequirements(IR::Program& program) {
 	program.spirv_requirements.reset();
 	IR::SpirvRequirements requirements {};
 	const auto MarkBallot = [&] { requirements.subgroup_ballot = true; };
@@ -192,30 +195,30 @@ bool AnalyzeProgramRequirements(IR::Program& program, std::string* error) {
 			if (address_access != IR::AddressAccess::None) {
 				const auto memory_index = inst.Flags<IR::MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, "address operation has invalid memory metadata");
+					Fail(program, "address operation has invalid memory metadata");
 				}
 				if (program.memory_info[memory_index].kind == IR::ResourceKind::Scratch) {
 					if (program.scratch_dwords == 0) {
-						return Fail(error, "scratch operation has no per-thread storage");
+						Fail(program, "scratch operation has no per-thread storage");
 					}
 					requirements.function_scratch = true;
 				} else if (address_access == IR::AddressAccess::Write) {
-					return Fail(error, "writable FLAT/GLOBAL addresses require GPU ownership tracking");
+					Fail(program, "writable FLAT/GLOBAL addresses require GPU ownership tracking");
 				}
 			}
 			if (IR::BufferAccessOf(inst.GetOpcode()) != IR::BufferAccess::None) {
 				const auto memory_index = inst.Flags<IR::MemoryFlags>().index;
 				if (memory_index >= program.memory_info.size()) {
-					return Fail(error, "buffer operation has invalid memory metadata");
+					Fail(program, "buffer operation has invalid memory metadata");
 				}
 				const auto& memory = program.memory_info[memory_index];
 				if (memory.kind == IR::ResourceKind::Buffer) {
 					if (memory.resource >= program.info.buffers.size()) {
-						return Fail(error, "buffer operation has invalid resource metadata");
+						Fail(program, "buffer operation has invalid resource metadata");
 					}
 					if ((program.info.buffers[memory.resource].packed_stride & (1u << 20u)) != 0u) {
 						if (program.stage != ShaderType::Compute) {
-							return Fail(error, "buffer ADD_TID is only valid for compute shaders");
+							Fail(program, "buffer ADD_TID is only valid for compute shaders");
 						}
 						requirements.subgroup_local_invocation_id = true;
 					}
@@ -225,11 +228,11 @@ bool AnalyzeProgramRequirements(IR::Program& program, std::string* error) {
 			if (shared_access != IR::SharedAccess::None) {
 				const auto index = inst.Flags<IR::MemoryFlags>().index;
 				if (index >= program.memory_info.size()) {
-					return Fail(error, "shared operation has invalid memory metadata");
+					Fail(program, "shared operation has invalid memory metadata");
 				}
 				const auto kind = program.memory_info[index].kind;
 				if (kind != IR::ResourceKind::Lds && kind != IR::ResourceKind::Gds) {
-					return Fail(error, "shared operation has invalid resource kind");
+					Fail(program, "shared operation has invalid resource kind");
 				}
 				if (program.stage != ShaderType::Compute && kind == IR::ResourceKind::Lds) {
 					requirements.function_lds = true;
@@ -283,7 +286,7 @@ bool AnalyzeProgramRequirements(IR::Program& program, std::string* error) {
 				case IR::ValueOpcode::SetAttribute: {
 					const auto index = inst.Flags<IR::ExportFlags>().index;
 					if (index >= program.export_info.size()) {
-						return Fail(error, "attribute export has invalid metadata");
+						Fail(program, "attribute export has invalid metadata");
 					}
 					if (program.stage == ShaderType::Pixel &&
 					    program.export_info[index].vm) {
@@ -296,37 +299,30 @@ bool AnalyzeProgramRequirements(IR::Program& program, std::string* error) {
 		}
 	}
 	program.spirv_requirements.emplace(requirements);
-	return true;
 }
 
-bool EmitProgram(const IR::Program& program, const IR::ResourceSnapshot& resources,
-                 ShaderStageInputInfo input_info, std::vector<uint32_t>& spirv,
-                 std::string* error) {
+std::vector<uint32_t> EmitProgram(const IR::Program& program,
+                                  const IR::ResourceSnapshot& resources,
+                                  ShaderStageInputInfo input_info) {
 	using namespace Emitter;
 
 	if (program.stage != ShaderType::Compute && program.stage != ShaderType::Vertex &&
 	    program.stage != ShaderType::Pixel) {
-		SetError(error, "binary SPIR-V emitter supports compute, vertex, and pixel shaders");
-		return false;
+		Fail(program, "binary SPIR-V emitter supports compute, vertex, and pixel shaders");
 	}
 	if (!program.srt_plan_complete || !program.resource_tracking_complete ||
 	    !program.shader_info_complete || !program.binding_layout_complete ||
 	    !program.spirv_requirements.has_value()) {
-		SetError(error, "SPIR-V emitter requires a fully planned native shader program");
-		return false;
+		Fail(program, "SPIR-V emitter requires a fully planned native shader program");
 	}
-	if (!IR::ValidateResourceSnapshot(program, resources, error)) {
-		return false;
+	if (!IR::ValidateResourceSnapshot(program, resources)) {
+		Fail(program, "resource snapshot is inconsistent with the native shader plan");
 	}
-	if (!IR::ValidateResourceSpecialization(program, resources, error)) {
-		return false;
-	}
-	if (!ValidateNativeProgram(program, error)) {
-		return false;
-	}
-	if (!IR::ValidateProgram(program, true, error)) {
-		return false;
+	if (!IR::ValidateResourceSpecialization(program, resources)) {
+		Fail(program, "resource specialization is inconsistent with the native shader plan");
 	}
+	ValidateNativeProgram(program);
+	IR::ValidateProgram(program, true);
 	EmitterState state(program, resources, input_info);
 	state.stage     = program.stage;
 	state.wave_size = program.wave_size;
@@ -337,17 +333,13 @@ bool EmitProgram(const IR::Program& program, const IR::ResourceSnapshot& resourc
 	AllocateInputVariables(state);
 	AllocateOutputVariables(state);
 	DefineModule(state);
-	if (!EmitProgram(state, program, error)) {
-		return false;
-	}
+	EmitProgram(state, program);
 
 	auto binary = state.builder.Build();
 	if (binary.empty()) {
-		SetError(error, "SPIR-V builder returned an empty module");
-		return false;
+		Fail(program, "SPIR-V builder returned an empty module");
 	}
-	spirv = std::move(binary);
-	return true;
+	return binary;
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::Spirv

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

@@ -9,10 +9,11 @@
 
 namespace Libs::Graphics::ShaderRecompiler::Spirv {
 
-bool AnalyzeProgramRequirements(IR::Program& program, std::string* error);
+void AnalyzeProgramRequirements(IR::Program& program);
 
-bool EmitProgram(const IR::Program& program, const IR::ResourceSnapshot& resources,
-                 ShaderStageInputInfo input_info, std::vector<uint32_t>& spirv, std::string* error);
+std::vector<uint32_t> EmitProgram(const IR::Program& program,
+                                  const IR::ResourceSnapshot& resources,
+                                  ShaderStageInputInfo input_info);
 
 } // namespace Libs::Graphics::ShaderRecompiler::Spirv
 

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

@@ -37,12 +37,6 @@ bool PixelParameterIsCustom(const EmitterState& state, uint32_t attr) {
 	       ShaderPixelParameterIsCustom(*state.input_info.pixel, attr);
 }
 
-void SetError(std::string* error, const char* message) {
-	if (error != nullptr) {
-		*error = message;
-	}
-}
-
 bool HasOutput(const std::vector<OutputBinding>& outputs, IR::StageOutputKind kind,
                uint32_t index) {
 	return std::any_of(outputs.begin(), outputs.end(), [kind, index](const OutputBinding& binding) {

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

@@ -439,7 +439,8 @@ struct ValueEmitContext {
 	const IR::MemoryInfo& Memory(const IR::Inst& inst) const;
 	const IR::ExportInfo& Export(const IR::Inst& inst) const;
 	uint32_t              Label(const IR::Block* block) const;
-	void                  Fail(const IR::Inst& inst, const char* reason);
+	[[noreturn]] void     Fail(const char* reason) const;
+	[[noreturn]] void     Fail(const IR::Inst& inst, const char* reason) const;
 
 	EmitterState&                                                      state;
 	const IR::Program&                                            program;
@@ -449,8 +450,6 @@ struct ValueEmitContext {
 	std::unordered_map<const IR::Inst*, std::pair<uint32_t, uint32_t>> dispatcher_block_loads;
 	const IR::Block*                                                   current_block = nullptr;
 	uint32_t                                                           scratch_u32_variable = 0;
-	bool                                                               failed               = false;
-	std::string                                                        error;
 };
 
 enum class VertexInputScalarKind { Float, Sint, Uint };
@@ -613,8 +612,6 @@ uint32_t VertexParameterVectorOrScalarType(EmitterState& state, VertexInputScala
 uint32_t VertexParameterInputPointerType(EmitterState& state, VertexInputScalarKind kind,
                                          uint32_t components);
 
-void SetError(std::string* error, const char* message);
-
 bool HasOutput(const std::vector<OutputBinding>& outputs, IR::StageOutputKind kind, uint32_t index);
 
 void CopyProgramInputsAndOutputs(EmitterState& state, const IR::Program& program);
@@ -864,7 +861,7 @@ bool EmitValueMemory(ValueEmitContext& ctx, const IR::Inst& inst);
 
 bool EmitValueImage(ValueEmitContext& ctx, const IR::Inst& inst);
 
-bool EmitProgram(EmitterState& state, const IR::Program& program, std::string* error);
+void EmitProgram(EmitterState& state, const IR::Program& program);
 
 void DefineGetBdaPointer(EmitterState& state);
 

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

@@ -1,8 +1,9 @@
 #include "graphics/shader/recompiler/backend/spirv/spirvEmitterInternal.h"
 
+#include "common/assert.h"
+
 #include <algorithm>
 #include <bit>
-#include <fmt/format.h>
 #include <functional>
 #include <optional>
 #include <unordered_set>
@@ -196,57 +197,50 @@ uint32_t EmitDispatcherNextPc(ValueEmitContext& ctx, const DispatcherFunctionSta
 	}
 }
 
-bool EmitDirectInstruction(ValueEmitContext& ctx, const IR::Inst& inst) {
+void EmitDirectInstruction(ValueEmitContext& ctx, const IR::Inst& inst) {
 	if (EmitValueFlow(ctx, inst) || EmitValueAlu(ctx, inst) || EmitValueMemory(ctx, inst) ||
 	    EmitValueImage(ctx, inst)) {
-		return true;
+		return;
 	}
 	ctx.Fail(inst, "has no direct SPIR-V emitter");
-	return false;
 }
 
-bool EmitStructuredInstruction(ValueEmitContext& ctx, StructuredFunctionState& structured,
+void EmitStructuredInstruction(ValueEmitContext& ctx, StructuredFunctionState& structured,
                                const IR::Inst& inst) {
 	if (inst.GetOpcode() == IR::ValueOpcode::Phi) {
 		const auto type = ctx.TypeId(inst.GetType());
 		if (type == 0 || inst.NumArgs() == 0) {
 			ctx.Fail(inst, "has no native SPIR-V representation");
-			return false;
 		}
 		for (size_t index = 0; index < inst.NumArgs(); index++) {
 			const auto* predecessor = inst.PhiBlock(index);
 			if (predecessor == nullptr || !ctx.labels.contains(predecessor)) {
 				ctx.Fail(inst, "has a predecessor outside the structured function");
-				return false;
 			}
 		}
 		structured.deferred_phis.push_back(
 		    {ctx.state.builder.AddDeferredPhi(type, ctx.Result(inst), inst.NumArgs()), &inst});
-		return true;
+		return;
 	}
-	return EmitDirectInstruction(ctx, inst);
+	EmitDirectInstruction(ctx, inst);
 }
 
-bool EmitDispatcherInstruction(ValueEmitContext& ctx, const DispatcherFunctionState& dispatcher,
+void EmitDispatcherInstruction(ValueEmitContext& ctx, const DispatcherFunctionState& dispatcher,
                                const IR::Inst& inst) {
 	if (inst.GetOpcode() == IR::ValueOpcode::Phi) {
 		const auto type = ctx.TypeId(inst.GetType());
 		if (type == 0) {
 			ctx.Fail(inst, "cannot be loaded by the dispatcher");
-			return false;
 		}
 		ctx.state.builder.AddFunction(
 		    {OpLoad, type, ctx.Result(inst), dispatcher.spills.at(&inst)});
-		return true;
-	}
-	if (!EmitDirectInstruction(ctx, inst)) {
-		return false;
+		return;
 	}
+	EmitDirectInstruction(ctx, inst);
 	if (const auto found = dispatcher.spills.find(&inst); found != dispatcher.spills.end()) {
 		ctx.state.builder.AddFunction(
 		    {OpStore, found->second, ctx.Def(IR::Value(const_cast<IR::Inst*>(&inst)))});
 	}
-	return true;
 }
 
 template <typename EmitInstruction>
@@ -258,14 +252,11 @@ void EmitBlock(ValueEmitContext& ctx, const IR::Block* block, EmitInstruction&&
 		if (inst.GetOpcode() == IR::ValueOpcode::Phi) {
 			if (emitted_non_phi) {
 				ctx.Fail(inst, "appears after a non-Phi instruction");
-				return;
 			}
 		} else {
 			emitted_non_phi = true;
 		}
-		if (!emit_instruction(inst)) {
-			return;
-		}
+		emit_instruction(inst);
 	}
 }
 
@@ -275,15 +266,10 @@ void PatchStructuredPhis(ValueEmitContext& ctx, StructuredFunctionState& structu
 			const auto* predecessor = deferred.instruction->PhiBlock(index);
 			const auto  found       = structured.block_exit_labels.find(predecessor);
 			if (found == structured.block_exit_labels.end()) {
-				ctx.failed = true;
-				ctx.error  = "typed Phi predecessor was not emitted";
-				return;
+				ctx.Fail(*deferred.instruction, "has a predecessor that was not emitted");
 			}
 			ctx.state.builder.PatchDeferredPhi(
 			    deferred.phi, index, ctx.Def(deferred.instruction->Arg(index)), found->second);
-			if (ctx.failed) {
-				return;
-			}
 		}
 	}
 }
@@ -291,20 +277,15 @@ void PatchStructuredPhis(ValueEmitContext& ctx, StructuredFunctionState& structu
 void EmitStructuredFunction(ValueEmitContext& ctx) {
 	StructuredFunctionState structured;
 	ctx.state.builder.AddFunction({OpBranch, ctx.Label(ctx.program.blocks.front())});
-	for (size_t index = 0; index < ctx.program.blocks.size() && !ctx.failed; index++) {
+	for (size_t index = 0; index < ctx.program.blocks.size(); index++) {
 		const auto* block = ctx.program.blocks[index];
 		EmitBlock(ctx, block, [&](const IR::Inst& inst) {
-			return EmitStructuredInstruction(ctx, structured, inst);
+			EmitStructuredInstruction(ctx, structured, inst);
 		});
-		if (ctx.failed) {
-			break;
-		}
 		structured.block_exit_labels.emplace(block, ctx.state.current_label);
 		EmitStructuredTerminator(ctx, block, ctx.program.block_info[index]);
 	}
-	if (!ctx.failed) {
-		PatchStructuredPhis(ctx, structured);
-	}
+	PatchStructuredPhis(ctx, structured);
 }
 
 void EmitDispatcherFunction(ValueEmitContext& ctx, const DispatcherFunctionState& dispatcher) {
@@ -312,11 +293,8 @@ void EmitDispatcherFunction(ValueEmitContext& ctx, const DispatcherFunctionState
 	const auto* entry = ctx.program.blocks.front();
 	state.builder.AddFunction({OpBranch, ctx.Label(entry)});
 	EmitBlock(ctx, entry, [&](const IR::Inst& inst) {
-		return EmitDispatcherInstruction(ctx, dispatcher, inst);
+		EmitDispatcherInstruction(ctx, dispatcher, inst);
 	});
-	if (ctx.failed) {
-		return;
-	}
 	const auto initial_pc =
 	    EmitDispatcherNextPc(ctx, dispatcher, entry, ctx.program.block_info.front());
 	const auto initial_parent = state.current_label;
@@ -347,22 +325,16 @@ void EmitDispatcherFunction(ValueEmitContext& ctx, const DispatcherFunctionState
 	std::vector<uint32_t> next_pc_words {OpPhi, TypeU32(state), next_pc,
 	                                     ConstantU32(state, UINT32_MAX), dispatcher.select_label};
 
-	for (size_t index = 1; index < ctx.program.blocks.size() && !ctx.failed; index++) {
+	for (size_t index = 1; index < ctx.program.blocks.size(); index++) {
 		EmitBlock(ctx, ctx.program.blocks[index], [&](const IR::Inst& inst) {
-			return EmitDispatcherInstruction(ctx, dispatcher, inst);
+			EmitDispatcherInstruction(ctx, dispatcher, inst);
 		});
-		if (ctx.failed) {
-			break;
-		}
 		const auto selected = EmitDispatcherNextPc(ctx, dispatcher, ctx.program.blocks[index],
 		                                           ctx.program.block_info[index]);
 		next_pc_words.push_back(selected);
 		next_pc_words.push_back(state.current_label);
 		state.builder.AddFunction({OpBranch, dispatcher.after_switch_label});
 	}
-	if (ctx.failed) {
-		return;
-	}
 	EmitLabel(state, dispatcher.after_switch_label);
 	state.builder.AddFunction(next_pc_words);
 	state.builder.AddFunction({OpBranch, dispatcher.continue_label});
@@ -408,9 +380,7 @@ uint32_t ValueEmitContext::Def(IR::Value value) {
 	}
 	const auto* inst = value.ResolveInstruction();
 	if (inst == nullptr) {
-		failed = true;
-		error  = "direct SPIR-V emitter received a non-value argument";
-		return ConstantU32(state, 0);
+		Fail("direct SPIR-V emitter received a non-value argument");
 	}
 	if (dispatcher_spills != nullptr && current_block != nullptr &&
 	    inst->Parent() != current_block) {
@@ -469,9 +439,7 @@ uint32_t ValueEmitContext::Define(const IR::Inst& inst, uint32_t value) {
 uint32_t ValueEmitContext::ResourceIndex(IR::Value value, IR::ValueOpcode opcode) {
 	const auto* inst = value.ResolveInstruction();
 	if (inst == nullptr || inst->GetOpcode() != opcode) {
-		failed = true;
-		error  = "typed resource handle has the wrong producer";
-		return 0;
+		Fail("typed resource handle has the wrong producer");
 	}
 	return inst->Flags<uint32_t>();
 }
@@ -479,9 +447,7 @@ uint32_t ValueEmitContext::ResourceIndex(IR::Value value, IR::ValueOpcode opcode
 const IR::Inst* ValueEmitContext::ImageAddress(IR::Value value) {
 	const auto* inst = value.ResolveInstruction();
 	if (inst == nullptr || inst->GetOpcode() != IR::ValueOpcode::MakeImageAddress) {
-		failed = true;
-		error  = "typed image address was not constructed by MakeImageAddress";
-		return nullptr;
+		Fail("typed image address was not constructed by MakeImageAddress");
 	}
 	return inst;
 }
@@ -498,12 +464,20 @@ uint32_t ValueEmitContext::Label(const IR::Block* block) const {
 	return labels.at(block);
 }
 
-void ValueEmitContext::Fail(const IR::Inst& inst, const char* reason) {
-	failed = true;
-	error  = fmt::format("typed opcode {} {}", IR::ValueOpcodeName(inst.GetOpcode()), reason);
+[[noreturn]] void ValueEmitContext::Fail(const char* reason) const {
+	EXIT("SPIR-V emission failed: hash=0x%016" PRIx64 " stage=%u reason=%s\n",
+	     program.shader_hash, static_cast<unsigned>(program.stage), reason);
+	std::abort();
 }
 
-bool EmitProgram(EmitterState& state, const IR::Program& program, std::string* error) {
+[[noreturn]] void ValueEmitContext::Fail(const IR::Inst& inst, const char* reason) const {
+	EXIT("SPIR-V emission failed: hash=0x%016" PRIx64 " stage=%u opcode=%s reason=%s\n",
+	     program.shader_hash, static_cast<unsigned>(program.stage),
+	     IR::ValueOpcodeName(inst.GetOpcode()), reason);
+	std::abort();
+}
+
+void EmitProgram(EmitterState& state, const IR::Program& program) {
 	ValueEmitContext                       ctx(state, program);
 	std::optional<DispatcherFunctionState> dispatcher;
 	if (state.stage == ShaderType::Pixel && state.requirements.pixel_valid_mask) {
@@ -562,10 +536,6 @@ bool EmitProgram(EmitterState& state, const IR::Program& program, std::string* e
 		dispatch.merge_label        = state.builder.AllocateId();
 		ctx.dispatcher_spills       = &dispatch.spills;
 	}
-	if (ctx.failed) {
-		SetError(error, ctx.error.c_str());
-		return false;
-	}
 	DefineGetBdaPointer(state);
 	for (const auto* block: program.blocks) {
 		if (std::ranges::any_of(*block, [](const IR::Inst& inst) {
@@ -630,11 +600,6 @@ bool EmitProgram(EmitterState& state, const IR::Program& program, std::string* e
 		EmitStructuredFunction(ctx);
 	}
 	state.builder.AddFunction({OpFunctionEnd});
-	if (ctx.failed) {
-		SetError(error, ctx.error.c_str());
-		return false;
-	}
-	return true;
 }
 
 } // namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter