Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-12-07 05:39:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #111452 from DarioSamo/re-spirv

Browse source 
Use re-spirv in the Vulkan driver to optimize shaders.
This commit is contained in:
Thaddeus Crews 2025-12-02 11:52:10 -06:00
commit 666bcb2056
No known key found for this signature in database
GPG key ID: 8C6E5FEB5FC03CCC
18 changed files with 9022 additions and 7724 deletions
Download patch file Download diff file Expand all files Collapse all files

2
drivers/metal/SCsub
View file

@ -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"]:

8
drivers/vulkan/SCsub
View file

@ -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

206
drivers/vulkan/rendering_device_driver_vulkan.cpp
View file

@ -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());
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
specialization_map_entries[j] = {};
specialization_map_entries[j].constantID = p_specialization_constants[j].constant_id;
specialization_map_entries[j].offset = (const char *)&p_specialization_constants[j].int_value - (const char *)p_specialization_constants.ptr();
specialization_map_entries[j].size = sizeof(uint32_t);
bool use_pipeline_spec_constants = true;
if ((i < shader_info->respv_stage_shaders.size()) && !shader_info->respv_stage_shaders[i].empty()) {
#if RECORD_PIPELINE_STATISTICS
uint64_t respv_start_time = OS::get_singleton()->get_ticks_usec();
#endif
// 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);
*specialization_info = {};
specialization_info->dataSize = p_specialization_constants.size() * sizeof(PipelineSpecializationConstant);
specialization_info->pData = p_specialization_constants.ptr();
specialization_info->mapEntryCount = p_specialization_constants.size();
specialization_info->pMapEntries = specialization_map_entries;
if (use_pipeline_spec_constants) {
// Use specialization constants through the driver.
if (specialization_entries.is_empty()) {
specialization_entries.resize(p_specialization_constants.size());
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
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);
}

12
drivers/vulkan/rendering_device_driver_vulkan.h
View file

@ -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;
};

4
drivers/vulkan/rendering_shader_container_vulkan.cpp
View file

@ -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() {}

1
drivers/vulkan/rendering_shader_container_vulkan.h
View file

@ -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();
};

2
modules/glslang/SCsub
View file

@ -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)])

25
thirdparty/README.md vendored
View file

@ -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

2815
thirdparty/glslang/SPIRV/spirv.hpp vendored
View file

File diff suppressed because it is too large Load diff

21
thirdparty/re-spirv/LICENSE vendored Normal file
View file

@ -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.

3183
thirdparty/re-spirv/re-spirv.cpp vendored Normal file
View file

File diff suppressed because it is too large Load diff

213
thirdparty/re-spirv/re-spirv.h vendored Normal file
View file

@ -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());
};
};

26
thirdparty/spirv-headers/LICENSE vendored Normal file
View file

@ -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.

5272
thirdparty/spirv-headers/include/spirv/unified1/spirv.h vendored Normal file
View file

File diff suppressed because it is too large Load diff

52
thirdparty/spirv-cross/spirv.hpp → thirdparty/spirv-headers/include/spirv/unified1/spirv.hpp vendored
View file

@ -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";

4890
thirdparty/spirv-reflect/include/spirv/unified1/spirv.h vendored
View file

File diff suppressed because it is too large Load diff

12
thirdparty/spirv-reflect/patches/0003-spirv-headers.patch vendored Normal file
View file

@ -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

2
thirdparty/spirv-reflect/spirv_reflect.h vendored
View file

@ -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