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>

drivers/metal/SCsub

@@ -9,6 +9,7 @@ env_metal = env.Clone()
 
 thirdparty_obj = []
 
+thirdparty_spirv_headers_dir = "#thirdparty/spirv-headers/"
 thirdparty_dir = "#thirdparty/spirv-cross/"
 thirdparty_sources = [
     "spirv_cfg.cpp",
@@ -22,6 +23,7 @@ thirdparty_sources = [
 thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
 env_metal.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])
+env_metal.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "include/spirv/unified1"])
 
 # Must enable exceptions for SPIRV-Cross; otherwise, it will abort the process on errors.
 if "-fno-exceptions" in env_metal["CXXFLAGS"]:

drivers/vulkan/SCsub

@@ -6,6 +6,8 @@ Import("env")
 thirdparty_obj = []
 thirdparty_dir = "#thirdparty/vulkan"
 thirdparty_volk_dir = "#thirdparty/volk"
+thirdparty_spirv_headers_dir = "#thirdparty/spirv-headers"
+thirdparty_respirv_dir = "#thirdparty/re-spirv"
 
 # Use bundled Vulkan headers
 env.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])
@@ -50,6 +52,12 @@ elif env["platform"] == "macos" or env["platform"] == "ios":
 
 env_thirdparty_vma.add_source_files(thirdparty_obj, thirdparty_sources_vma)
 
+# Build re-spirv
+env_thirdparty_respirv = env.Clone()
+env_thirdparty_respirv.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "/include"])
+env_thirdparty_respirv.disable_warnings()
+thirdparty_sources_respirv = [thirdparty_respirv_dir + "/re-spirv.cpp"]
+env_thirdparty_respirv.add_source_files(thirdparty_obj, thirdparty_sources_respirv)
 
 env.drivers_sources += thirdparty_obj
 

drivers/vulkan/rendering_device_driver_vulkan.cpp

@@ -50,6 +50,27 @@
 
 #define PRINT_NATIVE_COMMANDS 0
 
+// Enable the use of re-spirv for optimizing shaders after applying specialization constants.
+#define RESPV_ENABLED 1
+
+// Only enable function inlining for re-spirv when dealing with a shader that uses specialization constants.
+#define RESPV_ONLY_INLINE_SHADERS_WITH_SPEC_CONSTANTS 1
+
+// Print additional information about every shader optimized with re-spirv.
+#define RESPV_VERBOSE 0
+
+// Disable dead code elimination when using re-spirv.
+#define RESPV_DONT_REMOVE_DEAD_CODE 0
+
+// Record numerous statistics about pipeline creation such as time and shader sizes. When combined with enabling
+// and disabling re-spirv, this can be used to measure its effects.
+#define RECORD_PIPELINE_STATISTICS 0
+
+#if RECORD_PIPELINE_STATISTICS
+#include "core/io/file_access.h"
+#define RECORD_PIPELINE_STATISTICS_PATH "./pipelines.csv"
+#endif
+
 /*****************/
 /**** GENERIC ****/
 /*****************/
@@ -1637,6 +1658,14 @@ Error RenderingDeviceDriverVulkan::initialize(uint32_t p_device_index, uint32_t
 
 	shader_container_format.set_debug_info_enabled(Engine::get_singleton()->is_generate_spirv_debug_info_enabled());
 
+#if RECORD_PIPELINE_STATISTICS
+	pipeline_statistics.file_access = FileAccess::open(RECORD_PIPELINE_STATISTICS_PATH, FileAccess::WRITE);
+	ERR_FAIL_NULL_V_MSG(pipeline_statistics.file_access, ERR_CANT_CREATE, "Unable to write pipeline statistics file.");
+
+	pipeline_statistics.file_access->store_csv_line({ "name", "hash", "stage", "spec", "glslang", "re-spirv", "time" });
+	pipeline_statistics.file_access->flush();
+#endif
+
 	return OK;
 }
 
