Use re-spirv in the Vulkan driver to optimize shaders.

Includes contributions by Rémi to unify usage of SPIR-V Headers across the dependencies.

Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>

thirdparty/README.md

@@ -920,6 +920,19 @@ Files extracted from upstream source:
 - `License.txt`
 
 
+## re-spirv
+
+- Upstream: https://github.com/renderbag/re-spirv
+- Version: git (2f9be81bca5882ada1b6377d2ef8c0f7d8665171, 2025)
+- License: MIT
+
+Files extracted from upstream source:
+
+- `re-spirv.cpp`
+- `re-spirv.h`
+- `LICENSE`
+
+
 ## rvo2
 
 For 2D in `rvo2_2d` folder
@@ -997,6 +1010,16 @@ Versions of this SDK do not have to match the `vulkan` section, as this SDK is r
 to generate Metal source from Vulkan SPIR-V.
 
 
+## spirv-headers
+
+- Upstream: https://github.com/KhronosGroup/SPIRV-Headers
+- Version: vulkan-sdk-1.4.328.1 (01e0577914a75a2569c846778c2f93aa8e6feddd, 2025)
+
+Files extracted from upstream source:
+- `include/spirv/unified1` folder with only `spirv.h` and `spirv.hpp`
+- `LICENSE`
+
+
 ## spirv-reflect
 
 - Upstream: https://github.com/KhronosGroup/SPIRV-Reflect
@@ -1016,7 +1039,7 @@ Patches:
 
 - `0001-specialization-constants.patch` (GH-50325)
 - `0002-zero-size-for-sc-sized-arrays.patch` (GH-94985)
-
+- `0003-spirv-headers.patch` (GH-111452)
 
 ## swappy-frame-pacing
 

thirdparty/re-spirv/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 renderbag and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

thirdparty/re-spirv/re-spirv.h

