recompiler: deduplication cleanup

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

@@ -2,6 +2,7 @@
 
 #include "graphics/shader/recompiler/backend/spirv/spirvEmitterInternal.h"
 #include "graphics/shader/recompiler/ir/ValueProgram.h"
+#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <array>
@@ -10,14 +11,9 @@
 
 namespace Libs::Graphics::ShaderRecompiler::Spirv {
 
-namespace {
+using ShaderError::Fail;
 
-bool Fail(std::string* error, const std::string& message) {
+namespace {
-	if (error != nullptr) {
-		*error = message;
-	}
-	return false;
-}
 
 bool ImageBinding(const IR::ImageResource& image, IR::DescriptorBindingKind& kind) {
 	using Kind = IR::DescriptorBindingKind;

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

@@ -1,4 +1,5 @@
 #include "graphics/shader/recompiler/frontend/translate/Translator.h"
+#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <array>
@@ -6,14 +7,10 @@
 #include <utility>
 
 namespace Libs::Graphics::ShaderRecompiler::Frontend {
-namespace Detail {
 
-bool Fail(std::string* error, const std::string& message) {
+using ShaderError::Fail;
-	if (error != nullptr) {
+
-		*error = message;
+namespace Detail {
-	}
-	return false;
-}
 
 IR::Operand Translator::OffsetOperand(const IR::Operand& operand, uint32_t offset) {
 	if (offset == 0 || operand.kind != IR::OperandKind::Register) {
@@ -808,7 +805,7 @@ bool TranslateProgram(const IR::Program& source, IR::ValueProgram& result,
 			    return block.id;
 		    })->id;
 		if (max_id == UINT32_MAX) {
-			return Detail::Fail(error, "cannot allocate a typed prologue block id");
+			return Fail(error, "cannot allocate a typed prologue block id");
 		}
 		CFG::Terminator terminator;
 		terminator.kind       = CFG::TerminatorKind::Branch;
@@ -827,7 +824,7 @@ bool TranslateProgram(const IR::Program& source, IR::ValueProgram& result,
 	for (size_t index = 0; index < source.blocks.size(); index++) {
 		for (const auto successor: source.blocks[index].successors) {
 			if (successor >= source.blocks.size()) {
-				return Detail::Fail(error, "value IR block successor is out of range");
+				return Fail(error, "value IR block successor is out of range");
 			}
 			result.blocks[index + 1u]->AddBranch(result.blocks[successor + 1u]);
 		}

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

@@ -18,8 +18,6 @@ struct ScalarMemorySourceValues {
 	IR::U32   offset;
 };
 
-bool Fail(std::string* error, const std::string& message);
-
 class Translator {
 public:
 	Translator(IR::ValueProgram& program, IR::Block* block, uint32_t vector_limit,

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

@@ -1,18 +1,16 @@
 #include "graphics/shader/recompiler/ir/ValueProgram.h"
 
+#include "graphics/shader/shader.h"
+
 #include <fmt/format.h>
 #include <map>
 #include <unordered_set>
 
 namespace Libs::Graphics::ShaderRecompiler::IR {
-namespace {
 
-bool Fail(std::string* error, const std::string& message) {
+using ShaderError::Fail;
-	if (error != nullptr) {
+
-		*error = message;
+namespace {
-	}
-	return false;
-}
 
 bool IsRegisterGet(ValueOpcode opcode) {
 	switch (opcode) {

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

@@ -2,6 +2,7 @@
 
 #include "graphics/shader/recompiler/ir/ValueProgram.h"
 #include "graphics/shader/recompiler/ir/passes/SrtWalker.h"
+#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <fmt/format.h>
@@ -215,11 +216,9 @@ private:
 	};
 
 	bool Fail(uint32_t pc, std::string* error, const std::string& reason) const {
-		if (error != nullptr) {
+		return ShaderError::Fail(
-			*error = fmt::format("shader resource tracking: hash=0x{:016x} stage={} pc=0x{:08x} {}",
+		    error, fmt::format("shader resource tracking: hash=0x{:016x} stage={} pc=0x{:08x} {}",
-			                     m_program.shader_hash, StageName(m_program.stage), pc, reason);
+		                       m_program.shader_hash, StageName(m_program.stage), pc, reason));
-		}
-		return false;
 	}
 
 	struct AddressPart {

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

@@ -1,6 +1,7 @@
 #include "graphics/shader/recompiler/ir/passes/SrtWalker.h"
 
 #include "graphics/shader/recompiler/ir/ValueProgram.h"
+#include "graphics/shader/shader.h"
 
 #include <algorithm>
 #include <bit>
@@ -314,10 +315,7 @@ private:
 	};
 
 	bool Fail(uint32_t pc, std::string* error, const std::string& message) const {
-		if (error != nullptr) {
+		return ShaderError::Fail(error, Diagnostic(m_program, pc, message));
-			*error = Diagnostic(m_program, pc, message);
-		}
-		return false;
 	}
 
 	bool Collect(Value value, uint32_t use_pc, std::string* error) {
@@ -434,10 +432,7 @@ public:
 
 private:
 	bool Fail(std::string* error, const std::string& message) const {
-		if (error != nullptr) {
+		return ShaderError::Fail(error, Diagnostic(m_program, m_use_pc, message));
-			*error = Diagnostic(m_program, m_use_pc, message);
-		}
-		return false;
 	}
 
 	bool EvaluateWide(Value value, uint64_t& result, std::string* error) {

src/graphics/shader/shader.h

@@ -10,10 +10,22 @@
 #include <memory>
 #include <span>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace Libs::Graphics {
 
+namespace ShaderError {
+
+[[nodiscard]] inline bool Fail(std::string* error, std::string_view message) {
+	if (error != nullptr) {
+		error->assign(message.data(), message.size());
+	}
+	return false;
+}
+
+} // namespace ShaderError
+
 namespace HW {
 struct VertexShaderInfo;
 struct PixelShaderInfo;

src/graphics/shader/shaderVertexMetadata.cpp

@@ -5,21 +5,10 @@
 
 namespace Libs::Graphics {
 
-namespace {
-
-bool Fail(std::string* error, const char* message) {
-	if (error != nullptr) {
-		*error = message;
-	}
-	return false;
-}
-
-} // namespace
-
 bool ShaderReadVertexMetadata(const ShaderMappedData& data, uint32_t max_user_sgprs,
                               ShaderVertexMetadata& metadata, std::string* error) {
 	if (data.user_data == nullptr) {
-		return Fail(error, "missing AGC user-data header");
+		return ShaderError::Fail(error, "missing AGC user-data header");
 	}
 
 	ShaderUserData user_data {};
@@ -28,7 +17,8 @@ bool ShaderReadVertexMetadata(const ShaderMappedData& data, uint32_t max_user_sg
 	constexpr uint32_t DirectResourceCount =
 	    static_cast<uint32_t>(AgcDirectResourceType::Last) + 1u;
 	if (user_data.direct_resource_count > DirectResourceCount) {
-		return Fail(error, "AGC direct-resource count exceeds the known resource domain");
+		return ShaderError::Fail(error,
+		                         "AGC direct-resource count exceeds the known resource domain");
 	}
 
 	std::array<uint16_t, DirectResourceCount> direct_offsets {};
@@ -36,7 +26,7 @@ bool ShaderReadVertexMetadata(const ShaderMappedData& data, uint32_t max_user_sg
 	    static_cast<uint64_t>(user_data.direct_resource_count) * sizeof(uint16_t);
 	if (direct_size != 0) {
 		if (user_data.direct_resource_offset == nullptr) {
-			return Fail(error, "missing AGC direct-resource offsets");
+			return ShaderError::Fail(error, "missing AGC direct-resource offsets");
 		}
 		std::memcpy(direct_offsets.data(), user_data.direct_resource_offset, direct_size);
 	}
@@ -57,31 +47,31 @@ bool ShaderReadVertexMetadata(const ShaderMappedData& data, uint32_t max_user_sg
 	}
 
 	if (next.vertex_attrib_reg >= 0 && next.vertex_buffer_reg < 0) {
-		return Fail(error, "vertex attribute table requires a vertex buffer table");
+		return ShaderError::Fail(error, "vertex attribute table requires a vertex buffer table");
 	}
 	if (next.vertex_buffer_reg < 0) {
 		metadata = next;
 		return true;
 	}
 	if (static_cast<uint32_t>(next.vertex_buffer_reg) + 1u >= max_user_sgprs) {
-		return Fail(error, "vertex table pointer exceeds the user-SGPR domain");
+		return ShaderError::Fail(error, "vertex table pointer exceeds the user-SGPR domain");
 	}
 	if (next.vertex_attrib_reg < 0) {
 		metadata = next;
 		return true;
 	}
 	if (static_cast<uint32_t>(next.vertex_attrib_reg) + 1u >= max_user_sgprs) {
-		return Fail(error, "vertex table pointer exceeds the user-SGPR domain");
+		return ShaderError::Fail(error, "vertex table pointer exceeds the user-SGPR domain");
 	}
 	if (data.num_input_semantics == 0 ||
 	    data.num_input_semantics > ShaderVertexInputInfo::RES_MAX) {
-		return Fail(error, "vertex semantic count is outside the supported domain");
+		return ShaderError::Fail(error, "vertex semantic count is outside the supported domain");
 	}
 
 	const auto semantic_size =
 	    static_cast<uint64_t>(data.num_input_semantics) * sizeof(ShaderSemantic);
 	if (data.input_semantics == nullptr) {
-		return Fail(error, "missing vertex input semantics");
+		return ShaderError::Fail(error, "missing vertex input semantics");
 	}
 	std::memcpy(next.input_semantics.data(), data.input_semantics, semantic_size);
 	next.input_semantics_count = data.num_input_semantics;