@@ -3760,6 +3789,8 @@ static VkShaderStageFlagBits RD_STAGE_TO_VK_SHADER_STAGE_BITS[RDD::SHADER_STAGE_
 RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Ref<RenderingShaderContainer> &p_shader_container, const Vector<ImmutableSampler> &p_immutable_samplers) {
 	ShaderReflection shader_refl = p_shader_container->get_shader_reflection();
 	ShaderInfo shader_info;
+	shader_info.name = p_shader_container->shader_name.get_data();
+
 	for (uint32_t i = 0; i < SHADER_STAGE_MAX; i++) {
 		if (shader_refl.push_constant_stages.has_flag((ShaderStage)(1 << i))) {
 			shader_info.vk_push_constant_stages |= RD_STAGE_TO_VK_SHADER_STAGE_BITS[i];
@@ -3846,9 +3877,20 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
 	VkResult res;
 	String error_text;
 	Vector<uint8_t> decompressed_code;
-	Vector<uint8_t> decoded_spirv;
 	VkShaderModule vk_module;
-	for (int i = 0; i < shader_refl.stages_vector.size(); i++) {
+	PackedByteArray decoded_spirv;
+	const bool use_respv = RESPV_ENABLED && !shader_container_format.get_debug_info_enabled();
+	const bool store_respv = use_respv && !shader_refl.specialization_constants.is_empty();
+	const int64_t stage_count = shader_refl.stages_vector.size();
+	shader_info.vk_stages_create_info.reserve(stage_count);
+	shader_info.spirv_stage_bytes.reserve(stage_count);
+	shader_info.original_stage_size.reserve(stage_count);
+
+	if (store_respv) {
+		shader_info.respv_stage_shaders.reserve(stage_count);
+	}
+
+	for (int i = 0; i < stage_count; i++) {
 		const RenderingShaderContainer::Shader &shader = p_shader_container->shaders[i];
 		bool requires_decompression = (shader.code_decompressed_size > 0);
 		if (requires_decompression) {
@@ -3878,6 +3920,31 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
 			memcpy(decoded_spirv.ptrw(), smolv_input, decoded_spirv.size());
 		}
 
+		shader_info.original_stage_size.push_back(decoded_spirv.size());
+
+		if (use_respv) {
+			const bool inline_data = store_respv || !RESPV_ONLY_INLINE_SHADERS_WITH_SPEC_CONSTANTS;
+			respv::Shader respv_shader(decoded_spirv.ptr(), decoded_spirv.size(), inline_data);
+			if (store_respv) {
+				shader_info.respv_stage_shaders.push_back(respv_shader);
+			} else {
+				std::vector<uint8_t> respv_optimized_data;
+				if (respv::Optimizer::run(respv_shader, nullptr, 0, respv_optimized_data)) {
+#if RESPV_VERBOSE
+					print_line(vformat("re-spirv transformed the shader from %d bytes to %d bytes.", decoded_spirv.size(), respv_optimized_data.size()));
+#endif
+					decoded_spirv.resize(respv_optimized_data.size());
+					memcpy(decoded_spirv.ptrw(), respv_optimized_data.data(), respv_optimized_data.size());
+				} else {
+#if RESPV_VERBOSE
+					print_line("re-spirv failed to optimize the shader.");
+#endif
+				}
+			}
+		}
+
+		shader_info.spirv_stage_bytes.push_back(decoded_spirv);
+
 		VkShaderModuleCreateInfo shader_module_create_info = {};
 		shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
 		shader_module_create_info.codeSize = decoded_spirv.size();
@@ -5508,26 +5575,104 @@ RDD::PipelineID RenderingDeviceDriverVulkan::render_pipeline_create(
 			"Cannot create pipeline without shader module, please make sure shader modules are destroyed only after all associated pipelines are created.");
 	VkPipelineShaderStageCreateInfo *vk_pipeline_stages = ALLOCA_ARRAY(VkPipelineShaderStageCreateInfo, shader_info->vk_stages_create_info.size());
 
+	thread_local std::vector<uint8_t> respv_optimized_data;
+	thread_local LocalVector<respv::SpecConstant> respv_spec_constants;
+	thread_local LocalVector<VkShaderModule> respv_shader_modules;
+	thread_local LocalVector<VkSpecializationMapEntry> specialization_entries;
+
+#if RECORD_PIPELINE_STATISTICS
+	thread_local LocalVector<uint64_t> respv_run_time;
+	thread_local LocalVector<uint64_t> respv_size;
+	uint32_t stage_count = shader_info->vk_stages_create_info.size();
+	respv_run_time.clear();
+	respv_size.clear();
+	respv_run_time.resize_initialized(stage_count);
+	respv_size.resize_initialized(stage_count);
+#endif
+
+	respv_shader_modules.clear();
+	specialization_entries.clear();
+
 	for (uint32_t i = 0; i < shader_info->vk_stages_create_info.size(); i++) {
 		vk_pipeline_stages[i] = shader_info->vk_stages_create_info[i];
 
 		if (p_specialization_constants.size()) {
-			VkSpecializationMapEntry *specialization_map_entries = ALLOCA_ARRAY(VkSpecializationMapEntry, p_specialization_constants.size());
+			bool use_pipeline_spec_constants = true;
-			for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
+			if ((i < shader_info->respv_stage_shaders.size()) && !shader_info->respv_stage_shaders[i].empty()) {
-				specialization_map_entries[j] = {};
+#if RECORD_PIPELINE_STATISTICS
-				specialization_map_entries[j].constantID = p_specialization_constants[j].constant_id;
+				uint64_t respv_start_time = OS::get_singleton()->get_ticks_usec();
-				specialization_map_entries[j].offset = (const char *)&p_specialization_constants[j].int_value - (const char *)p_specialization_constants.ptr();
+#endif
-				specialization_map_entries[j].size = sizeof(uint32_t);
+				// Attempt to optimize the shader using re-spirv before relying on the driver.
+				respv_spec_constants.resize(p_specialization_constants.size());
+				for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
+					respv_spec_constants[j].specId = p_specialization_constants[j].constant_id;
+					respv_spec_constants[j].values.resize(1);
+					respv_spec_constants[j].values[0] = p_specialization_constants[j].int_value;
+				}
+
+				respv::Options respv_options;
+#if RESPV_DONT_REMOVE_DEAD_CODE
+				respv_options.removeDeadCode = false;
+#endif
+				if (respv::Optimizer::run(shader_info->respv_stage_shaders[i], respv_spec_constants.ptr(), respv_spec_constants.size(), respv_optimized_data, respv_options)) {
+#if RESPV_VERBOSE
+					String spec_constants;
+					for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
+						spec_constants += vformat("%d: %d", p_specialization_constants[j].constant_id, p_specialization_constants[j].int_value);
+						if (j < p_specialization_constants.size() - 1) {
+							spec_constants += ", ";
+						}
+					}
+
+					print_line(vformat("re-spirv transformed the shader from %d bytes to %d bytes with constants %s (%d).", shader_info->spirv_stage_bytes[i].size(), respv_optimized_data.size(), spec_constants, p_shader.id));
+#endif
+
+					// Create the shader module with the optimized output.
+					VkShaderModule shader_module = VK_NULL_HANDLE;
+					VkShaderModuleCreateInfo shader_module_create_info = {};
+					shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+					shader_module_create_info.pCode = (const uint32_t *)(respv_optimized_data.data());
+					shader_module_create_info.codeSize = respv_optimized_data.size();
+					VkResult err = vkCreateShaderModule(vk_device, &shader_module_create_info, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_SHADER_MODULE), &shader_module);
+					if (err == VK_SUCCESS) {
+						// Replace the module used in the creation info.
+						vk_pipeline_stages[i].module = shader_module;
+						respv_shader_modules.push_back(shader_module);
+						use_pipeline_spec_constants = false;
+					}
+
+#if RECORD_PIPELINE_STATISTICS
+					respv_run_time[i] = OS::get_singleton()->get_ticks_usec() - respv_start_time;
+					respv_size[i] = respv_optimized_data.size();
+#endif
+				} else {
+#if RESPV_VERBOSE
+					print_line("re-spirv failed to optimize the shader.");
+#endif
+				}
 			}
 
-			VkSpecializationInfo *specialization_info = ALLOCA_SINGLE(VkSpecializationInfo);
+			if (use_pipeline_spec_constants) {
-			*specialization_info = {};
+				// Use specialization constants through the driver.
-			specialization_info->dataSize = p_specialization_constants.size() * sizeof(PipelineSpecializationConstant);
+				if (specialization_entries.is_empty()) {
-			specialization_info->pData = p_specialization_constants.ptr();
+					specialization_entries.resize(p_specialization_constants.size());
-			specialization_info->mapEntryCount = p_specialization_constants.size();
+					for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
-			specialization_info->pMapEntries = specialization_map_entries;
+						specialization_entries[j] = {};
+						specialization_entries[j].constantID = p_specialization_constants[j].constant_id;
+						specialization_entries[j].offset = (const char *)&p_specialization_constants[j].int_value - (const char *)p_specialization_constants.ptr();
+						specialization_entries[j].size = sizeof(uint32_t);
+					}
+				}
 
-			vk_pipeline_stages[i].pSpecializationInfo = specialization_info;
+				VkSpecializationInfo *specialization_info = ALLOCA_SINGLE(VkSpecializationInfo);
+				*specialization_info = {};
+				specialization_info->dataSize = p_specialization_constants.size() * sizeof(PipelineSpecializationConstant);
+				specialization_info->pData = p_specialization_constants.ptr();
+				specialization_info->mapEntryCount = specialization_entries.size();
+				specialization_info->pMapEntries = specialization_entries.ptr();
+
+				vk_pipeline_stages[i].pSpecializationInfo = specialization_info;
+			}
 		}
 	}
 
@@ -5546,12 +5691,41 @@ RDD::PipelineID RenderingDeviceDriverVulkan::render_pipeline_create(
 	pipeline_create_info.renderPass = render_pass->vk_render_pass;
 	pipeline_create_info.subpass = p_render_subpass;
 
-	// ---
+#if RECORD_PIPELINE_STATISTICS
+	uint64_t pipeline_start_time = OS::get_singleton()->get_ticks_usec();
+#endif
 
 	VkPipeline vk_pipeline = VK_NULL_HANDLE;
 	VkResult err = vkCreateGraphicsPipelines(vk_device, pipelines_cache.vk_cache, 1, &pipeline_create_info, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_PIPELINE), &vk_pipeline);
 	ERR_FAIL_COND_V_MSG(err, PipelineID(), "vkCreateGraphicsPipelines failed with error " + itos(err) + ".");
 
+#if RECORD_PIPELINE_STATISTICS
+	{
+		MutexLock lock(pipeline_statistics.file_access_mutex);
+		uint64_t pipeline_creation_time = OS::get_singleton()->get_ticks_usec() - pipeline_start_time;
+		for (uint32_t i = 0; i < shader_info->vk_stages_create_info.size(); i++) {
+			PackedStringArray csv_array = {
+				shader_info->name,
+				String::num_uint64(hash_murmur3_buffer(shader_info->spirv_stage_bytes[i].ptr(), shader_info->spirv_stage_bytes[i].size())),
+				String::num_uint64(i),
+				String::num_uint64(respv_size[i] > 0),
+				String::num_uint64(shader_info->original_stage_size[i]),
+				String::num_uint64(respv_size[i] > 0 ? respv_size[i] : shader_info->spirv_stage_bytes[i].size()),
+				String::num_uint64(respv_run_time[i] + pipeline_creation_time)
+			};
+
+			pipeline_statistics.file_access->store_csv_line(csv_array);
+		}
+
+		pipeline_statistics.file_access->flush();
+	}
+#endif
+
+	// Destroy any modules created temporarily by re-spirv.
+	for (VkShaderModule vk_module : respv_shader_modules) {
+		vkDestroyShaderModule(vk_device, vk_module, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_SHADER_MODULE));
+	}
+
 	return PipelineID(vk_pipeline);
 }
 