@@ -0,0 +1,213 @@
+//
+// re-spirv
+//
+// Copyright (c) 2024 renderbag and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file for details.
+//
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace respv {
+    struct SpecConstant {
+        uint32_t specId = 0;
+        std::vector<uint32_t> values;
+
+        SpecConstant() {
+            // Empty constructor.
+        }
+
+        SpecConstant(uint32_t pSpecId, const std::vector<uint32_t> &pValues) {
+            specId = pSpecId;
+            values = pValues;
+        }
+    };
+
+    struct Instruction {
+        uint32_t wordIndex = UINT32_MAX;
+        uint32_t blockIndex = UINT32_MAX;
+
+        Instruction(uint32_t pWordIndex, uint32_t pBlockIndex) {
+            wordIndex = pWordIndex;
+            blockIndex = pBlockIndex;
+        }
+    };
+
+    struct Block {
+        uint32_t labelInstructionIndex = UINT32_MAX;
+        uint32_t terminatorInstructionIndex = UINT32_MAX;
+
+        Block() {
+            // Empty.
+        }
+
+        Block(uint32_t pLabelInstructionIndex, uint32_t pTerminatorInstructionIndex) {
+            labelInstructionIndex = pLabelInstructionIndex;
+            terminatorInstructionIndex = pTerminatorInstructionIndex;
+        }
+    };
+
+    struct Function {
+        uint32_t instructionIndex = UINT32_MAX;
+        uint32_t labelInstructionIndex = UINT32_MAX;
+
+        Function() {
+            // Empty.
+        }
+
+        Function(uint32_t pInstructionIndex, uint32_t pLabelInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+            labelInstructionIndex = pLabelInstructionIndex;
+        }
+    };
+
+    struct Result {
+        uint32_t instructionIndex = UINT32_MAX;
+
+        Result() {
+            // Empty.
+        }
+
+        Result(uint32_t pInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+        }
+    };
+
+    struct Specialization {
+        uint32_t constantInstructionIndex = UINT32_MAX;
+        uint32_t decorationInstructionIndex = UINT32_MAX;
+
+        Specialization() {
+            // Empty.
+        }
+
+        Specialization(uint32_t pConstantInstructionIndex, uint32_t pDecorationInstructionIndex) {
+            constantInstructionIndex = pConstantInstructionIndex;
+            decorationInstructionIndex = pDecorationInstructionIndex;
+        }
+    };
+
+    struct Decoration {
+        uint32_t instructionIndex = UINT32_MAX;
+
+        Decoration() {
+            // Empty.
+        }
+
+        Decoration(uint32_t pInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+        }
+    };
+
+    struct Variable {
+        uint32_t instructionIndex = UINT32_MAX;
+
+        Variable() {
+            // Empty.
+        }
+
+        Variable(uint32_t pInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+        }
+    };
+
+    struct AccessChain {
+        uint32_t instructionIndex = UINT32_MAX;
+
+        AccessChain() {
+            // Empty.
+        }
+
+        AccessChain(uint32_t pInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+        }
+    };
+
+    struct Phi {
+        uint32_t instructionIndex = UINT32_MAX;
+
+        Phi() {
+            // Empty.
+        }
+
+        Phi(uint32_t pInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+        }
+    };
+
+    struct LoopHeader {
+        uint32_t instructionIndex = UINT32_MAX;
+        uint32_t blockInstructionIndex = UINT32_MAX;
+
+        LoopHeader() {
+            // Empty.
+        }
+
+        LoopHeader(uint32_t pInstructionIndex, uint32_t pBlockInstructionIndex) {
+            instructionIndex = pInstructionIndex;
+            blockInstructionIndex = pBlockInstructionIndex;
+        }
+    };
+
+    struct ListNode {
+        uint32_t instructionIndex = UINT32_MAX;
+        uint32_t nextListIndex = UINT32_MAX;
+
+        ListNode() {
+            // Empty.
+        }
+
+        ListNode(uint32_t pInstructionIndex, uint32_t pNextListIndex) {
+            instructionIndex = pInstructionIndex;
+            nextListIndex = pNextListIndex;
+        }
+    };
+
+    struct Shader {
+        const uint32_t *extSpirvWords = nullptr;
+        size_t extSpirvWordCount = 0;
+        std::vector<uint32_t> inlinedSpirvWords;
+        std::vector<Instruction> instructions;
+        std::vector<uint32_t> instructionAdjacentListIndices;
+        std::vector<uint32_t> instructionInDegrees;
+        std::vector<uint32_t> instructionOutDegrees;
+        std::vector<uint32_t> instructionOrder;
+        std::vector<Block> blocks;
+        std::vector<uint32_t> blockPreOrderIndices;
+        std::vector<uint32_t> blockPostOrderIndices;
+        std::vector<Function> functions;
+        std::vector<uint32_t> variableOrder;
+        std::vector<Result> results;
+        std::vector<Specialization> specializations;
+        std::vector<Decoration> decorations;
+        std::vector<Phi> phis;
+        std::vector<LoopHeader> loopHeaders;
+        std::vector<ListNode> listNodes;
+        uint32_t defaultSwitchOpConstantInt = UINT32_MAX;
+
+        Shader();
+        
+        // Data is only copied if pInlineFunctions is true. An extra processing pass is required if inlining is enabled.
+        // This step is usually not required unless the shader compiler has disabled optimizations.
+        Shader(const void *pData, size_t pSize, bool pInlineFunctions);
+        void clear();
+        bool checkData(const void *pData, size_t pSize);
+        bool inlineData(const void *pData, size_t pSize);
+        bool parseData(const void *pData, size_t pSize);
+        bool parse(const void *pData, size_t pSize, bool pInlineFunctions);
+        bool process(const void *pData, size_t pSize);
+        bool sort(const void *pData, size_t pSize);
+        bool empty() const;
+    };
+
+    struct Options {
+        bool removeDeadCode = true;
+    };
+
+    struct Optimizer {
+        static bool run(const Shader &pShader, const SpecConstant *pNewSpecConstants, uint32_t pNewSpecConstantCount, std::vector<uint8_t> &pOptimizedData, Options pOptions = Options());
+    };
+};

thirdparty/spirv-headers/LICENSE

@@ -0,0 +1,26 @@
+Files: All files except for those called out below.
+Copyright (c) 2015-2024 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+   https://www.khronos.org/registry/
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

thirdparty/spirv-headers/include/spirv/unified1/spirv.hpp

