diff --git a/CMakeLists.txt b/CMakeLists.txt index b629c204..ff4cd6e1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -276,6 +276,7 @@ set(SOURCE_FILES MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameBuiltinShadowingFunctionsPass.cpp MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecomposeWorkgroupVec3Pass.cpp MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp + MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerDrawParametersPass.cpp MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PackDoubleVertexInputsPass.cpp MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/SplitArrayVertexInputsPass.cpp diff --git a/MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt b/MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt index 714f8d51..18da1c3b 100644 --- a/MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt +++ b/MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt @@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.14) add_executable( SpirvPassTest SpirvPassTest.cpp + DemoteFloat64Test.cpp ) target_include_directories(SpirvPassTest PRIVATE diff --git a/MobileGL/MG_Test/ShaderTranspiler/DemoteFloat64Test.cpp b/MobileGL/MG_Test/ShaderTranspiler/DemoteFloat64Test.cpp new file mode 100644 index 00000000..67dc8256 --- /dev/null +++ b/MobileGL/MG_Test/ShaderTranspiler/DemoteFloat64Test.cpp @@ -0,0 +1,486 @@ +// MobileGL - MobileGL/MG_Test/ShaderTranspiler/DemoteFloat64Test.cpp +// Copyright (c) 2025-2026 MobileGL-Dev +// Licensed under the GNU Lesser General Public License v3.0: +// https://www.gnu.org/licenses/gpl-3.0.txt +// https://www.gnu.org/licenses/lgpl-3.0.txt +// SPDX-License-Identifier: LGPL-3.0-only +// End of Source File Header + +#include + +#include +#include + +#include "Includes.h" +#include "Init.h" +#include +#include +#include + +#include + +using namespace MobileGL; +using MobileGL::MG_Util::ShaderTranspiler::ShaderCompiler; + +namespace { + // The test-side reference walker, deliberately independent of the production code: a bug in + // the pass must not be able to hide behind the same helper. Counts OpTypeFloat declarations of + // a given width and collects the Offset literal of every OpMemberDecorate, in module order. + constexpr Uint32 kSpirvHeaderWordCount = 5; + constexpr Uint32 kOpTypeFloat = 22; + constexpr Uint32 kOpName = 5; + constexpr Uint32 kOpMemberDecorate = 72; + constexpr Uint32 kOpFConvert = 115; + constexpr Uint32 kOpCapability = 17; + constexpr Uint32 kDecorationOffset = 35; + constexpr Uint32 kCapabilityFloat64 = 10; + + template + void ForEachInstruction(const Vector& spirv, Visitor&& visit) { + for (SizeT i = kSpirvHeaderWordCount; i < spirv.size();) { + const Uint32 wordCount = spirv[i] >> 16; + const Uint32 opcode = spirv[i] & 0xFFFFu; + if (wordCount == 0 || i + wordCount > spirv.size()) break; + visit(opcode, &spirv[i], wordCount); + i += wordCount; + } + } + + Uint32 CountFloatTypesOfWidth(const Vector& spirv, Uint32 width) { + Uint32 count = 0; + ForEachInstruction(spirv, [&](Uint32 opcode, const Uint32* words, Uint32 wordCount) { + if (opcode == kOpTypeFloat && wordCount >= 3 && words[2] == width) ++count; + }); + return count; + } + + Uint32 CountFConverts(const Vector& spirv) { + Uint32 count = 0; + ForEachInstruction(spirv, [&](Uint32 opcode, const Uint32*, Uint32) { + if (opcode == kOpFConvert) ++count; + }); + return count; + } + + Bool DeclaresFloat64Capability(const Vector& spirv) { + Bool found = false; + ForEachInstruction(spirv, [&](Uint32 opcode, const Uint32* words, Uint32 wordCount) { + if (opcode == kOpCapability && wordCount >= 2 && words[1] == kCapabilityFloat64) found = true; + }); + return found; + } + + // Byte offset of every member of the struct named `blockName`, in member order. + Vector CollectOffsetsOf(const Vector& spirv, const String& blockName) { + Uint32 structId = 0; + ForEachInstruction(spirv, [&](Uint32 opcode, const Uint32* words, Uint32 wordCount) { + if (opcode != kOpName || wordCount < 3 || structId != 0) return; + const char* text = reinterpret_cast(&words[2]); + const SizeT maxBytes = (wordCount - 2) * sizeof(Uint32); + if (std::strncmp(text, blockName.c_str(), maxBytes) == 0) structId = words[1]; + }); + if (structId == 0) return {}; + + std::map offsetByMember; + ForEachInstruction(spirv, [&](Uint32 opcode, const Uint32* words, Uint32 wordCount) { + if (opcode == kOpMemberDecorate && wordCount >= 5 && words[1] == structId && + words[3] == kDecorationOffset) { + offsetByMember[words[2]] = words[4]; + } + }); + + Vector offsets; + for (const auto& [member, offset] : offsetByMember) offsets.push_back(offset); + return offsets; + } + + // Everything the production pipeline does to a source before the pass sees it. + Vector CompileToSpirv(GLenum stage, const String& source) { + using namespace MG_Util::ShaderTranspiler; + ShaderAttrib shaderAttrib{.shaderType = stage, .sourceStr = source}; + auto shaderResult = ShaderCompiler::CompileShader(shaderAttrib); + EXPECT_TRUE(shaderResult) << (shaderResult ? String{} : shaderResult.error().log); + if (!shaderResult) return {}; + + ProgramAttrib programAttrib{.shaders = {shaderResult.value()}}; + auto programResult = ShaderCompiler::LinkProgram(programAttrib); + EXPECT_TRUE(programResult) << (programResult ? String{} : programResult.error().log); + if (!programResult) return {}; + + ProgramBinaryAttrib binaryAttrib{.shaderTypes = {stage}, .program = *programResult.value()}; + auto binaryResult = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib); + EXPECT_TRUE(binaryResult) << (binaryResult ? String{} : binaryResult.error().log); + if (!binaryResult || binaryResult->empty()) return {}; + return binaryResult->front(); + } + + String Disassemble(const Vector& spirv) { + spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1); + String text; + tools.Disassemble(spirv, &text); + return text; + } + + // A vertex shader that exercises every shape the pass has to handle at once: a block with + // double / dvec2 / dvec3 / dvec4 / dmat4 members between two floats (so a shifted offset would + // be visible), a default-block double uniform, a 64-bit vertex input, a double-typed array, an + // implicit float->double conversion and an explicit double->float one. + const char* kWideVertexSource = R"(#version 460 core +layout(std140, binding = 0) uniform Blk { + float a; + double d; + dvec2 v2; + dvec3 v3; + dvec4 v4; + dmat4 m4; + double arr[3]; + float z; +}; +layout(location = 0) uniform double uScale; +layout(location = 0) in dvec3 inPos; +layout(location = 1) in vec3 inNormal; +layout(location = 0) out float vOut; +void main() { + double s = d * uScale + a; + dvec3 p = inPos * v3 + v2.xyx + v4.xyz + dvec3(m4[0].xyz); + s += p.x + p.y + p.z + arr[0] + arr[1] + arr[2] + z + 0.5lf; + vOut = float(s) + inNormal.x; + gl_Position = vec4(float(s)); +} +)"; +} // namespace + +class DemoteFloat64Test : public ::testing::Test { +protected: + void SetUp() override { + MobileGL::Initialize(); + ShaderCompiler::SetSpirvValidationEnabled(true); + m_validationFailuresAtStart = ShaderCompiler::SpirvValidationFailureCount(); + } + + void TearDown() override { + // The wrapper validates its OUTPUT on every run, so this covers every demotion the test + // performed without any of them having to say so. + EXPECT_EQ(ShaderCompiler::SpirvValidationFailureCount(), m_validationFailuresAtStart) + << "the demoted module did not survive spirv-val"; + } + + Uint64 m_validationFailuresAtStart = 0; +}; + +TEST_F(DemoteFloat64Test, DemotesEveryWidthAndDropsTheCapability) { + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, kWideVertexSource); + ASSERT_FALSE(input.empty()); + ASSERT_EQ(CountFloatTypesOfWidth(input, 64), 1u) << Disassemble(input); + ASSERT_TRUE(DeclaresFloat64Capability(input)); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + EXPECT_EQ(CountFloatTypesOfWidth(output, 64), 0u) << Disassemble(output); + // And exactly one 32-bit float type survives: the merge has to happen, or spirv-val rejects + // the second declaration. + EXPECT_EQ(CountFloatTypesOfWidth(output, 32), 1u) << Disassemble(output); + EXPECT_FALSE(DeclaresFloat64Capability(output)); +} + +TEST_F(DemoteFloat64Test, RederivesTheStd140LayoutOfADemotedUniformBlock) { + const String source = R"(#version 460 core +layout(std140, binding = 0) uniform Blk { + float a; + double d; + dvec2 v2; + dvec3 v3; + dvec4 v4; + dmat4 m4; + double arr[3]; + float z; +}; +layout(location = 0) out float vOut; +void main() { + vOut = float(d + v2.x + v3.y + v4.z + m4[2].w + arr[1] + a + z); + gl_Position = vec4(vOut); +} +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + // What glslang laid out for the 64-bit members, which is what an application computing + // std140 by hand would also get. + EXPECT_EQ(CollectOffsetsOf(input, "Blk"), (Vector{0, 8, 16, 32, 64, 96, 224, 272})) + << Disassemble(input); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + // std140 for the demoted members: float at 4, vec2 at 8, vec3 at 16 (aligned like a vec4), + // vec4 at 32, mat4 at 48 with a 16-byte column stride, the array at 112 with the std140 + // 16-byte element stride, and the trailing float at 160. This is what SPIRV-Cross has to be + // able to re-derive for GLSL ES, which has no member layout(offset=) to fall back on. + EXPECT_EQ(CollectOffsetsOf(output, "Blk"), (Vector{0, 4, 8, 16, 32, 48, 112, 160})) + << Disassemble(output); + const String text = Disassemble(output); + EXPECT_NE(text.find("MatrixStride 16"), String::npos) << text; + EXPECT_NE(text.find("ArrayStride 16"), String::npos) << text; +} + +TEST_F(DemoteFloat64Test, RederivesTheStd430LayoutOfADemotedStorageBlock) { + const String source = R"(#version 460 core +layout(std430, binding = 0) buffer Ssbo { + double head; + dvec4 wide; + double tail[4]; +}; +layout(location = 0) out float vOut; +void main() { + vOut = float(head + wide.w + tail[3]); + gl_Position = vec4(vOut); +} +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + EXPECT_EQ(CollectOffsetsOf(input, "Ssbo"), (Vector{0, 32, 64})) << Disassemble(input); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + // std430, so the array packs at its element size rather than being rounded to 16: float at 0, + // vec4 at 16, float[4] at 32 with a 4-byte stride. A storage block must NOT come out std140, + // which is the whole reason the packing is chosen per storage class. + EXPECT_EQ(CollectOffsetsOf(output, "Ssbo"), (Vector{0, 16, 32})) << Disassemble(output); + EXPECT_NE(Disassemble(output).find("ArrayStride 4"), String::npos) << Disassemble(output); +} + +TEST_F(DemoteFloat64Test, LeavesTheLayoutOfABlockWithoutDoublesAlone) { + const String source = R"(#version 460 core +layout(std140, binding = 0) uniform Blk { + float a; + vec3 v3; + mat4 m4; +}; +layout(std140, binding = 1) uniform Wide { + float w; + double d; +}; +layout(location = 0) out float vOut; +void main() { + vOut = float(a + v3.y + m4[1].z + float(d) + w); + gl_Position = vec4(vOut); +} +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + const Vector before = CollectOffsetsOf(input, "Blk"); + ASSERT_FALSE(before.empty()); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + // Only the block that actually narrowed is re-laid-out. Touching the other one would be + // churn at best, and a disagreement with glslang's own layout at worst. + EXPECT_EQ(CollectOffsetsOf(output, "Blk"), before) << Disassemble(output); + EXPECT_EQ(CollectOffsetsOf(output, "Wide"), (Vector{0, 4})) << Disassemble(output); +} + +TEST_F(DemoteFloat64Test, FoldsTheConversionsThatBecameIdentities) { + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, kWideVertexSource); + ASSERT_FALSE(input.empty()); + ASSERT_GT(CountFConverts(input), 0u) << "the fixture no longer converts between the two widths"; + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + // SPIR-V requires the two component widths of an OpFConvert to differ, so every one of them + // has to be gone: both sides are 32 bits now. + EXPECT_EQ(CountFConverts(output), 0u) << Disassemble(output); +} + +TEST_F(DemoteFloat64Test, NarrowsDoubleConstantsToTheirFloatValue) { + const String source = R"(#version 460 core +layout(location = 0) out float outValue; +void main() { + double d = 0.5lf; + outValue = float(d * 0.25lf); + gl_Position = vec4(0.0); +} +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + + // A 64-bit literal is two words wide and a 32-bit one is a single word, so a constant left + // unconverted is not merely imprecise - it is an unparseable instruction. Disassembling both + // values proves the re-encode produced the right number, not just the right width. + const String text = Disassemble(output); + EXPECT_NE(text.find("OpConstant %float 0.5"), String::npos) << text; + EXPECT_NE(text.find("OpConstant %float 0.25"), String::npos) << text; +} + +TEST_F(DemoteFloat64Test, LeavesAModuleWithoutDoublesByteIdentical) { + const String source = R"(#version 460 core +layout(location = 0) in vec4 inPos; +void main() { gl_Position = inPos; } +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + // The pass reports SuccessWithoutChange here, and SPIRV-Tools asserts (in assert-enabled + // builds) that such a run round-trips byte-identically. + EXPECT_EQ(output, input); +} + +TEST_F(DemoteFloat64Test, DeclinesAModuleThatBitcastsAcrossTheWidthBoundary) { + // packDouble2x32 is defined only for a 64-bit result: there is no 32-bit answer to give, and + // narrowing one side of the surrounding OpBitcast alone produces a module spirv-val rejects. + // The contract is that such a module comes back untouched rather than broken. + const String source = R"(#version 460 core +#extension GL_ARB_gpu_shader_fp64 : require +layout(location = 0) uniform uvec2 uPacked; +layout(location = 0) out float outValue; +void main() { + double d = packDouble2x32(uPacked); + outValue = float(d); + gl_Position = vec4(0.0); +} +)"; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, source); + ASSERT_FALSE(input.empty()); + ASSERT_EQ(CountFloatTypesOfWidth(input, 64), 1u) << Disassemble(input); + + Vector output; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(input, output)); + EXPECT_EQ(output, input) << Disassemble(output); + EXPECT_TRUE(ShaderCompiler::ModuleDeclaresFloat64(output)); +} + +TEST_F(DemoteFloat64Test, ModuleDeclaresFloat64AnswersBothWays) { + const Vector wide = CompileToSpirv(GL_VERTEX_SHADER, kWideVertexSource); + ASSERT_FALSE(wide.empty()); + EXPECT_TRUE(ShaderCompiler::ModuleDeclaresFloat64(wide)); + + Vector demoted; + ASSERT_TRUE(ShaderCompiler::DemoteFloat64ToFloat32(wide, demoted)); + EXPECT_FALSE(ShaderCompiler::ModuleDeclaresFloat64(demoted)); + + EXPECT_FALSE(ShaderCompiler::ModuleDeclaresFloat64({})); +} + +TEST_F(DemoteFloat64Test, TheSharedChainDemotesToo) { + // Production never calls the pass on its own: it reaches it through the one chain every + // module goes through at link, on both backends. + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, kWideVertexSource); + ASSERT_FALSE(input.empty()); + + Vector output; + ASSERT_TRUE(ShaderCompiler::SanitizeAndOptimizeBinary(input, output)); + EXPECT_FALSE(ShaderCompiler::ModuleDeclaresFloat64(output)) << Disassemble(output); +} + +// The payoff on the Espryt path: SPIRV-Cross throws "FP64 not supported in ES profile" for every +// one of these before demotion, so the program simply could not be transpiled at all. +class DemoteFloat64EsslTest : public DemoteFloat64Test, public ::testing::WithParamInterface {}; + +INSTANTIATE_TEST_SUITE_P( + Shapes, DemoteFloat64EsslTest, + ::testing::Values( + // A double that never reaches an interface: locals and literals only. + R"(#version 460 core +layout(location = 0) out float vOut; +void main() { + double s = 0.5lf; + for (int i = 0; i < 3; ++i) s = s * 1.5lf + 0.25lf; + vOut = float(s); + gl_Position = vec4(float(s)); +} +)", + // A default-block double uniform: the glUniform*d path, and the block MobileGL lays out + // itself. + R"(#version 460 core +layout(location = 0) uniform double uScale; +layout(location = 1) uniform dvec3 uOffset; +layout(location = 2) uniform dmat4 uTransform; +layout(location = 0) out float vOut; +void main() { + dvec3 p = uOffset * uScale + dvec3(uTransform[1].xyz); + vOut = float(p.x + p.y + p.z); + gl_Position = vec4(float(p.x)); +} +)", + // An application-declared std140 block whose members are 64-bit. + R"(#version 460 core +layout(std140, binding = 0) uniform Blk { + float a; + double d; + dvec2 v2; + dvec3 v3; + dvec4 v4; + dmat4 m4; + double arr[3]; + float z; +}; +layout(location = 0) out float vOut; +void main() { + double s = d + v2.x + v3.y + v4.z + m4[2].w + arr[1] + a + z; + vOut = float(s); + gl_Position = vec4(float(s)); +} +)", + // A 64-bit vertex input, which is what glVertexAttribLFormat feeds. + R"(#version 460 core +layout(location = 0) in dvec3 inPos; +layout(location = 2) in double inWeight; +layout(location = 0) out float vOut; +void main() { + vOut = float(inPos.x + inPos.y + inPos.z + inWeight); + gl_Position = vec4(vOut); +} +)", + // An std430 storage block, whose double members pack differently again. + R"(#version 460 core +layout(std430, binding = 0) buffer Ssbo { + double head; + dvec4 wide; + double tail[4]; +}; +layout(location = 0) out float vOut; +void main() { + double s = head + wide.w + tail[3]; + vOut = float(s); + gl_Position = vec4(float(s)); +} +)")); + +TEST_P(DemoteFloat64EsslTest, TheDemotedModuleCanBeEmittedAsEssl) { + using namespace MG_Util::ShaderTranspiler; + const Vector input = CompileToSpirv(GL_VERTEX_SHADER, GetParam()); + ASSERT_FALSE(input.empty()); + + Vector output; + ASSERT_TRUE(ShaderCompiler::SanitizeAndOptimizeBinary(input, output)); + + SpvcSession session(output, SessionUsageBit::Transpile); + spvc_compiler_options options; + ASSERT_EQ(session.CreateOptions(&options), SPVC_SUCCESS); + spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, 320); + spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_TRUE); + spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS, SPVC_FALSE); + ASSERT_EQ(session.SetOptions(options), SPVC_SUCCESS); + + auto essl = ShaderCompiler::DecompileShader(session); + ASSERT_TRUE(essl) << essl.error().log; + EXPECT_NE(essl->find("#version 320 es"), String::npos) << *essl; + // ESSL has no 64-bit float spelling at all, so any of these in the output is SPIRV-Cross + // having emitted something no ES driver will compile. + EXPECT_EQ(essl->find("double"), String::npos) << *essl; + EXPECT_EQ(essl->find("dvec"), String::npos) << *essl; + EXPECT_EQ(essl->find("dmat"), String::npos) << *essl; +} + +TEST_F(DemoteFloat64Test, RejectsGarbageInput) { + const Vector notSpirv{0xdeadbeefu, 0u, 0u, 0u, 0u}; + Vector output; + EXPECT_FALSE(ShaderCompiler::DemoteFloat64ToFloat32(notSpirv, output)); +} diff --git a/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp b/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp index 8244b0b2..69349a38 100644 --- a/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp +++ b/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp @@ -18,6 +18,7 @@ #include "SpirvPasses/RenameBuiltinShadowingFunctionsPass.h" #include "SpirvPasses/DecomposeWorkgroupVec3Pass.h" #include "SpirvPasses/DecoratePositionInvariantPass.h" +#include "SpirvPasses/DemoteFloat64Pass.h" #include "SpirvPasses/LowerDrawParametersPass.h" #include "SpirvPasses/PackDoubleVertexInputsPass.h" #include "SpirvPasses/SplitArrayVertexInputsPass.h" @@ -578,6 +579,37 @@ namespace MobileGL { return false; } + Bool ShaderCompiler::ModuleDeclaresFloat64(const Vector& spirv) { + if (spirv.empty()) { + // Same reasoning as ModuleDeclaresBufferTextureSampler: a stage that produced + // no SPIR-V is not a verdict about 64-bit floats, and parsing it would push a + // spurious diagnostic through the message consumer. + return false; + } + std::unique_ptr context = spvtools::BuildModule( + SPV_ENV_VULKAN_1_1, MakeSpirvMessageConsumer("ModuleDeclaresFloat64"), spirv.data(), + spirv.size()); + if (!context) { + return false; + } + for (const spvtools::opt::Instruction& type : context->types_values()) { + if (type.opcode() == spv::Op::OpTypeFloat && type.NumInOperands() >= 1 && + type.GetSingleWordInOperand(0) == 64) { + return true; + } + } + return false; + } + + bool ShaderCompiler::DemoteFloat64ToFloat32(const Vector& inputBinary, + Vector& outputBinary) { + using namespace spvtools; + Optimizer optimizer(SPV_ENV_VULKAN_1_1); + optimizer.RegisterPass(DemoteFloat64Pass::CreateDemoteFloat64Pass()); + + return RunOptimizerChecked("DemoteFloat64ToFloat32", optimizer, inputBinary, outputBinary); + } + bool ShaderCompiler::SanitizeAndOptimizeBinary(const Vector& inputBinary, Vector& outputBinary) { using namespace spvtools; @@ -616,6 +648,17 @@ namespace MobileGL { RenameBuiltinShadowingFunctionsPass::CreateRenameBuiltinShadowingFunctionsPass()); optimizer.RegisterPass(EliminateFloatEqualsZeroPass::CreateEliminateFloatEqualsZeroPass()); optimizer.RegisterPass(DecomposeWorkgroupVec3Pass::CreateDecomposeWorkgroupVec3Pass()); + // No mobile GPU has 64-bit floats: Adreno and Mali both report shaderFloat64 == + // VK_FALSE, and ESSL has no fp64 type for SPIRV-Cross to emit. Demoting here - in + // the one chain every module goes through, on both backends, at link - is what + // makes `double` compile at all, and makes it behave the SAME everywhere, which + // matters because the GL frontend's uniform storage cannot be per-backend: the + // glUniform*d shadow narrows to float unconditionally to match this. Runs last so + // no earlier pass ever has to reason about a width it will not see in the output; + // in particular it runs before the backends' PackDoubleVertexInputsPass, whose + // OpBitcast this one would otherwise decline on. Costs one types_values() walk on + // the overwhelming majority of modules, which declare no 64-bit float at all. + optimizer.RegisterPass(DemoteFloat64Pass::CreateDemoteFloat64Pass()); return RunOptimizerChecked("SanitizeAndOptimizeBinary", optimizer, inputBinary, outputBinary); diff --git a/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h b/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h index 41ff3461..5340dfd2 100644 --- a/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h +++ b/MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h @@ -100,6 +100,12 @@ namespace MobileGL { // reinterpretation paths (for example, R32F storage accessed as r32ui). static bool UseUnformattedFloatStorageImagesForVulkan( const Vector& inputBinary, Vector& outputBinary); + // Rewrites every 64-bit float in the module to a 32-bit one, preserving every + // block offset and stride exactly (see DemoteFloat64Pass). Already part of + // SanitizeAndOptimizeBinary, which is where production reaches it; exposed + // separately so a test can drive the demotion on its own. + static bool DemoteFloat64ToFloat32(const Vector& inputBinary, + Vector& outputBinary); static Result DecompileShader(SpvcSession& session); // Parses one trivial shader in each configuration the production path can @@ -159,6 +165,12 @@ namespace MobileGL { // check exists so that failure can be reported as the missing capability it is, // naming the shader, rather than as a driver info log nobody sees. static Bool ModuleDeclaresBufferTextureSampler(const Vector& spirv); + + // True when the module still declares a 64-bit float type. After + // SanitizeAndOptimizeBinary that can only mean DemoteFloat64Pass declined the + // module (see its header for the two operations that make it decline), which is + // what the backends report: no mobile driver can build such a module. + static Bool ModuleDeclaresFloat64(const Vector& spirv); }; } // namespace ShaderTranspiler } // namespace MG_Util diff --git a/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp b/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp new file mode 100644 index 00000000..a2b5292b --- /dev/null +++ b/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp @@ -0,0 +1,547 @@ +// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp +// Copyright (c) 2025-2026 MobileGL-Dev +// Licensed under the GNU Lesser General Public License v3.0: +// https://www.gnu.org/licenses/gpl-3.0.txt +// https://www.gnu.org/licenses/lgpl-3.0.txt +// SPDX-License-Identifier: LGPL-3.0-only +// End of Source File Header + +#include "DemoteFloat64Pass.h" + +#include "spirv.hpp" +#include "source/latest_version_glsl_std_450_header.h" +#include "source/opt/def_use_manager.h" +#include "source/opt/instruction.h" +#include "source/opt/ir_context.h" +#include "source/opt/module.h" +#include "source/util/make_unique.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace MobileGL { + namespace MG_Util { + namespace ShaderTranspiler { + namespace { + using spvtools::opt::IRContext; + using spvtools::opt::Instruction; + using spvtools::opt::Operand; + + constexpr Uint32 kFloat64Width = 64; + constexpr Uint32 kFloat32Width = 32; + + // OpTypeFloat . SPIR-V 1.6 added an optional FP Encoding operand after + // it; the width stays operand 0 either way, and an encoded (non-IEEE) float is not + // something glslang can emit for `double`, so it is left alone by the width guard. + Bool IsFloatTypeOfWidth(const Instruction& type, Uint32 width) { + return type.opcode() == spv::Op::OpTypeFloat && type.NumInOperands() >= 1 && + type.GetSingleWordInOperand(0) == width; + } + + // Exactly the types spirv-val forbids a second declaration of. Aggregates - arrays + // and structs - are excluded on purpose: the spec permits duplicates of those, and + // merging them would take one of the two OpNames and one of the two ArrayStride / + // Offset decoration sets with it. + Bool IsDuplicableType(spv::Op opcode) { + switch (opcode) { + case spv::Op::OpTypeFloat: + case spv::Op::OpTypeVector: + case spv::Op::OpTypeMatrix: + case spv::Op::OpTypePointer: + case spv::Op::OpTypeFunction: return true; + default: return false; + } + } + + Uint32 RoundUp(Uint32 value, Uint32 alignment) { + if (alignment == 0) return value; + return (value + alignment - 1) / alignment * alignment; + } + + // Re-derives the std140 / std430 layout of a block whose members have just become + // 32 bits wide, and writes it back as Offset / ArrayStride / MatrixStride. + // + // Why the layout is recomputed rather than preserved. Preserving it - leaving each + // member at the byte offset glslang picked for the 64-bit type and letting the + // freed 4 bytes become padding - keeps the application's byte layout intact and is + // the obvious first choice, but it does not survive contact with the Espryt path: + // SPIRV-Cross has to print an ESSL block, GLSL ES has no member `layout(offset=)` + // (no ARB_enhanced_layouts), so it refuses any block whose declared offsets are not + // exactly what std140 or std430 computes - "Buffer block cannot be expressed as any + // of std430, std140, scalar". Every shader with a double in a block would fail to + // transpile at all, which is the case this whole demotion exists to fix. Padding + // members back in cannot rescue it either: a dmat4 member carries MatrixStride 32 + // and std140 demands 16 for the demoted mat4, and no amount of padding BETWEEN + // members changes a stride INSIDE one. + // + // What recomputing costs: a block laid out for 64-bit members changes its + // driver-visible byte layout, so an application that hard-codes std140 offsets + // computed for doubles addresses the wrong bytes. Applications that query their + // offsets are unaffected, and MobileGL's own default-uniform block is unaffected by + // construction - the frontend builds its uniform routing by reflecting THIS module + // (ProgramSpirvTask::BuildGlobalUboRouting), so glUniform*d writes wherever the + // demoted shader reads. + class BlockRelayout { + public: + BlockRelayout(IRContext* irContext, Bool std140) + : m_irContext(irContext), m_std140(std140) {} + + // Size and alignment of `typeId`, applying every stride decoration it implies + // on the way down. Zero size means "not a type this layout knows how to + // describe"; the caller then leaves the block alone rather than guessing. + struct Extent { + Uint32 size = 0; + Uint32 alignment = 0; + }; + + Extent Measure(Uint32 typeId) { + const auto memo = m_extents.find(typeId); + if (memo != m_extents.end()) return memo->second; + + const Extent extent = MeasureUncached(typeId); + m_extents.emplace(typeId, extent); + return extent; + } + + private: + Extent MeasureUncached(Uint32 typeId) { + const Instruction* type = m_irContext->get_def_use_mgr()->GetDef(typeId); + if (type == nullptr) return {}; + + switch (type->opcode()) { + case spv::Op::OpTypeInt: + case spv::Op::OpTypeFloat: { + const Uint32 bytes = type->GetSingleWordInOperand(0) / 8; + return {bytes, bytes}; + } + case spv::Op::OpTypeBool: return {4, 4}; + case spv::Op::OpTypeVector: { + const Extent component = Measure(type->GetSingleWordInOperand(0)); + if (component.size == 0) return {}; + const Uint32 count = type->GetSingleWordInOperand(1); + // A three-component vector aligns like a four-component one. + return {component.size * count, + component.alignment * (count == 3 ? 4 : count)}; + } + case spv::Op::OpTypeMatrix: { + const Extent column = Measure(type->GetSingleWordInOperand(0)); + if (column.size == 0) return {}; + const Uint32 stride = MatrixOrArrayStride(column.alignment); + return {stride * type->GetSingleWordInOperand(1), stride}; + } + case spv::Op::OpTypeArray: + case spv::Op::OpTypeRuntimeArray: { + const Extent element = Measure(type->GetSingleWordInOperand(0)); + if (element.size == 0) return {}; + const Uint32 alignment = MatrixOrArrayStride(element.alignment); + const Uint32 stride = RoundUp(element.size, alignment); + SetTypeDecoration(typeId, spv::Decoration::ArrayStride, stride); + if (type->opcode() == spv::Op::OpTypeRuntimeArray) { + // An unsized array contributes its stride and nothing more; the + // block's size is whatever the application bound. + return {stride, alignment}; + } + return {stride * ArrayLength(type->GetSingleWordInOperand(1)), alignment}; + } + case spv::Op::OpTypeStruct: return MeasureStruct(*type); + default: return {}; + } + } + + Extent MeasureStruct(const Instruction& structType) { + Uint32 cursor = 0; + Uint32 alignment = m_std140 ? 16u : 1u; + for (Uint32 member = 0; member < structType.NumInOperands(); ++member) { + const Uint32 memberTypeId = structType.GetSingleWordInOperand(member); + const Extent extent = Measure(memberTypeId); + if (extent.size == 0) return {}; + + const Uint32 offset = RoundUp(cursor, extent.alignment); + SetMemberDecoration(structType.result_id(), member, spv::Decoration::Offset, offset); + // A matrix member carries the stride between its columns on the MEMBER, + // not on the type, so it has to be (re)stated here - including for a + // matrix reached through an array. + const Instruction* memberType = + m_irContext->get_def_use_mgr()->GetDef(PeelArrays(memberTypeId)); + if (memberType != nullptr && memberType->opcode() == spv::Op::OpTypeMatrix) { + const Extent column = Measure(memberType->GetSingleWordInOperand(0)); + SetMemberDecoration(structType.result_id(), member, + spv::Decoration::MatrixStride, + MatrixOrArrayStride(column.alignment)); + } + + cursor = offset + extent.size; + alignment = std::max(alignment, extent.alignment); + } + return {RoundUp(cursor, alignment), alignment}; + } + + // std140 rounds every array and matrix stride up to a four-component vector. + Uint32 MatrixOrArrayStride(Uint32 elementAlignment) const { + return m_std140 ? RoundUp(elementAlignment, 16) : elementAlignment; + } + + Uint32 PeelArrays(Uint32 typeId) const { + const Instruction* type = m_irContext->get_def_use_mgr()->GetDef(typeId); + while (type != nullptr && (type->opcode() == spv::Op::OpTypeArray || + type->opcode() == spv::Op::OpTypeRuntimeArray)) { + type = m_irContext->get_def_use_mgr()->GetDef(type->GetSingleWordInOperand(0)); + } + return type != nullptr ? type->result_id() : 0; + } + + Uint32 ArrayLength(Uint32 lengthConstantId) const { + const Instruction* length = m_irContext->get_def_use_mgr()->GetDef(lengthConstantId); + if (length == nullptr || length->opcode() != spv::Op::OpConstant || + length->NumInOperands() < 1) { + return 1; + } + return length->GetSingleWordInOperand(0); + } + + void SetTypeDecoration(Uint32 targetId, spv::Decoration decoration, Uint32 value) { + for (Instruction& annotation : m_irContext->annotations()) { + if (annotation.opcode() != spv::Op::OpDecorate) continue; + if (annotation.GetSingleWordInOperand(0) != targetId) continue; + if (static_cast(annotation.GetSingleWordInOperand(1)) != decoration) { + continue; + } + annotation.SetInOperand(2, {value}); + return; + } + } + + void SetMemberDecoration(Uint32 structId, Uint32 member, spv::Decoration decoration, + Uint32 value) { + for (Instruction& annotation : m_irContext->annotations()) { + if (annotation.opcode() != spv::Op::OpMemberDecorate) continue; + if (annotation.GetSingleWordInOperand(0) != structId) continue; + if (annotation.GetSingleWordInOperand(1) != member) continue; + if (static_cast(annotation.GetSingleWordInOperand(2)) != decoration) { + continue; + } + annotation.SetInOperand(3, {value}); + return; + } + } + + IRContext* m_irContext = nullptr; + Bool m_std140 = true; + std::unordered_map m_extents; + }; + } // namespace + + spvtools::opt::Pass::Status DemoteFloat64Pass::Process() { + auto* irContext = context(); + auto* defUseMgr = irContext->get_def_use_mgr(); + + // --- 1. the leaf types ------------------------------------------------------- + std::vector float64Types; + for (Instruction& type : irContext->types_values()) { + if (IsFloatTypeOfWidth(type, kFloat64Width)) { + float64Types.push_back(&type); + } + } + if (float64Types.empty()) return Status::SuccessWithoutChange; + + std::unordered_set float64TypeIds; + for (const Instruction* type : float64Types) { + float64TypeIds.insert(type->result_id()); + } + + // Every type a *value* can have that is 64-bit float underneath: the scalar itself + // plus the vectors and matrices built from it. The types-and-values section is in + // declaration order and SPIR-V forbids a type from forward-referencing another, so + // one forward walk is already the complete transitive closure. Aggregates and + // pointers are deliberately not included: no operand of the instructions checked + // below is ever an aggregate or a pointer. + std::unordered_set float64ValueTypeIds = float64TypeIds; + for (Instruction& type : irContext->types_values()) { + if (type.opcode() != spv::Op::OpTypeVector && type.opcode() != spv::Op::OpTypeMatrix) { + continue; + } + if (float64ValueTypeIds.count(type.GetSingleWordInOperand(0)) != 0) { + float64ValueTypeIds.insert(type.result_id()); + } + } + + // Every type that has a 64-bit float anywhere underneath it, which is exactly the + // set of blocks whose layout has to be re-derived once the leaves narrow. Computed + // now, before the rewrite makes a demoted float indistinguishable from one that was + // always 32 bits; the same single forward walk is a complete closure. + std::unordered_set wideTypeIds = float64TypeIds; + for (Instruction& type : irContext->types_values()) { + const auto contains = [&](Uint32 operand) { + return wideTypeIds.count(type.GetSingleWordInOperand(operand)) != 0; + }; + switch (type.opcode()) { + case spv::Op::OpTypeVector: + case spv::Op::OpTypeMatrix: + case spv::Op::OpTypeArray: + case spv::Op::OpTypeRuntimeArray: + if (contains(0)) wideTypeIds.insert(type.result_id()); + break; + case spv::Op::OpTypePointer: + if (contains(1)) wideTypeIds.insert(type.result_id()); + break; + case spv::Op::OpTypeStruct: + for (Uint32 member = 0; member < type.NumInOperands(); ++member) { + if (contains(member)) { + wideTypeIds.insert(type.result_id()); + break; + } + } + break; + default: break; + } + } + + const auto valueIsFloat64 = [&](Uint32 id) { + const Instruction* def = defUseMgr->GetDef(id); + return def != nullptr && float64ValueTypeIds.count(def->type_id()) != 0; + }; + + // --- 2. decline before touching anything ------------------------------------ + // These are the operations that mean "the 64 bits themselves", not "a wide float". + // Narrowing one side of them produces a module spirv-val rejects, and rebuilding + // the value would mean emulating fp64 in software. Bail out with the module + // byte-identical instead; the caller still has its "module declares Float64" + // diagnostic for it. + Uint32 glslStd450SetId = 0; + for (const Instruction& import : irContext->ext_inst_imports()) { + if (import.GetInOperand(0).AsString() == "GLSL.std.450") { + glslStd450SetId = import.result_id(); + break; + } + } + + const char* declineReason = nullptr; + irContext->module()->ForEachInst( + [&](Instruction* inst) { + if (declineReason != nullptr) return; + switch (inst->opcode()) { + case spv::Op::OpBitcast: { + // "Total bit width of Result Type and Operand must match" - true + // today, false the moment one of the two sides halves. + const Bool resultIs64 = float64ValueTypeIds.count(inst->type_id()) != 0; + const Bool operandIs64 = valueIsFloat64(inst->GetSingleWordInOperand(0)); + if (resultIs64 != operandIs64) { + declineReason = "an OpBitcast across the 64-bit boundary " + "(doubleBitsToUint64 / uint64BitsToDouble / " + "packDouble2x32)"; + } + break; + } + case spv::Op::OpExtInst: { + if (glslStd450SetId == 0 || + inst->GetSingleWordInOperand(0) != glslStd450SetId) { + break; + } + const Uint32 extOpcode = inst->GetSingleWordInOperand(1); + if (extOpcode == GLSLstd450PackDouble2x32 || + extOpcode == GLSLstd450UnpackDouble2x32) { + declineReason = "GLSL.std.450 PackDouble2x32 / UnpackDouble2x32, " + "which are defined only for a 64-bit float"; + } + break; + } + default: break; + } + }, + /*run_on_debug_line_insts=*/false); + + if (declineReason != nullptr) { + MGLOG_D("DemoteFloat64Pass: declined - the module uses %s; its 64-bit floats are " + "left in place", + declineReason); + return Status::SuccessWithoutChange; + } + + // --- 3. re-encode the literals ---------------------------------------------- + // A 64-bit float constant carries two literal words and a 32-bit one carries a + // single word, so the value has to be narrowed before the type changes underneath + // it - afterwards there is no way left to tell how wide the literal was meant to + // be. Composite constants hold s, not literals, and need nothing. + for (Instruction& value : irContext->types_values()) { + if (value.opcode() != spv::Op::OpConstant && value.opcode() != spv::Op::OpSpecConstant) { + continue; + } + if (float64TypeIds.count(value.type_id()) == 0) continue; + if (value.NumInOperands() < 1) continue; + const Operand& literal = value.GetInOperand(0); + if (literal.words.size() != 2) continue; + + const Uint64 bits = + (static_cast(literal.words[1]) << 32) | static_cast(literal.words[0]); + double wide = 0.0; + std::memcpy(&wide, &bits, sizeof(wide)); + // Deliberately the ordinary narrowing conversion: a magnitude no float can + // hold becomes an infinity, which is the same answer the demoted arithmetic + // around it would produce. + const float narrow = static_cast(wide); + Uint32 narrowedBits = 0; + std::memcpy(&narrowedBits, &narrow, sizeof(narrowedBits)); + + Operand narrowedLiteral = literal; + narrowedLiteral.words = {narrowedBits}; + value.SetInOperands({std::move(narrowedLiteral)}); + } + + // --- 4. the demotion itself -------------------------------------------------- + // In place, so every composite type, every pointer, every struct member offset and + // every debug name that referred to the 64-bit type keeps referring to the same + // . This is the whole reason the pass does not build parallel types. + for (Instruction* type : float64Types) { + type->SetInOperand(0, {kFloat32Width}); + } + // The cached analysis::Type objects were built against the old widths. + irContext->InvalidateAnalyses(IRContext::kAnalysisTypes); + + // --- 5. the conversions that just became identities -------------------------- + // `float(someDouble)` and `double(someFloat)` are both OpFConvert, and SPIR-V + // requires the two component widths to differ. Both sides are 32 bits now, so each + // one is replaced by its operand. Walking in module order means a chain of them + // resolves in a single sweep: by the time the second is reached its operand has + // already been rewritten to the ultimate source. + const auto componentWidth = [&](Uint32 typeId) -> Uint32 { + const Instruction* def = defUseMgr->GetDef(typeId); + if (def == nullptr) return 0; + if (def->opcode() == spv::Op::OpTypeVector) { + def = defUseMgr->GetDef(def->GetSingleWordInOperand(0)); + } + if (def == nullptr || def->opcode() != spv::Op::OpTypeFloat) return 0; + return def->GetSingleWordInOperand(0); + }; + + std::vector identityConversions; + irContext->module()->ForEachInst( + [&](Instruction* inst) { + if (inst->opcode() != spv::Op::OpFConvert) return; + const Instruction* operandDef = defUseMgr->GetDef(inst->GetSingleWordInOperand(0)); + if (operandDef == nullptr) return; + const Uint32 resultWidth = componentWidth(inst->type_id()); + if (resultWidth == 0 || resultWidth != componentWidth(operandDef->type_id())) { + return; + } + identityConversions.push_back(inst); + }, + /*run_on_debug_line_insts=*/false); + + for (Instruction* conversion : identityConversions) { + irContext->ReplaceAllUsesWith(conversion->result_id(), + conversion->GetSingleWordInOperand(0)); + irContext->KillInst(conversion); + } + + // --- 6. the capability ------------------------------------------------------- + std::vector deadCapabilities; + for (Instruction& capability : irContext->capabilities()) { + if (static_cast(capability.GetSingleWordInOperand(0)) == + spv::Capability::Float64) { + deadCapabilities.push_back(&capability); + } + } + for (Instruction* capability : deadCapabilities) { + irContext->KillInst(capability); + } + + // --- 7. merge what the rewrite made into a duplicate ------------------------- + // `double` and `float` are now the same declaration, and so is every vector, + // matrix, pointer and function type spelled in terms of them. Walking the section + // in declaration order and replacing each duplicate the moment it is found means + // the later types are already canonical by the time they are keyed: SPIR-V forbids + // a type from forward-referencing another, so every operand of the instruction + // being looked at has been through this loop already. + std::map, Uint32> keptTypeByShape; + for (Instruction* type = &*irContext->types_values_begin(); type != nullptr;) { + Instruction* next = type->NextNode(); + if (!IsDuplicableType(type->opcode())) { + type = next; + continue; + } + + std::vector shape{static_cast(type->opcode())}; + for (Uint32 i = 0; i < type->NumInOperands(); ++i) { + const Operand& operand = type->GetInOperand(i); + shape.insert(shape.end(), operand.words.begin(), operand.words.end()); + } + + const auto kept = keptTypeByShape.find(shape); + if (kept == keptTypeByShape.end()) { + keptTypeByShape.emplace(std::move(shape), type->result_id()); + type = next; + continue; + } + + irContext->KillNamesAndDecorates(type->result_id()); + irContext->ReplaceAllUsesWith(type->result_id(), kept->second); + irContext->KillInst(type); + type = next; + } + + // --- 8. re-derive the layout of every block that held a 64-bit float ----------- + // See BlockRelayout for why this is a recomputation and not a preservation. Only + // blocks that actually narrowed are touched: relaying out an untouched block would + // be pure churn, and would risk disagreeing with glslang over a layout that was + // already correct. + for (Instruction& variable : irContext->types_values()) { + if (variable.opcode() != spv::Op::OpVariable) continue; + const auto storageClass = + static_cast(variable.GetSingleWordInOperand(0)); + if (storageClass != spv::StorageClass::Uniform && + storageClass != spv::StorageClass::StorageBuffer && + storageClass != spv::StorageClass::PushConstant) { + continue; + } + const Instruction* pointerType = defUseMgr->GetDef(variable.type_id()); + if (pointerType == nullptr) continue; + + // An arrayed block (`uniform Blk { ... } blocks[4];`) is a pointer to an array + // of the struct; the layout lives on the struct either way. + const Instruction* blockType = defUseMgr->GetDef(pointerType->GetSingleWordInOperand(1)); + while (blockType != nullptr && (blockType->opcode() == spv::Op::OpTypeArray || + blockType->opcode() == spv::Op::OpTypeRuntimeArray)) { + blockType = defUseMgr->GetDef(blockType->GetSingleWordInOperand(0)); + } + if (blockType == nullptr || blockType->opcode() != spv::Op::OpTypeStruct) continue; + if (wideTypeIds.count(blockType->result_id()) == 0) continue; + + // A storage block packs std430, a uniform block std140. Before SPIR-V 1.3 a + // storage block was a Uniform-storage variable whose struct carried + // BufferBlock, so the decoration decides rather than the storage class alone. + Bool isStorageBlock = storageClass == spv::StorageClass::StorageBuffer; + for (const Instruction& annotation : irContext->annotations()) { + if (annotation.opcode() != spv::Op::OpDecorate) continue; + if (annotation.GetSingleWordInOperand(0) != blockType->result_id()) continue; + if (static_cast(annotation.GetSingleWordInOperand(1)) == + spv::Decoration::BufferBlock) { + isStorageBlock = true; + } + } + + BlockRelayout relayout(irContext, /*std140=*/!isStorageBlock); + if (relayout.Measure(blockType->result_id()).size == 0) { + // A member shape the layout rules here do not describe. Leaving the block + // at its 64-bit offsets keeps the module valid for Vulkan; SPIRV-Cross will + // decline it for ESSL, which is the same outcome as before the demotion. + MGLOG_D("DemoteFloat64Pass: block %%%u contains a member this pass cannot lay " + "out; its 64-bit offsets are left in place", + blockType->result_id()); + } + } + + irContext->InvalidateAnalysesExceptFor(IRContext::kAnalysisNone); + return Status::SuccessWithChange; + } + + spvtools::Optimizer::PassToken DemoteFloat64Pass::CreateDemoteFloat64Pass() { + return spvtools::Optimizer::PassToken(MakeUnique()); + } + } // namespace ShaderTranspiler + } // namespace MG_Util +} // namespace MobileGL diff --git a/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.h b/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.h new file mode 100644 index 00000000..73e6d822 --- /dev/null +++ b/MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.h @@ -0,0 +1,84 @@ +// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.h +// Copyright (c) 2025-2026 MobileGL-Dev +// Licensed under the GNU Lesser General Public License v3.0: +// https://www.gnu.org/licenses/gpl-3.0.txt +// https://www.gnu.org/licenses/lgpl-3.0.txt +// SPDX-License-Identifier: LGPL-3.0-only +// End of Source File Header + +#pragma once +#include "source/opt/pass.h" +#include "spirv-tools/optimizer.hpp" + +#include + +namespace MobileGL { + namespace MG_Util { + namespace ShaderTranspiler { + // Rewrites every 64-bit float in the module to a 32-bit one: `OpTypeFloat 64` becomes + // `OpTypeFloat 32` in place, so every vector, matrix, array, struct, pointer and + // function type that named it keeps its and every decoration attached to it, and + // only the meaning of the leaf type changes. The double literals are re-encoded, the + // now-width-preserving OpFConvert pairs collapse to their operand, and the Float64 + // capability goes away. + // + // Why demote at all: no mobile GPU has it. Adreno and Mali both report + // VkPhysicalDeviceFeatures::shaderFloat64 == VK_FALSE (the Magma POST has a row for it), + // so a module declaring Float64 cannot become a pipeline there; and ESSL has no 64-bit + // float type at all, so SPIRV-Cross throws "FP64 not supported in ES profile" and the + // Espryt path never even reaches the driver. Demotion is what makes `double` in an + // application's GLSL compile and run everywhere, at fp32 precision. + // + // BLOCK LAYOUT IS RE-DERIVED, NOT PRESERVED, and that was not the first choice - see + // BlockRelayout in the .cpp for the measurement that forced it. Preserving the 64-bit + // offsets (float + 4 bytes of padding in each slot) keeps the application's byte layout + // intact and is what a Vulkan-only implementation would do, but GLSL ES has no member + // `layout(offset=)`, so SPIRV-Cross recomputes std140/std430 from the declared types + // and refuses any block whose stated offsets disagree - "Buffer block cannot be + // expressed as any of std430, std140, scalar". Every shader with a double in a block + // would then fail to transpile for Espryt at all, which is the case this demotion + // exists to fix. Nor can padding members rescue it: a dmat4 member carries + // MatrixStride 32 and std140 requires 16 for the demoted mat4, and padding BETWEEN + // members cannot change a stride INSIDE one. + // + // What re-deriving costs, stated plainly: a block that held 64-bit members changes its + // driver-visible byte layout, so an application that hard-codes std140 offsets it + // computed for doubles addresses the wrong bytes. Applications that query their offsets + // are unaffected. MobileGL's own default-uniform block is unaffected by construction: + // the frontend builds its uniform routing by reflecting the module this pass produced + // (ProgramSpirvTask::BuildGlobalUboRouting), so glUniform*d - which narrows to float + // for the same reason - writes exactly where the demoted shader reads. Blocks with no + // 64-bit member anywhere are never touched. + // + // Declines (leaves the module byte-identical, so the caller's existing "this module + // still declares Float64" failure path reports it) when the module contains an + // operation whose validity depends on the operand really being 64 bits wide: + // - OpBitcast across the boundary - packDouble2x32 / doubleBitsToUint64 and friends, + // where SPIR-V requires both sides to have the same total bit width; + // - GLSL.std.450 PackDouble2x32 / UnpackDouble2x32, which are defined only for a + // 64-bit float result/operand. + // + // ORDERING: must run before PackDoubleVertexInputsPass, which introduces exactly the + // OpBitcast this pass declines on. After demotion no 64-bit vertex input is left, so + // that pass becomes a no-op rather than a conflict. + // + // The in-place rewrite creates duplicate type declarations by construction - a module + // that had both `double` and `float` ends up with two `OpTypeFloat 32`, and spirv-val + // rejects that ("Duplicate non-aggregate type declarations are not allowed") - so the + // pass merges them itself afterwards. Deliberately NOT by registering spvtools' + // RemoveDuplicates alongside it: that pass also merges structurally identical STRUCTS + // and calls KillNamesAndDecorates on the loser, which would silently delete the OpName + // of one of two distinct-but-identically-shaped interface blocks - and OpName is how + // MobileGL resolves block and varying names. Only the non-aggregate types spirv-val + // actually forbids duplicates of are merged here; arrays and structs are left alone, + // which also keeps a `double[]`'s ArrayStride from being merged into a `float[]`'s. + class DemoteFloat64Pass : public spvtools::opt::Pass { + public: + const char* name() const override { return "mobilegl-demote-float64"; } + Status Process() override; + + static spvtools::Optimizer::PassToken CreateDemoteFloat64Pass(); + }; + } // namespace ShaderTranspiler + } // namespace MG_Util +} // namespace MobileGL