drivers/vulkan/rendering_device_driver_vulkan.h

@@ -41,6 +41,7 @@
 #define _DEBUG
 #endif
 #endif
+#include "thirdparty/re-spirv/re-spirv.h"
 #include "thirdparty/vulkan/vk_mem_alloc.h"
 
 #include "drivers/vulkan/godot_vulkan.h"
@@ -156,6 +157,13 @@ class RenderingDeviceDriverVulkan : public RenderingDeviceDriver {
 
 	PendingFlushes pending_flushes;
 
+	struct PipelineStatistics {
+		Ref<FileAccess> file_access;
+		Mutex file_access_mutex;
+	};
+
+	PipelineStatistics pipeline_statistics;
+
 	void _register_requested_device_extension(const CharString &p_extension_name, bool p_required);
 	Error _initialize_device_extensions();
 	Error _check_device_features();
@@ -437,9 +445,13 @@ public:
 	/****************/
 private:
 	struct ShaderInfo {
+		String name;
 		VkShaderStageFlags vk_push_constant_stages = 0;
 		TightLocalVector<VkPipelineShaderStageCreateInfo> vk_stages_create_info;
 		TightLocalVector<VkDescriptorSetLayout> vk_descriptor_set_layouts;
+		TightLocalVector<respv::Shader> respv_stage_shaders;
+		TightLocalVector<Vector<uint8_t>> spirv_stage_bytes;
+		TightLocalVector<uint64_t> original_stage_size;
 		VkPipelineLayout vk_pipeline_layout = VK_NULL_HANDLE;
 	};
 

drivers/vulkan/rendering_shader_container_vulkan.cpp

@@ -108,6 +108,10 @@ void RenderingShaderContainerFormatVulkan::set_debug_info_enabled(bool p_debug_i
 	debug_info_enabled = p_debug_info_enabled;
 }
 
+bool RenderingShaderContainerFormatVulkan::get_debug_info_enabled() const {
+	return debug_info_enabled;
+}
+
 RenderingShaderContainerFormatVulkan::RenderingShaderContainerFormatVulkan() {}
 
 RenderingShaderContainerFormatVulkan::~RenderingShaderContainerFormatVulkan() {}

drivers/vulkan/rendering_shader_container_vulkan.h

@@ -62,6 +62,7 @@ public:
 	virtual ShaderLanguageVersion get_shader_language_version() const override;
 	virtual ShaderSpirvVersion get_shader_spirv_version() const override;
 	void set_debug_info_enabled(bool p_debug_info_enabled);
+	bool get_debug_info_enabled() const;
 	RenderingShaderContainerFormatVulkan();
 	virtual ~RenderingShaderContainerFormatVulkan();
 };

modules/glslang/SCsub

@@ -12,6 +12,7 @@ thirdparty_obj = []
 
 if env["builtin_glslang"]:
     thirdparty_dir = "#thirdparty/glslang/"
+    thirdparty_spirv_headers_dir = "#thirdparty/spirv-headers/"
     thirdparty_sources = [
         "glslang/GenericCodeGen/CodeGen.cpp",
         "glslang/GenericCodeGen/Link.cpp",
@@ -63,6 +64,7 @@ if env["builtin_glslang"]:
     thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
 
     env_glslang.Prepend(CPPPATH=[thirdparty_dir, "#thirdparty"])
+    env_glslang.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "include/spirv/unified1"])
 
     env_glslang.Append(CPPDEFINES=[("ENABLE_OPT", 0)])
 

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