@@ -638,6 +638,7 @@ enum Decoration {
     DecorationHostAccessINTEL = 6188,
     DecorationInitModeINTEL = 6190,
     DecorationImplementInRegisterMapINTEL = 6191,
+    DecorationConditionalINTEL = 6247,
     DecorationCacheControlLoadINTEL = 6442,
     DecorationCacheControlStoreINTEL = 6443,
     DecorationMax = 0x7fffffff,
@@ -1103,6 +1104,7 @@ enum Capability {
     CapabilityTextureBoxFilterQCOM = 4485,
     CapabilityTextureBlockMatchQCOM = 4486,
     CapabilityTileShadingQCOM = 4495,
+    CapabilityCooperativeMatrixConversionQCOM = 4496,
     CapabilityTextureBlockMatch2QCOM = 4498,
     CapabilityFloat16ImageAMD = 5008,
     CapabilityImageGatherBiasLodAMD = 5009,
@@ -1278,6 +1280,9 @@ enum Capability {
     CapabilitySubgroup2DBlockTransposeINTEL = 6230,
     CapabilitySubgroupMatrixMultiplyAccumulateINTEL = 6236,
     CapabilityTernaryBitwiseFunctionINTEL = 6241,
+    CapabilityUntypedVariableLengthArrayINTEL = 6243,
+    CapabilitySpecConditionalINTEL = 6245,
+    CapabilityFunctionVariantsINTEL = 6246,
     CapabilityGroupUniformArithmeticKHR = 6400,
     CapabilityTensorFloat32RoundingINTEL = 6425,
     CapabilityMaskedGatherScatterINTEL = 6427,
@@ -1972,6 +1977,7 @@ enum Op {
     OpGroupNonUniformRotateKHR = 4431,
     OpSubgroupReadInvocationKHR = 4432,
     OpExtInstWithForwardRefsKHR = 4433,
+    OpUntypedGroupAsyncCopyKHR = 4434,
     OpTraceRayKHR = 4445,
     OpExecuteCallableKHR = 4446,
     OpConvertUToAccelerationStructureKHR = 4447,
@@ -2008,10 +2014,14 @@ enum Op {
     OpImageBoxFilterQCOM = 4481,
     OpImageBlockMatchSSDQCOM = 4482,
     OpImageBlockMatchSADQCOM = 4483,
+    OpBitCastArrayQCOM = 4497,
     OpImageBlockMatchWindowSSDQCOM = 4500,
     OpImageBlockMatchWindowSADQCOM = 4501,
     OpImageBlockMatchGatherSSDQCOM = 4502,
     OpImageBlockMatchGatherSADQCOM = 4503,
+    OpCompositeConstructCoopMatQCOM = 4540,
+    OpCompositeExtractCoopMatQCOM = 4541,
+    OpExtractSubArrayQCOM = 4542,
     OpGroupIAddNonUniformAMD = 5000,
     OpGroupFAddNonUniformAMD = 5001,
     OpGroupFMinNonUniformAMD = 5002,
@@ -2093,6 +2103,7 @@ enum Op {
     OpTypeAccelerationStructureNV = 5341,
     OpExecuteCallableNV = 5344,
     OpRayQueryGetClusterIdNV = 5345,
+    OpRayQueryGetIntersectionClusterIdNV = 5345,
     OpHitObjectGetClusterIdNV = 5346,
     OpTypeCooperativeMatrixNV = 5358,
     OpCooperativeMatrixLoadNV = 5359,
@@ -2402,6 +2413,14 @@ enum Op {
     OpSubgroup2DBlockStoreINTEL = 6235,
     OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
     OpBitwiseFunctionINTEL = 6242,
+    OpUntypedVariableLengthArrayINTEL = 6244,
+    OpConditionalExtensionINTEL = 6248,
+    OpConditionalEntryPointINTEL = 6249,
+    OpConditionalCapabilityINTEL = 6250,
+    OpSpecConstantTargetINTEL = 6251,
+    OpSpecConstantArchitectureINTEL = 6252,
+    OpSpecConstantCapabilitiesINTEL = 6253,
+    OpConditionalCopyObjectINTEL = 6254,
     OpGroupIMulKHR = 6401,
     OpGroupFMulKHR = 6402,
     OpGroupBitwiseAndKHR = 6403,
@@ -2802,6 +2821,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
     case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
     case OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
+    case OpUntypedGroupAsyncCopyKHR: *hasResult = true; *hasResultType = true; break;
     case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
     case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
     case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
@@ -2832,10 +2852,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case OpBitCastArrayQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
     case OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case OpCompositeConstructCoopMatQCOM: *hasResult = true; *hasResultType = true; break;
+    case OpCompositeExtractCoopMatQCOM: *hasResult = true; *hasResultType = true; break;
+    case OpExtractSubArrayQCOM: *hasResult = true; *hasResultType = true; break;
     case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
     case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
     case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
@@ -2914,7 +2938,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
     case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
     case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionClusterIdNV: *hasResult = true; *hasResultType = true; break;
     case OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
     case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
     case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
@@ -3221,6 +3245,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break;
     case OpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break;
     case OpBitwiseFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpUntypedVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpConditionalExtensionINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpConditionalEntryPointINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpConditionalCapabilityINTEL: *hasResult = false; *hasResultType = false; break;
+    case OpSpecConstantTargetINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantArchitectureINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpSpecConstantCapabilitiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case OpConditionalCopyObjectINTEL: *hasResult = true; *hasResultType = true; break;
     case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
     case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
     case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
@@ -3761,6 +3793,7 @@ inline const char* DecorationToString(Decoration value) {
     case DecorationHostAccessINTEL: return "HostAccessINTEL";
     case DecorationInitModeINTEL: return "InitModeINTEL";
     case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL";
+    case DecorationConditionalINTEL: return "ConditionalINTEL";
     case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL";
     case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL";
     default: return "Unknown";
@@ -4051,6 +4084,7 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
     case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
     case CapabilityTileShadingQCOM: return "TileShadingQCOM";
+    case CapabilityCooperativeMatrixConversionQCOM: return "CooperativeMatrixConversionQCOM";
     case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
     case CapabilityFloat16ImageAMD: return "Float16ImageAMD";
     case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
@@ -4200,6 +4234,9 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilitySubgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL";
     case CapabilitySubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL";
     case CapabilityTernaryBitwiseFunctionINTEL: return "TernaryBitwiseFunctionINTEL";
+    case CapabilityUntypedVariableLengthArrayINTEL: return "UntypedVariableLengthArrayINTEL";
+    case CapabilitySpecConditionalINTEL: return "SpecConditionalINTEL";
+    case CapabilityFunctionVariantsINTEL: return "FunctionVariantsINTEL";
     case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
     case CapabilityTensorFloat32RoundingINTEL: return "TensorFloat32RoundingINTEL";
     case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
@@ -4775,6 +4812,7 @@ inline const char* OpToString(Op value) {
     case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
     case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR";
     case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR";
+    case OpUntypedGroupAsyncCopyKHR: return "OpUntypedGroupAsyncCopyKHR";
     case OpTraceRayKHR: return "OpTraceRayKHR";
     case OpExecuteCallableKHR: return "OpExecuteCallableKHR";
     case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
@@ -4805,10 +4843,14 @@ inline const char* OpToString(Op value) {
     case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
     case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
     case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
+    case OpBitCastArrayQCOM: return "OpBitCastArrayQCOM";
     case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
     case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
     case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
     case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
+    case OpCompositeConstructCoopMatQCOM: return "OpCompositeConstructCoopMatQCOM";
+    case OpCompositeExtractCoopMatQCOM: return "OpCompositeExtractCoopMatQCOM";
+    case OpExtractSubArrayQCOM: return "OpExtractSubArrayQCOM";
     case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD";
     case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD";
     case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD";
@@ -5194,6 +5236,14 @@ inline const char* OpToString(Op value) {
     case OpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL";
     case OpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL";
     case OpBitwiseFunctionINTEL: return "OpBitwiseFunctionINTEL";
+    case OpUntypedVariableLengthArrayINTEL: return "OpUntypedVariableLengthArrayINTEL";
+    case OpConditionalExtensionINTEL: return "OpConditionalExtensionINTEL";
+    case OpConditionalEntryPointINTEL: return "OpConditionalEntryPointINTEL";
+    case OpConditionalCapabilityINTEL: return "OpConditionalCapabilityINTEL";
+    case OpSpecConstantTargetINTEL: return "OpSpecConstantTargetINTEL";
+    case OpSpecConstantArchitectureINTEL: return "OpSpecConstantArchitectureINTEL";
+    case OpSpecConstantCapabilitiesINTEL: return "OpSpecConstantCapabilitiesINTEL";
+    case OpConditionalCopyObjectINTEL: return "OpConditionalCopyObjectINTEL";
     case OpGroupIMulKHR: return "OpGroupIMulKHR";
     case OpGroupFMulKHR: return "OpGroupFMulKHR";
     case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";

thirdparty/spirv-reflect/patches/0003-spirv-headers.patch

@@ -0,0 +1,12 @@
+diff --git a/thirdparty/spirv-reflect/spirv_reflect.h b/thirdparty/spirv-reflect/spirv_reflect.h
+index cf8cfe2183..8f281ec80f 100644
+--- a/thirdparty/spirv-reflect/spirv_reflect.h
++++ b/thirdparty/spirv-reflect/spirv_reflect.h
+@@ -34,7 +34,7 @@ VERSION HISTORY
+ #if defined(SPIRV_REFLECT_USE_SYSTEM_SPIRV_H)
+ #include <spirv/unified1/spirv.h>
+ #else
+-#include "./include/spirv/unified1/spirv.h"
++#include "../spirv-headers/include/spirv/unified1/spirv.h"
+ #endif
+ 

thirdparty/spirv-reflect/spirv_reflect.h

@@ -34,7 +34,7 @@ VERSION HISTORY
 #if defined(SPIRV_REFLECT_USE_SYSTEM_SPIRV_H)
 #include <spirv/unified1/spirv.h>
 #else
-#include "./include/spirv/unified1/spirv.h"
+#include "../spirv-headers/include/spirv/unified1/spirv.h"
 #endif