From 39ae9e7ec5db40b9d857559e3b4b22dc12ef6fd77b85fd5f4c6fcf5982a5c17e Mon Sep 17 00:00:00 2001 From: Jan Engelhardt Date: Tue, 25 Jun 2024 23:56:54 +0000 Subject: [PATCH 1/3] - Add v283-to-2acb319.patch OBS-URL: https://build.opensuse.org/package/show/X11:Wayland/spirv-headers?expand=0&rev=100 --- .gitattributes | 23 + .gitignore | 1 + spirv-headers.changes | 371 ++ spirv-headers.spec | 68 + v283-to-2acb319.patch | 6739 +++++++++++++++++++++++++++++++++++++ vulkan-sdk-1.3.283.tar.gz | 3 + 6 files changed, 7205 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 spirv-headers.changes create mode 100644 spirv-headers.spec create mode 100644 v283-to-2acb319.patch create mode 100644 vulkan-sdk-1.3.283.tar.gz diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/spirv-headers.changes b/spirv-headers.changes new file mode 100644 index 0000000..dfd78f8 --- /dev/null +++ b/spirv-headers.changes @@ -0,0 +1,371 @@ +------------------------------------------------------------------- +Tue Jun 25 23:56:15 UTC 2024 - Jan Engelhardt + +- Add v283-to-2acb319.patch + +------------------------------------------------------------------- +Thu May 16 11:38:08 UTC 2024 - Jan Engelhardt + +- Update to release SDK-1.3.283.0 + * Update bit reservations for loop control and memory operands + +------------------------------------------------------------------- +Fri Apr 12 17:11:55 UTC 2024 - Jan Engelhardt + +- Update to release SDK-1.3.280.0 [This is equal to + 1.3.275.0-19-g8b246ff that openSUSE already has had] +- Delete v275-to-8b246ff.patch (merged) + +------------------------------------------------------------------- +Sun Mar 10 09:30:51 UTC 2024 - Jan Engelhardt + +- Add v275-to-8b246ff.patch +- Update to snapshot vulkan-sdk-1.3.275.0-19-g8b246ff + * Upstream tokens for SPV_INTEL_masked_gather_scatter + * Publish the header for the vulkan-shader-profiler embedded + reflection + * Add SPV_KHR_maximal_reconvergence, SPV_KHR_float_controls2 + * Support SPV_KHR_quad_control (with fixed line endings) + * Add SPV_QCOM_image_processing2, SPV_NV_shader_atomic_fp16_vector, + SPV_NV_raw_access_chains + * Headers support for SPV_INTEL_maximum_registers extension + +------------------------------------------------------------------- +Fri Jan 19 11:33:40 UTC 2024 - Jan Engelhardt + +- Update to release SDK-1.3.275.0 + * ClspvReflection non-sematic: add + NormalizedSamplerMaskPushConstant + * Headers support for new FPGAMemoryAttributesINTEL + * Fix SPV_KHR_workgroup_memory_explicit_layout implicit + declaration + * Change token IDs for global_variable_fpga_decorations and + global_variable_host_access + * Update SPV_INTEL_long_composites tokens + * Add Type-Declaration for extended types + * Headers support for FPGAClusterAttributesV2INTEL + +------------------------------------------------------------------- +Fri Oct 27 04:00:58 UTC 2023 - Jan Engelhardt + +- Update to release SDK-1.3.268.0 + * Add SPV_AMDX_shader_enqueue + * Add SPV_INTEL_cache_controls extension support + * Remove Kernel from ConstantSampler enum values + * Remove additional version "1.0" from SecondaryViewportRelativeNV + * Add headers for SPV_NV_displacement_micromap + * Add LiteralFloat to operand_kinds + +------------------------------------------------------------------- +Tue Aug 22 09:47:59 UTC 2023 - Jan Engelhardt + +- Update to release SDK-1.3.261.0 + * Header files changes to support SPV_INTEL_fp_max_error spec + extension + * Make the generated operators for masks constexpr + * Add definitions for SVP_EXT_image_raw10_raw12, + SPV_KHR_cooperative_matrix + * Remove capabilities on cooperative matrix enums to align with + specification + * Revert "Add support for fp_max_error extension" + +------------------------------------------------------------------- +Tue May 30 21:59:05 UTC 2023 - Jan Engelhardt + +- Update to release SDK-1.3.250.0 + * Add SPV_EXT_shader_tile_image. + * Add back version field for new enumerants and operands, but + set to None. + * SPV_KHR_ray_tracing_position_fetch support. + +------------------------------------------------------------------- +Wed Mar 29 18:40:35 UTC 2023 - Jan Engelhardt + +- Update to release 1.6.1/SDK-1.3.243.0 + * Added SPRIV_INTEL_argument_interfaces, RegisterMapInterfaceINTEL, + SPV_QCOM_image_processing + * Added support for SPV_INTEL_fpga_latency_control extension + * Headers support for SPV_INTEL_bfloat16_conversion + +------------------------------------------------------------------- +Sun Jan 29 13:02:53 UTC 2023 - Jan Engelhardt + +- Update to release 1.6.1/SDK-1.3.239.0 + * Add support for StreamingInterfaceINTEL in headers + * C++ headers: Define & and ~ bitwise operators for mask enums + * Add operator^ + * Make operands to Kernel added in v5 optional + +------------------------------------------------------------------- +Wed Jan 18 22:31:42 UTC 2023 - Jan Engelhardt + +- Update to snapshot 1.6.1+sdk236+git7.d13b522 + * Update ClspvReflection non-semantic instruction set + +------------------------------------------------------------------- +Fri Dec 23 07:59:56 UTC 2022 - Jan Engelhardt + +- Update to release 1.6.1+sdk236 (1d31a10) + * Add SPV_INTEL_fpga_invocation_pipelining_attributes, + SPV_INTEL_fpga_dsp_control, SPV_INTEL_runtime_aligned + * Add headers for SPV_NV_shader_invocation_reorder + +------------------------------------------------------------------- +Mon Oct 24 19:43:45 UTC 2022 - Jan Engelhardt + +- Update to 1.6.1+sdk231 (85a1ed2) + * Implement headers definitions for SPV_EXT_mesh_shader + * Add definitions for SPV_ARM_core_builtins + * Something with VK_EXT_opacity_micromap + * Add support for texel buffers to clspv non-semantic + instruction set + +------------------------------------------------------------------- +Mon Aug 22 23:25:58 UTC 2022 - Jan Engelhardt + +- Update to 1.6.1+sdk224+git2.0bcc624 + * Updated clspv reflection non-semantic instruction set + * Resolved missing update of spirv.bf + +------------------------------------------------------------------- +Wed Jun 15 13:21:30 UTC 2022 - Jan Engelhardt + +- Update to 1.6.1+sdk216 (b2a156e) + * Add a SourceLanguage for SYCL + * Add NamedBarrierCountINTEL execution mode + * Add SPV_KHR_subgroup_rotate, SPV_KHR_ray_cull_mask, + SPV_AMD_shader_early_and_late_fragment_tests + +------------------------------------------------------------------- +Mon Apr 18 23:29:28 UTC 2022 - Jan Engelhardt + +- Update to 1.6.1+sdk211 (4995a2f) + * Implement SPV_KHR_uniform_group_instructions extension + * Update SPIR-V headers for SPV_INTEL_split_barrier + * Implement SPV_INTEL_memory_access_aliasing extension + +------------------------------------------------------------------- +Wed Jan 26 20:47:58 UTC 2022 - Jan Engelhardt + +- Update to snapshot 1.6.g6 (b42ba6d / sdk204) + * Add definitions to implement the SPIR-V 1.6 spec. + * Add ShaderWriter as SPIR-V generation tool. + +------------------------------------------------------------------- +Thu Nov 11 19:38:18 UTC 2021 - Jan Engelhardt + +- Update to snapshot 1.5.5.g9 (814e728b / sdk198) + * Add spirv-headers pkgconfig file + * Implement header definitions for SPV_NV_bindless_texture + * Add SpecConstantSubgroupMaxSize to the clspv reflection + non-semantic instruction set + * Rename ConstFunctionPointerINTEL to + ConstantFunctionPointerINTEL + +------------------------------------------------------------------- +Mon Sep 6 05:11:49 UTC 2021 - Jan Engelhardt + +- Update to snapshot 1.5.4.g108 (449bc986) + * Add VectorComputeINTEL as enabling capability for Private + StorageClass + * Add header changes for SPV_EXT_shader_atomic_float16_add + * Support SPV_KHR_integer_dot_product + * Add support for SPV_KHR_bit_instructions + * Implement SPV_INTEL_optnone extension + * Add support for SPV_NV_ray_tracing_motion_blur + +------------------------------------------------------------------- +Wed May 5 09:34:57 UTC 2021 - Jan Engelhardt + +- Update to snapshot 1.5.4.g57 (dafead1765) + * Support SPV_KHR_expect_assume, SPV_KHR_linkonce_odr + * Add generator ID for MSP shader compiler + +------------------------------------------------------------------- +Mon Mar 1 06:46:29 UTC 2021 - Jan Engelhardt + +- Update to 1.5.4.g42 (a3fdfe8146) + * Add SPV_KHR_workgroup_memory_explicit_layout + * Add None as a possible value for DebugInfoFlags + * Add header changes for SPV_EXT_shader_atomic_float_min_max +- Remove 0001-Add-SPV_KHR_workgroup_memory_explicit_layout.patch + +------------------------------------------------------------------- +Wed Feb 10 15:01:14 UTC 2021 - Jan Engelhardt + +- Add 0001-Add-SPV_KHR_workgroup_memory_explicit_layout.patch + +------------------------------------------------------------------- +Wed Nov 25 17:08:48 UTC 2020 - Jan Engelhardt + +- Update to 1.5.4.g8 / 1.5.4.raytracing (104ecc35) + * Added SPV_KHR_fragment_shading_rate + * Add SPV_EXT_shader_image_int64 + * Raytracing and Rayquery updates for final + +------------------------------------------------------------------- +Mon Oct 5 17:57:34 UTC 2020 - Jan Engelhardt + +- Update to 1.5.3.g22 / 1.5.3.reservations1 (3fdabd0d) + * Publish the headers for the clspv embedded reflection + non-semantic extended instruction set. + * Update the registry in spir-v.xml to modernize and split out + opcodes. + +------------------------------------------------------------------- +Wed Aug 12 07:26:50 UTC 2020 - Jan Engelhardt + +- Update to snapshot 1.5.3.g18 (979924c8bc) + * Support for SPV_EXT_shader_atomic_float + +------------------------------------------------------------------- +Fri May 29 17:05:17 UTC 2020 - Jan Engelhardt + +- Update to release 1.5.3 + * Update headers to SPIR-V 1.5 Revision 3 + +------------------------------------------------------------------- +Wed Apr 8 11:17:10 UTC 2020 - Jan Engelhardt + +- Update to snapshot 1.5.1.c+git24 (f8bf11a) + * Add grammars, C header, and header generator for vendor and + KHR extended instruction sets. + * Update headers for SPV_KHR_ray_tracing. + * Added ray flags, primitive culling flags, queries. + * Add shadercalls scope. + +------------------------------------------------------------------- +Sat Oct 26 11:51:56 UTC 2019 - Jan Engelhardt + +- Update to release 1.5.1.corrected + * Add SPV_KHR_physical_storage_buffer. + +------------------------------------------------------------------- +Sat Sep 28 04:32:28 UTC 2019 - Jan Engelhardt + +- Update to release 1.5.1 + * No change from last snapshot, just a version bump. + +------------------------------------------------------------------- +Wed Aug 21 07:26:15 UTC 2019 - Jan Engelhardt + +- Update to new snapshot 1.4.1.g36 + * Add INTEL_shader_integer_functions2, + SPV_EXT_fragment_shader_interlock, + SPV_EXT_demote_to_helper_invocation. + * Add support for SPV_NV_sm_shader_builtins. + * Add Volatile to Memory Semantics, for + SPV_KHR_vulkan_memory_model. + * Add SPV_KHR_shader_clock to spirv-headers. + +------------------------------------------------------------------- +Tue Jun 4 12:12:05 UTC 2019 - Jan Engelhardt + +- Update to new snapshot 1.4.1.g17 + * Add INTEL_shader_integer_functions2 and + SPV_EXT_fragment_shader_interlock. + * Enable Groups capability by the extension SPV_AMD_shader_ballot. + * Add support for SPV_NV_sm_shader_builtins. + +------------------------------------------------------------------- +Sat Mar 16 18:30:41 UTC 2019 - Jan Engelhardt + +- Update to new upstream release 1.3.7 + * Synchronize to revision 7 of the header specification + from Khronos. + +------------------------------------------------------------------- +Mon Jan 7 21:25:39 UTC 2019 - Jan Engelhardt + +- Update to new snapshot 1.3.g60 + * Support for SPV_EXT_physical_storage_buffer + +------------------------------------------------------------------- +Fri Dec 14 23:33:12 UTC 2018 - Jan Engelhardt + +- Update to new snapshot 1.3.g50 + * Reserve tokens for float controls and no integer wrapping + * Add JSON support for SPV_EXT_fragment_invocation_density + +------------------------------------------------------------------- +Sat Nov 10 12:11:07 UTC 2018 - Jan Engelhardt + +- Update to new snapshot 1.3.g44 + * Add enumerants for six Nvidia extensions + * Add support for nv-raytracing + +------------------------------------------------------------------- +Fri Aug 24 19:01:10 UTC 2018 - jengelh@inai.de + +- Update to new snapshot 1.3.g34 + * Add missing extension/capability requirements for some symbols + * Add SPV_NV_shader_subgroup_partitioned to SPIR-V JSON. + * Add missing 'extensions' for OpGroupNonUniformPartitionNV. + * Add tokens for SPV_EXT_descriptor_indexing. + * SPV_GOOGLE_hlsl_functionality1 includes all of + SPV_GOOGLE_decorate_string. + * Clay Shader Compiler + * Add enumerants for SPV_KHR_8bit_storage. + +------------------------------------------------------------------- +Thu Mar 8 00:16:56 UTC 2018 - jengelh@inai.de + +- Update to new snapshot 1.3.g0 + * Allow SubgroupSize and SubgroupLocalInvocationId with SubgroupBallotKHR + * Add headers for the 1.2 unified (1.0, 1.1, and 1.2) specification. + * 464d17b Refresh 1.3 headers from spec repo + +------------------------------------------------------------------- +Wed Feb 7 22:24:49 UTC 2018 - jengelh@inai.de + +- Update to new snapshot 1.2.g22 + * Add headers for the 1.2 unified (1.0, 1.1, and 1.2) + specification. + +------------------------------------------------------------------- +Fri Nov 17 13:26:07 UTC 2017 - jengelh@inai.de + +- Update to new snapshot 1.2.g13 + * Add new Intel token reservations, new tokens for + SPV_AMD_shader_fragment_mask, and new tokens for + SPV_AMD_shader_fragment_mask. + * Update all headers for SPV_EXT_shader_stencil_export. + * Add SPV_EXT_shader_viewport_index_layer. + +------------------------------------------------------------------- +Mon Aug 7 16:34:41 UTC 2017 - jengelh@inai.de + +- Update to new snapshot 1.1.g46 + * Reserve number 16 for the Mesa-IR/SPIR-V Translator. + +------------------------------------------------------------------- +Tue Jul 18 08:53:28 UTC 2017 - jengelh@inai.de + +- Update to new snapshot 1.1.g44 + * reserve SPIR-V enum block for upcoming Intel extension + * Add version 1.2 headers, update 1.1 headers to revision 7, + update 1.0 headers to revision 11. + * Synchronize OpenCL extended instruction set header with spec, + and add missing capability use to the JSON grammar. + * Update JSON grammar files for 16-bit storage. + +------------------------------------------------------------------- +Mon Feb 20 17:28:15 UTC 2017 - jengelh@inai.de + +- Update to new snapshot 1.1.g31 + * New revisions of SPIR-V 1.0 and 1.1, and both extended + instruction sets. + +------------------------------------------------------------------- +Thu Feb 2 10:32:32 UTC 2017 - jengelh@inai.de + +- Update to new snapshot 1.1.g29 + * Add "Shaderc over Glslang" as a front end. + * Update to Rev. 8 of 1.0 and Rev. 4 of 1.1. Includes enums for + SPV_KHR_shader_draw_parameters. + * Add SPV_KHR_shader_ballot enumerants. + +------------------------------------------------------------------- +Sun Jun 12 16:10:27 UTC 2016 - jengelh@inai.de + +- Initial package (version 1.1.g15) for build.opensuse.org diff --git a/spirv-headers.spec b/spirv-headers.spec new file mode 100644 index 0000000..8beb511 --- /dev/null +++ b/spirv-headers.spec @@ -0,0 +1,68 @@ +# +# spec file for package spirv-headers +# +# Copyright (c) 2024 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +# The git repo is a hodgepodge. +# Most recent tag is 1.5.4, but that is outdated. +# CMakeLists.txt's project() line contains 1.5.5, but this is outdated too. +# The SPIR-V version is 1.6.1 (include/spirv/unified1/spirv.core.grammar.json) +# They add "SDK" tags that reflect the Vulkan version (1.3), +# and the independently increasing toolchain release number (283). + +Name: spirv-headers +Version: 1.6.1+sdk283+g8 +%define innerver 1.3.283 +Release: 0 +Summary: Machine-readable files from the SPIR-V registry +License: MIT +Group: Development/Libraries/C and C++ +URL: https://github.com/KhronosGroup/SPIRV-Headers +Source: https://github.com/KhronosGroup/SPIRV-Headers/archive/vulkan-sdk-%innerver.tar.gz +Patch1: v283-to-2acb319.patch +BuildArch: noarch +BuildRequires: cmake >= 2.8 +BuildRequires: fdupes +BuildRequires: gcc-c++ +BuildRequires: pkg-config + +%description +This repository contains machine-readable files from the SPIR-V +registry. This includes: + +* Header files for various languages. +* JSON files describing the grammar for the SPIR-V core instruction + set, and for the GLSL.std.450 extended instruction set. +* The XML registry file. + +%prep +%autosetup -n SPIRV-Headers-vulkan-sdk-%innerver -p0 + +%build +%cmake +%cmake_build + +%install +%cmake_install +%fdupes %buildroot/%_prefix + +%files +%_includedir/spirv/ +%_datadir/cmake/ +%_datadir/pkgconfig/*.pc +%license LICENSE + +%changelog diff --git a/v283-to-2acb319.patch b/v283-to-2acb319.patch new file mode 100644 index 0000000..bc3b881 --- /dev/null +++ b/v283-to-2acb319.patch @@ -0,0 +1,6739 @@ +Update to commit vulkan-sdk-1.3.283.0-8-g2acb319. +#git diff vulkan-sdk-1.3.283.0..2acb319 >../update.patch +Needed for building contemporary spirv-tools versions. +diff --git include/spirv/spir-v.xml include/spirv/spir-v.xml +index 52de097..f9b23ac 100644 +--- include/spirv/spir-v.xml ++++ include/spirv/spir-v.xml +@@ -157,7 +157,7 @@ + sure to fill in the vendor attribute, and preferably add a contact + person/address in a comment attribute. --> + +- ++ + + + +@@ -190,7 +190,7 @@ + sure to fill in the vendor attribute, and preferably add a contact + person/address in a comment attribute. --> + +- ++ + + + +diff --git include/spirv/unified1/NonSemanticVkspReflection.h include/spirv/unified1/NonSemanticVkspReflection.h +index 0ef478a..331a3d9 100644 +--- include/spirv/unified1/NonSemanticVkspReflection.h ++++ include/spirv/unified1/NonSemanticVkspReflection.h +@@ -33,7 +33,7 @@ extern "C" { + #endif + + enum { +- NonSemanticVkspReflectionRevision = 1, ++ NonSemanticVkspReflectionRevision = 2, + NonSemanticVkspReflectionRevision_BitWidthPadding = 0x7fffffff + }; + +diff --git include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json +index bee1bea..379457b 100644 +--- include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json ++++ include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json +@@ -1,5 +1,5 @@ + { +- "revision" : 1, ++ "revision" : 2, + "instructions" : [ + { + "opname" : "Configuration", +@@ -12,7 +12,8 @@ + {"kind" : "LiteralString", "name" : "EntryPoint" }, + {"kind" : "LiteralInteger", "name" : "groupCountX" }, + {"kind" : "LiteralInteger", "name" : "groupCountY" }, +- {"kind" : "LiteralInteger", "name" : "groupCountZ" } ++ {"kind" : "LiteralInteger", "name" : "groupCountZ" }, ++ {"kind" : "LiteralInteger", "name" : "dispatchId" } + ] + }, + { +diff --git include/spirv/unified1/spirv.bf include/spirv/unified1/spirv.bf +index 92b95c8..d14f43f 100644 +--- include/spirv/unified1/spirv.bf ++++ include/spirv/unified1/spirv.bf +@@ -1050,6 +1050,7 @@ namespace Spv + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, ++ CooperativeMatrixLayoutsARM = 4201, + FragmentShadingRateKHR = 4422, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, +@@ -1213,6 +1214,7 @@ namespace Spv + DotProductKHR = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, ++ ReplicatedCompositesEXT = 6024, + BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, +@@ -1365,6 +1367,8 @@ namespace Spv + { + RowMajorKHR = 0, + ColumnMajorKHR = 1, ++ RowBlockedInterleavedARM = 4202, ++ ColumnBlockedInterleavedARM = 4203, + } + + [AllowDuplicates, CRepr] public enum CooperativeMatrixUse +@@ -1780,6 +1784,7 @@ namespace Spv + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1802,6 +1807,9 @@ namespace Spv + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +diff --git include/spirv/unified1/spirv.core.grammar.json include/spirv/unified1/spirv.core.grammar.json +index 5d904ca..980b5dc 100644 +--- include/spirv/unified1/spirv.core.grammar.json ++++ include/spirv/unified1/spirv.core.grammar.json +@@ -4539,6 +4539,20 @@ + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "None" + }, ++ { ++ "opname" : "OpExtInstWithForwardRefsKHR", ++ "class" : "Extension", ++ "opcode" : 4433, ++ "operands" : [ ++ { "kind" : "IdResultType" }, ++ { "kind" : "IdResult" }, ++ { "kind" : "IdRef", "name" : "'Set'" }, ++ { "kind" : "LiteralExtInstInteger", "name" : "'Instruction'" }, ++ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Operand 1', +\n'Operand 2', +\n..." } ++ ], ++ "extensions" : [ "SPV_KHR_relaxed_extended_instruction" ], ++ "version": "None" ++ }, + { + "opname" : "OpTraceRayKHR", + "class" : "Reserved", +@@ -4854,6 +4868,42 @@ + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, ++ { ++ "opname" : "OpConstantCompositeReplicateEXT", ++ "class" : "Constant-Creation", ++ "opcode" : 4461, ++ "operands" : [ ++ { "kind" : "IdResultType" }, ++ { "kind" : "IdResult" }, ++ { "kind" : "IdRef", "name" : "'Value'" } ++ ], ++ "capabilities" : [ "ReplicatedCompositesEXT" ], ++ "version" : "None" ++ }, ++ { ++ "opname" : "OpSpecConstantCompositeReplicateEXT", ++ "class" : "Constant-Creation", ++ "opcode" : 4462, ++ "operands" : [ ++ { "kind" : "IdResultType" }, ++ { "kind" : "IdResult" }, ++ { "kind" : "IdRef", "name" : "'Value'" } ++ ], ++ "capabilities" : [ "ReplicatedCompositesEXT" ], ++ "version" : "None" ++ }, ++ { ++ "opname" : "OpCompositeConstructReplicateEXT", ++ "class" : "Composite", ++ "opcode" : 4463, ++ "operands" : [ ++ { "kind" : "IdResultType" }, ++ { "kind" : "IdResult" }, ++ { "kind" : "IdRef", "name" : "'Value'" } ++ ], ++ "capabilities" : [ "ReplicatedCompositesEXT" ], ++ "version" : "None" ++ }, + { + "opname" : "OpTypeRayQueryKHR", + "class" : "Type-Declaration", +@@ -5888,7 +5938,7 @@ + "version" : "None" + }, + { +- "opname" : "OpReportIntersectionNV", ++ "opname" : "OpReportIntersectionKHR", + "class" : "Reserved", + "opcode" : 5334, + "operands" : [ +@@ -5902,7 +5952,7 @@ + "version" : "None" + }, + { +- "opname" : "OpReportIntersectionKHR", ++ "opname" : "OpReportIntersectionNV", + "class" : "Reserved", + "opcode" : 5334, + "operands" : [ +@@ -6019,7 +6069,7 @@ + "version" : "None" + }, + { +- "opname" : "OpTypeAccelerationStructureNV", ++ "opname" : "OpTypeAccelerationStructureKHR", + "class" : "Type-Declaration", + "opcode" : 5341, + "operands" : [ +@@ -6030,7 +6080,7 @@ + "version" : "None" + }, + { +- "opname" : "OpTypeAccelerationStructureKHR", ++ "opname" : "OpTypeAccelerationStructureNV", + "class" : "Type-Declaration", + "opcode" : 5341, + "operands" : [ +@@ -10836,12 +10886,6 @@ + "capabilities" : [ "MeshShadingNV" ], + "version" : "None" + }, +- { +- "enumerant" : "RayGenerationNV", +- "value" : 5313, +- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], +- "version" : "None" +- }, + { + "enumerant" : "RayGenerationKHR", + "value" : 5313, +@@ -10849,8 +10893,8 @@ + "version" : "None" + }, + { +- "enumerant" : "IntersectionNV", +- "value" : 5314, ++ "enumerant" : "RayGenerationNV", ++ "value" : 5313, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, +@@ -10861,8 +10905,8 @@ + "version" : "None" + }, + { +- "enumerant" : "AnyHitNV", +- "value" : 5315, ++ "enumerant" : "IntersectionNV", ++ "value" : 5314, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, +@@ -10873,8 +10917,8 @@ + "version" : "None" + }, + { +- "enumerant" : "ClosestHitNV", +- "value" : 5316, ++ "enumerant" : "AnyHitNV", ++ "value" : 5315, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, +@@ -10885,8 +10929,8 @@ + "version" : "None" + }, + { +- "enumerant" : "MissNV", +- "value" : 5317, ++ "enumerant" : "ClosestHitNV", ++ "value" : 5316, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, +@@ -10897,8 +10941,8 @@ + "version" : "None" + }, + { +- "enumerant" : "CallableNV", +- "value" : 5318, ++ "enumerant" : "MissNV", ++ "value" : 5317, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, +@@ -10908,6 +10952,12 @@ + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, ++ { ++ "enumerant" : "CallableNV", ++ "value" : 5318, ++ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], ++ "version" : "None" ++ }, + { + "enumerant" : "TaskEXT", + "value" : 5364, +@@ -11460,13 +11510,6 @@ + "capabilities" : [ "QuadControlKHR" ], + "version" : "None" + }, +- { +- "enumerant" : "OutputLinesNV", +- "value" : 5269, +- "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], +- "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], +- "version" : "None" +- }, + { + "enumerant" : "OutputLinesEXT", + "value" : 5269, +@@ -11475,7 +11518,14 @@ + "version" : "None" + }, + { +- "enumerant" : "OutputPrimitivesNV", ++ "enumerant" : "OutputLinesNV", ++ "value" : 5269, ++ "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], ++ "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], ++ "version" : "None" ++ }, ++ { ++ "enumerant" : "OutputPrimitivesEXT", + "value" : 5270, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "parameters" : [ +@@ -11485,7 +11535,7 @@ + "version" : "None" + }, + { +- "enumerant" : "OutputPrimitivesEXT", ++ "enumerant" : "OutputPrimitivesNV", + "value" : 5270, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "parameters" : [ +@@ -11509,14 +11559,14 @@ + "version" : "None" + }, + { +- "enumerant" : "OutputTrianglesNV", ++ "enumerant" : "OutputTrianglesEXT", + "value" : 5298, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], + "version" : "None" + }, + { +- "enumerant" : "OutputTrianglesEXT", ++ "enumerant" : "OutputTrianglesNV", + "value" : 5298, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], +@@ -11828,13 +11878,6 @@ + "capabilities" : [ "ShaderEnqueueAMDX" ], + "version" : "None" + }, +- { +- "enumerant" : "CallableDataNV", +- "value" : 5328, +- "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], +- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], +- "version" : "None" +- }, + { + "enumerant" : "CallableDataKHR", + "value" : 5328, +@@ -11843,8 +11886,8 @@ + "version" : "None" + }, + { +- "enumerant" : "IncomingCallableDataNV", +- "value" : 5329, ++ "enumerant" : "CallableDataNV", ++ "value" : 5328, + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" +@@ -11857,8 +11900,8 @@ + "version" : "None" + }, + { +- "enumerant" : "RayPayloadNV", +- "value" : 5338, ++ "enumerant" : "IncomingCallableDataNV", ++ "value" : 5329, + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" +@@ -11871,8 +11914,8 @@ + "version" : "None" + }, + { +- "enumerant" : "HitAttributeNV", +- "value" : 5339, ++ "enumerant" : "RayPayloadNV", ++ "value" : 5338, + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" +@@ -11885,8 +11928,8 @@ + "version" : "None" + }, + { +- "enumerant" : "IncomingRayPayloadNV", +- "value" : 5342, ++ "enumerant" : "HitAttributeNV", ++ "value" : 5339, + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" +@@ -11899,8 +11942,8 @@ + "version" : "None" + }, + { +- "enumerant" : "ShaderRecordBufferNV", +- "value" : 5343, ++ "enumerant" : "IncomingRayPayloadNV", ++ "value" : 5342, + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" +@@ -11912,6 +11955,13 @@ + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "version" : "None" + }, ++ { ++ "enumerant" : "ShaderRecordBufferNV", ++ "value" : 5343, ++ "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], ++ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], ++ "version" : "None" ++ }, + { + "enumerant" : "PhysicalStorageBuffer", + "value" : 5349, +@@ -13263,14 +13313,14 @@ + ] + }, + { +- "enumerant" : "PerPrimitiveNV", ++ "enumerant" : "PerPrimitiveEXT", + "value" : 5271, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], + "version" : "None" + }, + { +- "enumerant" : "PerPrimitiveEXT", ++ "enumerant" : "PerPrimitiveNV", + "value" : 5271, + "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], + "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], +@@ -14569,13 +14619,6 @@ + "extensions" : [ "SPV_EXT_mesh_shader" ], + "version" : "None" + }, +- { +- "enumerant" : "LaunchIdNV", +- "value" : 5319, +- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], +- "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], +- "version" : "None" +- }, + { + "enumerant" : "LaunchIdKHR", + "value" : 5319, +@@ -14584,8 +14627,8 @@ + "version" : "None" + }, + { +- "enumerant" : "LaunchSizeNV", +- "value" : 5320, ++ "enumerant" : "LaunchIdNV", ++ "value" : 5319, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14598,8 +14641,8 @@ + "version" : "None" + }, + { +- "enumerant" : "WorldRayOriginNV", +- "value" : 5321, ++ "enumerant" : "LaunchSizeNV", ++ "value" : 5320, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14612,8 +14655,8 @@ + "version" : "None" + }, + { +- "enumerant" : "WorldRayDirectionNV", +- "value" : 5322, ++ "enumerant" : "WorldRayOriginNV", ++ "value" : 5321, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14626,8 +14669,8 @@ + "version" : "None" + }, + { +- "enumerant" : "ObjectRayOriginNV", +- "value" : 5323, ++ "enumerant" : "WorldRayDirectionNV", ++ "value" : 5322, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14640,8 +14683,8 @@ + "version" : "None" + }, + { +- "enumerant" : "ObjectRayDirectionNV", +- "value" : 5324, ++ "enumerant" : "ObjectRayOriginNV", ++ "value" : 5323, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14654,8 +14697,8 @@ + "version" : "None" + }, + { +- "enumerant" : "RayTminNV", +- "value" : 5325, ++ "enumerant" : "ObjectRayDirectionNV", ++ "value" : 5324, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14668,8 +14711,8 @@ + "version" : "None" + }, + { +- "enumerant" : "RayTmaxNV", +- "value" : 5326, ++ "enumerant" : "RayTminNV", ++ "value" : 5325, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14682,8 +14725,8 @@ + "version" : "None" + }, + { +- "enumerant" : "InstanceCustomIndexNV", +- "value" : 5327, ++ "enumerant" : "RayTmaxNV", ++ "value" : 5326, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14696,8 +14739,8 @@ + "version" : "None" + }, + { +- "enumerant" : "ObjectToWorldNV", +- "value" : 5330, ++ "enumerant" : "InstanceCustomIndexNV", ++ "value" : 5327, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14710,8 +14753,8 @@ + "version" : "None" + }, + { +- "enumerant" : "WorldToObjectNV", +- "value" : 5331, ++ "enumerant" : "ObjectToWorldNV", ++ "value" : 5330, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" +@@ -14723,6 +14766,13 @@ + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" + }, ++ { ++ "enumerant" : "WorldToObjectNV", ++ "value" : 5331, ++ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], ++ "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], ++ "version" : "None" ++ }, + { + "enumerant" : "HitTNV", + "value" : 5332, +@@ -14731,14 +14781,14 @@ + "version" : "None" + }, + { +- "enumerant" : "HitKindNV", ++ "enumerant" : "HitKindKHR", + "value" : 5333, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" + }, + { +- "enumerant" : "HitKindKHR", ++ "enumerant" : "HitKindNV", + "value" : 5333, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], +@@ -14770,14 +14820,14 @@ + "version" : "None" + }, + { +- "enumerant" : "IncomingRayFlagsNV", ++ "enumerant" : "IncomingRayFlagsKHR", + "value" : 5351, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], + "version" : "None" + }, + { +- "enumerant" : "IncomingRayFlagsKHR", ++ "enumerant" : "IncomingRayFlagsNV", + "value" : 5351, + "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], + "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], +@@ -15396,6 +15446,12 @@ + "extensions" : [ "SPV_EXT_shader_tile_image" ], + "version" : "None" + }, ++ { ++ "enumerant" : "CooperativeMatrixLayoutsARM", ++ "value" : 4201, ++ "extensions" : [ "SPV_ARM_cooperative_matrix_layouts" ], ++ "version" : "None" ++ }, + { + "enumerant" : "FragmentShadingRateKHR", + "value" : 4422, +@@ -16442,6 +16498,12 @@ + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, ++ { ++ "enumerant" : "ReplicatedCompositesEXT", ++ "value" : 6024, ++ "extensions" : [ "SPV_EXT_replicated_composites" ], ++ "version" : "None" ++ }, + { + "enumerant" : "BitInstructions", + "value" : 6025, +@@ -16705,6 +16767,16 @@ + "enumerant" : "ColumnMajorKHR", + "value" : 1, + "version" : "None" ++ }, ++ { ++ "enumerant" : "RowBlockedInterleavedARM", ++ "value" : 4202, ++ "version" : "None" ++ }, ++ { ++ "enumerant" : "ColumnBlockedInterleavedARM", ++ "value" : 4203, ++ "version" : "None" + } + ] + }, +diff --git include/spirv/unified1/spirv.cs include/spirv/unified1/spirv.cs +index 8d85cce..aaba96f 100644 +--- include/spirv/unified1/spirv.cs ++++ include/spirv/unified1/spirv.cs +@@ -1049,6 +1049,7 @@ namespace Spv + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, ++ CooperativeMatrixLayoutsARM = 4201, + FragmentShadingRateKHR = 4422, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, +@@ -1212,6 +1213,7 @@ namespace Spv + DotProductKHR = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, ++ ReplicatedCompositesEXT = 6024, + BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, +@@ -1364,6 +1366,8 @@ namespace Spv + { + RowMajorKHR = 0, + ColumnMajorKHR = 1, ++ RowBlockedInterleavedARM = 4202, ++ ColumnBlockedInterleavedARM = 4203, + } + + public enum CooperativeMatrixUse +@@ -1779,6 +1783,7 @@ namespace Spv + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1801,6 +1806,9 @@ namespace Spv + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +diff --git include/spirv/unified1/spirv.h include/spirv/unified1/spirv.h +index e544a85..42790e0 100644 +--- include/spirv/unified1/spirv.h ++++ include/spirv/unified1/spirv.h +@@ -1049,6 +1049,7 @@ typedef enum SpvCapability_ { + SpvCapabilityTileImageColorReadAccessEXT = 4166, + SpvCapabilityTileImageDepthReadAccessEXT = 4167, + SpvCapabilityTileImageStencilReadAccessEXT = 4168, ++ SpvCapabilityCooperativeMatrixLayoutsARM = 4201, + SpvCapabilityFragmentShadingRateKHR = 4422, + SpvCapabilitySubgroupBallotKHR = 4423, + SpvCapabilityDrawParameters = 4427, +@@ -1212,6 +1213,7 @@ typedef enum SpvCapability_ { + SpvCapabilityDotProductKHR = 6019, + SpvCapabilityRayCullMaskKHR = 6020, + SpvCapabilityCooperativeMatrixKHR = 6022, ++ SpvCapabilityReplicatedCompositesEXT = 6024, + SpvCapabilityBitInstructions = 6025, + SpvCapabilityGroupNonUniformRotateKHR = 6026, + SpvCapabilityFloatControls2 = 6029, +@@ -1361,6 +1363,8 @@ typedef enum SpvCooperativeMatrixOperandsMask_ { + typedef enum SpvCooperativeMatrixLayout_ { + SpvCooperativeMatrixLayoutRowMajorKHR = 0, + SpvCooperativeMatrixLayoutColumnMajorKHR = 1, ++ SpvCooperativeMatrixLayoutRowBlockedInterleavedARM = 4202, ++ SpvCooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203, + SpvCooperativeMatrixLayoutMax = 0x7fffffff, + } SpvCooperativeMatrixLayout; + +@@ -1775,6 +1779,7 @@ typedef enum SpvOp_ { + SpvOpSubgroupAllEqualKHR = 4430, + SpvOpGroupNonUniformRotateKHR = 4431, + SpvOpSubgroupReadInvocationKHR = 4432, ++ SpvOpExtInstWithForwardRefsKHR = 4433, + SpvOpTraceRayKHR = 4445, + SpvOpExecuteCallableKHR = 4446, + SpvOpConvertUToAccelerationStructureKHR = 4447, +@@ -1797,6 +1802,9 @@ typedef enum SpvOp_ { + SpvOpCooperativeMatrixStoreKHR = 4458, + SpvOpCooperativeMatrixMulAddKHR = 4459, + SpvOpCooperativeMatrixLengthKHR = 4460, ++ SpvOpConstantCompositeReplicateEXT = 4461, ++ SpvOpSpecConstantCompositeReplicateEXT = 4462, ++ SpvOpCompositeConstructReplicateEXT = 4463, + SpvOpTypeRayQueryKHR = 4472, + SpvOpRayQueryInitializeKHR = 4473, + SpvOpRayQueryTerminateKHR = 4474, +@@ -2519,6 +2527,7 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy + case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; ++ case SpvOpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpTraceRayKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; +@@ -2535,6 +2544,9 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy + case SpvOpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; ++ case SpvOpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case SpvOpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case SpvOpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; + case SpvOpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; + case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; +@@ -2606,14 +2618,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy + case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case SpvOpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; + case SpvOpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; +- case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; ++ case SpvOpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTraceMotionNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; + case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; +- case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; ++ case SpvOpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; + case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; +@@ -2888,6 +2900,1787 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy + case SpvOpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; + } + } ++inline const char* SpvSourceLanguageToString(SpvSourceLanguage value) { ++ switch (value) { ++ case SpvSourceLanguageUnknown: return "Unknown"; ++ case SpvSourceLanguageESSL: return "ESSL"; ++ case SpvSourceLanguageGLSL: return "GLSL"; ++ case SpvSourceLanguageOpenCL_C: return "OpenCL_C"; ++ case SpvSourceLanguageOpenCL_CPP: return "OpenCL_CPP"; ++ case SpvSourceLanguageHLSL: return "HLSL"; ++ case SpvSourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; ++ case SpvSourceLanguageSYCL: return "SYCL"; ++ case SpvSourceLanguageHERO_C: return "HERO_C"; ++ case SpvSourceLanguageNZSL: return "NZSL"; ++ case SpvSourceLanguageWGSL: return "WGSL"; ++ case SpvSourceLanguageSlang: return "Slang"; ++ case SpvSourceLanguageZig: return "Zig"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvExecutionModelToString(SpvExecutionModel value) { ++ switch (value) { ++ case SpvExecutionModelVertex: return "Vertex"; ++ case SpvExecutionModelTessellationControl: return "TessellationControl"; ++ case SpvExecutionModelTessellationEvaluation: return "TessellationEvaluation"; ++ case SpvExecutionModelGeometry: return "Geometry"; ++ case SpvExecutionModelFragment: return "Fragment"; ++ case SpvExecutionModelGLCompute: return "GLCompute"; ++ case SpvExecutionModelKernel: return "Kernel"; ++ case SpvExecutionModelTaskNV: return "TaskNV"; ++ case SpvExecutionModelMeshNV: return "MeshNV"; ++ case SpvExecutionModelRayGenerationKHR: return "RayGenerationKHR"; ++ case SpvExecutionModelIntersectionKHR: return "IntersectionKHR"; ++ case SpvExecutionModelAnyHitKHR: return "AnyHitKHR"; ++ case SpvExecutionModelClosestHitKHR: return "ClosestHitKHR"; ++ case SpvExecutionModelMissKHR: return "MissKHR"; ++ case SpvExecutionModelCallableKHR: return "CallableKHR"; ++ case SpvExecutionModelTaskEXT: return "TaskEXT"; ++ case SpvExecutionModelMeshEXT: return "MeshEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvAddressingModelToString(SpvAddressingModel value) { ++ switch (value) { ++ case SpvAddressingModelLogical: return "Logical"; ++ case SpvAddressingModelPhysical32: return "Physical32"; ++ case SpvAddressingModelPhysical64: return "Physical64"; ++ case SpvAddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvMemoryModelToString(SpvMemoryModel value) { ++ switch (value) { ++ case SpvMemoryModelSimple: return "Simple"; ++ case SpvMemoryModelGLSL450: return "GLSL450"; ++ case SpvMemoryModelOpenCL: return "OpenCL"; ++ case SpvMemoryModelVulkan: return "Vulkan"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvExecutionModeToString(SpvExecutionMode value) { ++ switch (value) { ++ case SpvExecutionModeInvocations: return "Invocations"; ++ case SpvExecutionModeSpacingEqual: return "SpacingEqual"; ++ case SpvExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; ++ case SpvExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; ++ case SpvExecutionModeVertexOrderCw: return "VertexOrderCw"; ++ case SpvExecutionModeVertexOrderCcw: return "VertexOrderCcw"; ++ case SpvExecutionModePixelCenterInteger: return "PixelCenterInteger"; ++ case SpvExecutionModeOriginUpperLeft: return "OriginUpperLeft"; ++ case SpvExecutionModeOriginLowerLeft: return "OriginLowerLeft"; ++ case SpvExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; ++ case SpvExecutionModePointMode: return "PointMode"; ++ case SpvExecutionModeXfb: return "Xfb"; ++ case SpvExecutionModeDepthReplacing: return "DepthReplacing"; ++ case SpvExecutionModeDepthGreater: return "DepthGreater"; ++ case SpvExecutionModeDepthLess: return "DepthLess"; ++ case SpvExecutionModeDepthUnchanged: return "DepthUnchanged"; ++ case SpvExecutionModeLocalSize: return "LocalSize"; ++ case SpvExecutionModeLocalSizeHint: return "LocalSizeHint"; ++ case SpvExecutionModeInputPoints: return "InputPoints"; ++ case SpvExecutionModeInputLines: return "InputLines"; ++ case SpvExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; ++ case SpvExecutionModeTriangles: return "Triangles"; ++ case SpvExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; ++ case SpvExecutionModeQuads: return "Quads"; ++ case SpvExecutionModeIsolines: return "Isolines"; ++ case SpvExecutionModeOutputVertices: return "OutputVertices"; ++ case SpvExecutionModeOutputPoints: return "OutputPoints"; ++ case SpvExecutionModeOutputLineStrip: return "OutputLineStrip"; ++ case SpvExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; ++ case SpvExecutionModeVecTypeHint: return "VecTypeHint"; ++ case SpvExecutionModeContractionOff: return "ContractionOff"; ++ case SpvExecutionModeInitializer: return "Initializer"; ++ case SpvExecutionModeFinalizer: return "Finalizer"; ++ case SpvExecutionModeSubgroupSize: return "SubgroupSize"; ++ case SpvExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; ++ case SpvExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; ++ case SpvExecutionModeLocalSizeId: return "LocalSizeId"; ++ case SpvExecutionModeLocalSizeHintId: return "LocalSizeHintId"; ++ case SpvExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; ++ case SpvExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; ++ case SpvExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; ++ case SpvExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; ++ case SpvExecutionModePostDepthCoverage: return "PostDepthCoverage"; ++ case SpvExecutionModeDenormPreserve: return "DenormPreserve"; ++ case SpvExecutionModeDenormFlushToZero: return "DenormFlushToZero"; ++ case SpvExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case SpvExecutionModeRoundingModeRTE: return "RoundingModeRTE"; ++ case SpvExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; ++ case SpvExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; ++ case SpvExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; ++ case SpvExecutionModeCoalescingAMDX: return "CoalescingAMDX"; ++ case SpvExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; ++ case SpvExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; ++ case SpvExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case SpvExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; ++ case SpvExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; ++ case SpvExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; ++ case SpvExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; ++ case SpvExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; ++ case SpvExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; ++ case SpvExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; ++ case SpvExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; ++ case SpvExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; ++ case SpvExecutionModeOutputLinesEXT: return "OutputLinesEXT"; ++ case SpvExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; ++ case SpvExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; ++ case SpvExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; ++ case SpvExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; ++ case SpvExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; ++ case SpvExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; ++ case SpvExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; ++ case SpvExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; ++ case SpvExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; ++ case SpvExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; ++ case SpvExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; ++ case SpvExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; ++ case SpvExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; ++ case SpvExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; ++ case SpvExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; ++ case SpvExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; ++ case SpvExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; ++ case SpvExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; ++ case SpvExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; ++ case SpvExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; ++ case SpvExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; ++ case SpvExecutionModeFPFastMathDefault: return "FPFastMathDefault"; ++ case SpvExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; ++ case SpvExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; ++ case SpvExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; ++ case SpvExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; ++ case SpvExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; ++ case SpvExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvStorageClassToString(SpvStorageClass value) { ++ switch (value) { ++ case SpvStorageClassUniformConstant: return "UniformConstant"; ++ case SpvStorageClassInput: return "Input"; ++ case SpvStorageClassUniform: return "Uniform"; ++ case SpvStorageClassOutput: return "Output"; ++ case SpvStorageClassWorkgroup: return "Workgroup"; ++ case SpvStorageClassCrossWorkgroup: return "CrossWorkgroup"; ++ case SpvStorageClassPrivate: return "Private"; ++ case SpvStorageClassFunction: return "Function"; ++ case SpvStorageClassGeneric: return "Generic"; ++ case SpvStorageClassPushConstant: return "PushConstant"; ++ case SpvStorageClassAtomicCounter: return "AtomicCounter"; ++ case SpvStorageClassImage: return "Image"; ++ case SpvStorageClassStorageBuffer: return "StorageBuffer"; ++ case SpvStorageClassTileImageEXT: return "TileImageEXT"; ++ case SpvStorageClassNodePayloadAMDX: return "NodePayloadAMDX"; ++ case SpvStorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; ++ case SpvStorageClassCallableDataKHR: return "CallableDataKHR"; ++ case SpvStorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; ++ case SpvStorageClassRayPayloadKHR: return "RayPayloadKHR"; ++ case SpvStorageClassHitAttributeKHR: return "HitAttributeKHR"; ++ case SpvStorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; ++ case SpvStorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; ++ case SpvStorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; ++ case SpvStorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; ++ case SpvStorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; ++ case SpvStorageClassCodeSectionINTEL: return "CodeSectionINTEL"; ++ case SpvStorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; ++ case SpvStorageClassHostOnlyINTEL: return "HostOnlyINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvDimToString(SpvDim value) { ++ switch (value) { ++ case SpvDim1D: return "1D"; ++ case SpvDim2D: return "2D"; ++ case SpvDim3D: return "3D"; ++ case SpvDimCube: return "Cube"; ++ case SpvDimRect: return "Rect"; ++ case SpvDimBuffer: return "Buffer"; ++ case SpvDimSubpassData: return "SubpassData"; ++ case SpvDimTileImageDataEXT: return "TileImageDataEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvSamplerAddressingModeToString(SpvSamplerAddressingMode value) { ++ switch (value) { ++ case SpvSamplerAddressingModeNone: return "None"; ++ case SpvSamplerAddressingModeClampToEdge: return "ClampToEdge"; ++ case SpvSamplerAddressingModeClamp: return "Clamp"; ++ case SpvSamplerAddressingModeRepeat: return "Repeat"; ++ case SpvSamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvSamplerFilterModeToString(SpvSamplerFilterMode value) { ++ switch (value) { ++ case SpvSamplerFilterModeNearest: return "Nearest"; ++ case SpvSamplerFilterModeLinear: return "Linear"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvImageFormatToString(SpvImageFormat value) { ++ switch (value) { ++ case SpvImageFormatUnknown: return "Unknown"; ++ case SpvImageFormatRgba32f: return "Rgba32f"; ++ case SpvImageFormatRgba16f: return "Rgba16f"; ++ case SpvImageFormatR32f: return "R32f"; ++ case SpvImageFormatRgba8: return "Rgba8"; ++ case SpvImageFormatRgba8Snorm: return "Rgba8Snorm"; ++ case SpvImageFormatRg32f: return "Rg32f"; ++ case SpvImageFormatRg16f: return "Rg16f"; ++ case SpvImageFormatR11fG11fB10f: return "R11fG11fB10f"; ++ case SpvImageFormatR16f: return "R16f"; ++ case SpvImageFormatRgba16: return "Rgba16"; ++ case SpvImageFormatRgb10A2: return "Rgb10A2"; ++ case SpvImageFormatRg16: return "Rg16"; ++ case SpvImageFormatRg8: return "Rg8"; ++ case SpvImageFormatR16: return "R16"; ++ case SpvImageFormatR8: return "R8"; ++ case SpvImageFormatRgba16Snorm: return "Rgba16Snorm"; ++ case SpvImageFormatRg16Snorm: return "Rg16Snorm"; ++ case SpvImageFormatRg8Snorm: return "Rg8Snorm"; ++ case SpvImageFormatR16Snorm: return "R16Snorm"; ++ case SpvImageFormatR8Snorm: return "R8Snorm"; ++ case SpvImageFormatRgba32i: return "Rgba32i"; ++ case SpvImageFormatRgba16i: return "Rgba16i"; ++ case SpvImageFormatRgba8i: return "Rgba8i"; ++ case SpvImageFormatR32i: return "R32i"; ++ case SpvImageFormatRg32i: return "Rg32i"; ++ case SpvImageFormatRg16i: return "Rg16i"; ++ case SpvImageFormatRg8i: return "Rg8i"; ++ case SpvImageFormatR16i: return "R16i"; ++ case SpvImageFormatR8i: return "R8i"; ++ case SpvImageFormatRgba32ui: return "Rgba32ui"; ++ case SpvImageFormatRgba16ui: return "Rgba16ui"; ++ case SpvImageFormatRgba8ui: return "Rgba8ui"; ++ case SpvImageFormatR32ui: return "R32ui"; ++ case SpvImageFormatRgb10a2ui: return "Rgb10a2ui"; ++ case SpvImageFormatRg32ui: return "Rg32ui"; ++ case SpvImageFormatRg16ui: return "Rg16ui"; ++ case SpvImageFormatRg8ui: return "Rg8ui"; ++ case SpvImageFormatR16ui: return "R16ui"; ++ case SpvImageFormatR8ui: return "R8ui"; ++ case SpvImageFormatR64ui: return "R64ui"; ++ case SpvImageFormatR64i: return "R64i"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvImageChannelOrderToString(SpvImageChannelOrder value) { ++ switch (value) { ++ case SpvImageChannelOrderR: return "R"; ++ case SpvImageChannelOrderA: return "A"; ++ case SpvImageChannelOrderRG: return "RG"; ++ case SpvImageChannelOrderRA: return "RA"; ++ case SpvImageChannelOrderRGB: return "RGB"; ++ case SpvImageChannelOrderRGBA: return "RGBA"; ++ case SpvImageChannelOrderBGRA: return "BGRA"; ++ case SpvImageChannelOrderARGB: return "ARGB"; ++ case SpvImageChannelOrderIntensity: return "Intensity"; ++ case SpvImageChannelOrderLuminance: return "Luminance"; ++ case SpvImageChannelOrderRx: return "Rx"; ++ case SpvImageChannelOrderRGx: return "RGx"; ++ case SpvImageChannelOrderRGBx: return "RGBx"; ++ case SpvImageChannelOrderDepth: return "Depth"; ++ case SpvImageChannelOrderDepthStencil: return "DepthStencil"; ++ case SpvImageChannelOrdersRGB: return "sRGB"; ++ case SpvImageChannelOrdersRGBx: return "sRGBx"; ++ case SpvImageChannelOrdersRGBA: return "sRGBA"; ++ case SpvImageChannelOrdersBGRA: return "sBGRA"; ++ case SpvImageChannelOrderABGR: return "ABGR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvImageChannelDataTypeToString(SpvImageChannelDataType value) { ++ switch (value) { ++ case SpvImageChannelDataTypeSnormInt8: return "SnormInt8"; ++ case SpvImageChannelDataTypeSnormInt16: return "SnormInt16"; ++ case SpvImageChannelDataTypeUnormInt8: return "UnormInt8"; ++ case SpvImageChannelDataTypeUnormInt16: return "UnormInt16"; ++ case SpvImageChannelDataTypeUnormShort565: return "UnormShort565"; ++ case SpvImageChannelDataTypeUnormShort555: return "UnormShort555"; ++ case SpvImageChannelDataTypeUnormInt101010: return "UnormInt101010"; ++ case SpvImageChannelDataTypeSignedInt8: return "SignedInt8"; ++ case SpvImageChannelDataTypeSignedInt16: return "SignedInt16"; ++ case SpvImageChannelDataTypeSignedInt32: return "SignedInt32"; ++ case SpvImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; ++ case SpvImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; ++ case SpvImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; ++ case SpvImageChannelDataTypeHalfFloat: return "HalfFloat"; ++ case SpvImageChannelDataTypeFloat: return "Float"; ++ case SpvImageChannelDataTypeUnormInt24: return "UnormInt24"; ++ case SpvImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; ++ case SpvImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; ++ case SpvImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvFPRoundingModeToString(SpvFPRoundingMode value) { ++ switch (value) { ++ case SpvFPRoundingModeRTE: return "RTE"; ++ case SpvFPRoundingModeRTZ: return "RTZ"; ++ case SpvFPRoundingModeRTP: return "RTP"; ++ case SpvFPRoundingModeRTN: return "RTN"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvLinkageTypeToString(SpvLinkageType value) { ++ switch (value) { ++ case SpvLinkageTypeExport: return "Export"; ++ case SpvLinkageTypeImport: return "Import"; ++ case SpvLinkageTypeLinkOnceODR: return "LinkOnceODR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvAccessQualifierToString(SpvAccessQualifier value) { ++ switch (value) { ++ case SpvAccessQualifierReadOnly: return "ReadOnly"; ++ case SpvAccessQualifierWriteOnly: return "WriteOnly"; ++ case SpvAccessQualifierReadWrite: return "ReadWrite"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvFunctionParameterAttributeToString(SpvFunctionParameterAttribute value) { ++ switch (value) { ++ case SpvFunctionParameterAttributeZext: return "Zext"; ++ case SpvFunctionParameterAttributeSext: return "Sext"; ++ case SpvFunctionParameterAttributeByVal: return "ByVal"; ++ case SpvFunctionParameterAttributeSret: return "Sret"; ++ case SpvFunctionParameterAttributeNoAlias: return "NoAlias"; ++ case SpvFunctionParameterAttributeNoCapture: return "NoCapture"; ++ case SpvFunctionParameterAttributeNoWrite: return "NoWrite"; ++ case SpvFunctionParameterAttributeNoReadWrite: return "NoReadWrite"; ++ case SpvFunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvDecorationToString(SpvDecoration value) { ++ switch (value) { ++ case SpvDecorationRelaxedPrecision: return "RelaxedPrecision"; ++ case SpvDecorationSpecId: return "SpecId"; ++ case SpvDecorationBlock: return "Block"; ++ case SpvDecorationBufferBlock: return "BufferBlock"; ++ case SpvDecorationRowMajor: return "RowMajor"; ++ case SpvDecorationColMajor: return "ColMajor"; ++ case SpvDecorationArrayStride: return "ArrayStride"; ++ case SpvDecorationMatrixStride: return "MatrixStride"; ++ case SpvDecorationGLSLShared: return "GLSLShared"; ++ case SpvDecorationGLSLPacked: return "GLSLPacked"; ++ case SpvDecorationCPacked: return "CPacked"; ++ case SpvDecorationBuiltIn: return "BuiltIn"; ++ case SpvDecorationNoPerspective: return "NoPerspective"; ++ case SpvDecorationFlat: return "Flat"; ++ case SpvDecorationPatch: return "Patch"; ++ case SpvDecorationCentroid: return "Centroid"; ++ case SpvDecorationSample: return "Sample"; ++ case SpvDecorationInvariant: return "Invariant"; ++ case SpvDecorationRestrict: return "Restrict"; ++ case SpvDecorationAliased: return "Aliased"; ++ case SpvDecorationVolatile: return "Volatile"; ++ case SpvDecorationConstant: return "Constant"; ++ case SpvDecorationCoherent: return "Coherent"; ++ case SpvDecorationNonWritable: return "NonWritable"; ++ case SpvDecorationNonReadable: return "NonReadable"; ++ case SpvDecorationUniform: return "Uniform"; ++ case SpvDecorationUniformId: return "UniformId"; ++ case SpvDecorationSaturatedConversion: return "SaturatedConversion"; ++ case SpvDecorationStream: return "Stream"; ++ case SpvDecorationLocation: return "Location"; ++ case SpvDecorationComponent: return "Component"; ++ case SpvDecorationIndex: return "Index"; ++ case SpvDecorationBinding: return "Binding"; ++ case SpvDecorationDescriptorSet: return "DescriptorSet"; ++ case SpvDecorationOffset: return "Offset"; ++ case SpvDecorationXfbBuffer: return "XfbBuffer"; ++ case SpvDecorationXfbStride: return "XfbStride"; ++ case SpvDecorationFuncParamAttr: return "FuncParamAttr"; ++ case SpvDecorationFPRoundingMode: return "FPRoundingMode"; ++ case SpvDecorationFPFastMathMode: return "FPFastMathMode"; ++ case SpvDecorationLinkageAttributes: return "LinkageAttributes"; ++ case SpvDecorationNoContraction: return "NoContraction"; ++ case SpvDecorationInputAttachmentIndex: return "InputAttachmentIndex"; ++ case SpvDecorationAlignment: return "Alignment"; ++ case SpvDecorationMaxByteOffset: return "MaxByteOffset"; ++ case SpvDecorationAlignmentId: return "AlignmentId"; ++ case SpvDecorationMaxByteOffsetId: return "MaxByteOffsetId"; ++ case SpvDecorationNoSignedWrap: return "NoSignedWrap"; ++ case SpvDecorationNoUnsignedWrap: return "NoUnsignedWrap"; ++ case SpvDecorationWeightTextureQCOM: return "WeightTextureQCOM"; ++ case SpvDecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; ++ case SpvDecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; ++ case SpvDecorationExplicitInterpAMD: return "ExplicitInterpAMD"; ++ case SpvDecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; ++ case SpvDecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; ++ case SpvDecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; ++ case SpvDecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; ++ case SpvDecorationOverrideCoverageNV: return "OverrideCoverageNV"; ++ case SpvDecorationPassthroughNV: return "PassthroughNV"; ++ case SpvDecorationViewportRelativeNV: return "ViewportRelativeNV"; ++ case SpvDecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; ++ case SpvDecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; ++ case SpvDecorationPerViewNV: return "PerViewNV"; ++ case SpvDecorationPerTaskNV: return "PerTaskNV"; ++ case SpvDecorationPerVertexKHR: return "PerVertexKHR"; ++ case SpvDecorationNonUniform: return "NonUniform"; ++ case SpvDecorationRestrictPointer: return "RestrictPointer"; ++ case SpvDecorationAliasedPointer: return "AliasedPointer"; ++ case SpvDecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; ++ case SpvDecorationBindlessSamplerNV: return "BindlessSamplerNV"; ++ case SpvDecorationBindlessImageNV: return "BindlessImageNV"; ++ case SpvDecorationBoundSamplerNV: return "BoundSamplerNV"; ++ case SpvDecorationBoundImageNV: return "BoundImageNV"; ++ case SpvDecorationSIMTCallINTEL: return "SIMTCallINTEL"; ++ case SpvDecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; ++ case SpvDecorationClobberINTEL: return "ClobberINTEL"; ++ case SpvDecorationSideEffectsINTEL: return "SideEffectsINTEL"; ++ case SpvDecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; ++ case SpvDecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; ++ case SpvDecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; ++ case SpvDecorationStackCallINTEL: return "StackCallINTEL"; ++ case SpvDecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; ++ case SpvDecorationCounterBuffer: return "CounterBuffer"; ++ case SpvDecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; ++ case SpvDecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; ++ case SpvDecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; ++ case SpvDecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; ++ case SpvDecorationRegisterINTEL: return "RegisterINTEL"; ++ case SpvDecorationMemoryINTEL: return "MemoryINTEL"; ++ case SpvDecorationNumbanksINTEL: return "NumbanksINTEL"; ++ case SpvDecorationBankwidthINTEL: return "BankwidthINTEL"; ++ case SpvDecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; ++ case SpvDecorationSinglepumpINTEL: return "SinglepumpINTEL"; ++ case SpvDecorationDoublepumpINTEL: return "DoublepumpINTEL"; ++ case SpvDecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; ++ case SpvDecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; ++ case SpvDecorationMergeINTEL: return "MergeINTEL"; ++ case SpvDecorationBankBitsINTEL: return "BankBitsINTEL"; ++ case SpvDecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; ++ case SpvDecorationStridesizeINTEL: return "StridesizeINTEL"; ++ case SpvDecorationWordsizeINTEL: return "WordsizeINTEL"; ++ case SpvDecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; ++ case SpvDecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; ++ case SpvDecorationCacheSizeINTEL: return "CacheSizeINTEL"; ++ case SpvDecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; ++ case SpvDecorationPrefetchINTEL: return "PrefetchINTEL"; ++ case SpvDecorationStallEnableINTEL: return "StallEnableINTEL"; ++ case SpvDecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; ++ case SpvDecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; ++ case SpvDecorationAliasScopeINTEL: return "AliasScopeINTEL"; ++ case SpvDecorationNoAliasINTEL: return "NoAliasINTEL"; ++ case SpvDecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; ++ case SpvDecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; ++ case SpvDecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; ++ case SpvDecorationBufferLocationINTEL: return "BufferLocationINTEL"; ++ case SpvDecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; ++ case SpvDecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; ++ case SpvDecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; ++ case SpvDecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; ++ case SpvDecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; ++ case SpvDecorationStallFreeINTEL: return "StallFreeINTEL"; ++ case SpvDecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; ++ case SpvDecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; ++ case SpvDecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; ++ case SpvDecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; ++ case SpvDecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; ++ case SpvDecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; ++ case SpvDecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; ++ case SpvDecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; ++ case SpvDecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; ++ case SpvDecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; ++ case SpvDecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; ++ case SpvDecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; ++ case SpvDecorationHostAccessINTEL: return "HostAccessINTEL"; ++ case SpvDecorationInitModeINTEL: return "InitModeINTEL"; ++ case SpvDecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; ++ case SpvDecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; ++ case SpvDecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvBuiltInToString(SpvBuiltIn value) { ++ switch (value) { ++ case SpvBuiltInPosition: return "Position"; ++ case SpvBuiltInPointSize: return "PointSize"; ++ case SpvBuiltInClipDistance: return "ClipDistance"; ++ case SpvBuiltInCullDistance: return "CullDistance"; ++ case SpvBuiltInVertexId: return "VertexId"; ++ case SpvBuiltInInstanceId: return "InstanceId"; ++ case SpvBuiltInPrimitiveId: return "PrimitiveId"; ++ case SpvBuiltInInvocationId: return "InvocationId"; ++ case SpvBuiltInLayer: return "Layer"; ++ case SpvBuiltInViewportIndex: return "ViewportIndex"; ++ case SpvBuiltInTessLevelOuter: return "TessLevelOuter"; ++ case SpvBuiltInTessLevelInner: return "TessLevelInner"; ++ case SpvBuiltInTessCoord: return "TessCoord"; ++ case SpvBuiltInPatchVertices: return "PatchVertices"; ++ case SpvBuiltInFragCoord: return "FragCoord"; ++ case SpvBuiltInPointCoord: return "PointCoord"; ++ case SpvBuiltInFrontFacing: return "FrontFacing"; ++ case SpvBuiltInSampleId: return "SampleId"; ++ case SpvBuiltInSamplePosition: return "SamplePosition"; ++ case SpvBuiltInSampleMask: return "SampleMask"; ++ case SpvBuiltInFragDepth: return "FragDepth"; ++ case SpvBuiltInHelperInvocation: return "HelperInvocation"; ++ case SpvBuiltInNumWorkgroups: return "NumWorkgroups"; ++ case SpvBuiltInWorkgroupSize: return "WorkgroupSize"; ++ case SpvBuiltInWorkgroupId: return "WorkgroupId"; ++ case SpvBuiltInLocalInvocationId: return "LocalInvocationId"; ++ case SpvBuiltInGlobalInvocationId: return "GlobalInvocationId"; ++ case SpvBuiltInLocalInvocationIndex: return "LocalInvocationIndex"; ++ case SpvBuiltInWorkDim: return "WorkDim"; ++ case SpvBuiltInGlobalSize: return "GlobalSize"; ++ case SpvBuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; ++ case SpvBuiltInGlobalOffset: return "GlobalOffset"; ++ case SpvBuiltInGlobalLinearId: return "GlobalLinearId"; ++ case SpvBuiltInSubgroupSize: return "SubgroupSize"; ++ case SpvBuiltInSubgroupMaxSize: return "SubgroupMaxSize"; ++ case SpvBuiltInNumSubgroups: return "NumSubgroups"; ++ case SpvBuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; ++ case SpvBuiltInSubgroupId: return "SubgroupId"; ++ case SpvBuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; ++ case SpvBuiltInVertexIndex: return "VertexIndex"; ++ case SpvBuiltInInstanceIndex: return "InstanceIndex"; ++ case SpvBuiltInCoreIDARM: return "CoreIDARM"; ++ case SpvBuiltInCoreCountARM: return "CoreCountARM"; ++ case SpvBuiltInCoreMaxIDARM: return "CoreMaxIDARM"; ++ case SpvBuiltInWarpIDARM: return "WarpIDARM"; ++ case SpvBuiltInWarpMaxIDARM: return "WarpMaxIDARM"; ++ case SpvBuiltInSubgroupEqMask: return "SubgroupEqMask"; ++ case SpvBuiltInSubgroupGeMask: return "SubgroupGeMask"; ++ case SpvBuiltInSubgroupGtMask: return "SubgroupGtMask"; ++ case SpvBuiltInSubgroupLeMask: return "SubgroupLeMask"; ++ case SpvBuiltInSubgroupLtMask: return "SubgroupLtMask"; ++ case SpvBuiltInBaseVertex: return "BaseVertex"; ++ case SpvBuiltInBaseInstance: return "BaseInstance"; ++ case SpvBuiltInDrawIndex: return "DrawIndex"; ++ case SpvBuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; ++ case SpvBuiltInDeviceIndex: return "DeviceIndex"; ++ case SpvBuiltInViewIndex: return "ViewIndex"; ++ case SpvBuiltInShadingRateKHR: return "ShadingRateKHR"; ++ case SpvBuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; ++ case SpvBuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; ++ case SpvBuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; ++ case SpvBuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; ++ case SpvBuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; ++ case SpvBuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; ++ case SpvBuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; ++ case SpvBuiltInFragStencilRefEXT: return "FragStencilRefEXT"; ++ case SpvBuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; ++ case SpvBuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case SpvBuiltInViewportMaskNV: return "ViewportMaskNV"; ++ case SpvBuiltInSecondaryPositionNV: return "SecondaryPositionNV"; ++ case SpvBuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; ++ case SpvBuiltInPositionPerViewNV: return "PositionPerViewNV"; ++ case SpvBuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; ++ case SpvBuiltInFullyCoveredEXT: return "FullyCoveredEXT"; ++ case SpvBuiltInTaskCountNV: return "TaskCountNV"; ++ case SpvBuiltInPrimitiveCountNV: return "PrimitiveCountNV"; ++ case SpvBuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; ++ case SpvBuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; ++ case SpvBuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; ++ case SpvBuiltInLayerPerViewNV: return "LayerPerViewNV"; ++ case SpvBuiltInMeshViewCountNV: return "MeshViewCountNV"; ++ case SpvBuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; ++ case SpvBuiltInBaryCoordKHR: return "BaryCoordKHR"; ++ case SpvBuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; ++ case SpvBuiltInFragSizeEXT: return "FragSizeEXT"; ++ case SpvBuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; ++ case SpvBuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; ++ case SpvBuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; ++ case SpvBuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; ++ case SpvBuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; ++ case SpvBuiltInLaunchIdKHR: return "LaunchIdKHR"; ++ case SpvBuiltInLaunchSizeKHR: return "LaunchSizeKHR"; ++ case SpvBuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; ++ case SpvBuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; ++ case SpvBuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; ++ case SpvBuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; ++ case SpvBuiltInRayTminKHR: return "RayTminKHR"; ++ case SpvBuiltInRayTmaxKHR: return "RayTmaxKHR"; ++ case SpvBuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; ++ case SpvBuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; ++ case SpvBuiltInWorldToObjectKHR: return "WorldToObjectKHR"; ++ case SpvBuiltInHitTNV: return "HitTNV"; ++ case SpvBuiltInHitKindKHR: return "HitKindKHR"; ++ case SpvBuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; ++ case SpvBuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; ++ case SpvBuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; ++ case SpvBuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; ++ case SpvBuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; ++ case SpvBuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; ++ case SpvBuiltInWarpsPerSMNV: return "WarpsPerSMNV"; ++ case SpvBuiltInSMCountNV: return "SMCountNV"; ++ case SpvBuiltInWarpIDNV: return "WarpIDNV"; ++ case SpvBuiltInSMIDNV: return "SMIDNV"; ++ case SpvBuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; ++ case SpvBuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; ++ case SpvBuiltInCullMaskKHR: return "CullMaskKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvScopeToString(SpvScope value) { ++ switch (value) { ++ case SpvScopeCrossDevice: return "CrossDevice"; ++ case SpvScopeDevice: return "Device"; ++ case SpvScopeWorkgroup: return "Workgroup"; ++ case SpvScopeSubgroup: return "Subgroup"; ++ case SpvScopeInvocation: return "Invocation"; ++ case SpvScopeQueueFamily: return "QueueFamily"; ++ case SpvScopeShaderCallKHR: return "ShaderCallKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvGroupOperationToString(SpvGroupOperation value) { ++ switch (value) { ++ case SpvGroupOperationReduce: return "Reduce"; ++ case SpvGroupOperationInclusiveScan: return "InclusiveScan"; ++ case SpvGroupOperationExclusiveScan: return "ExclusiveScan"; ++ case SpvGroupOperationClusteredReduce: return "ClusteredReduce"; ++ case SpvGroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; ++ case SpvGroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; ++ case SpvGroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvKernelEnqueueFlagsToString(SpvKernelEnqueueFlags value) { ++ switch (value) { ++ case SpvKernelEnqueueFlagsNoWait: return "NoWait"; ++ case SpvKernelEnqueueFlagsWaitKernel: return "WaitKernel"; ++ case SpvKernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvCapabilityToString(SpvCapability value) { ++ switch (value) { ++ case SpvCapabilityMatrix: return "Matrix"; ++ case SpvCapabilityShader: return "Shader"; ++ case SpvCapabilityGeometry: return "Geometry"; ++ case SpvCapabilityTessellation: return "Tessellation"; ++ case SpvCapabilityAddresses: return "Addresses"; ++ case SpvCapabilityLinkage: return "Linkage"; ++ case SpvCapabilityKernel: return "Kernel"; ++ case SpvCapabilityVector16: return "Vector16"; ++ case SpvCapabilityFloat16Buffer: return "Float16Buffer"; ++ case SpvCapabilityFloat16: return "Float16"; ++ case SpvCapabilityFloat64: return "Float64"; ++ case SpvCapabilityInt64: return "Int64"; ++ case SpvCapabilityInt64Atomics: return "Int64Atomics"; ++ case SpvCapabilityImageBasic: return "ImageBasic"; ++ case SpvCapabilityImageReadWrite: return "ImageReadWrite"; ++ case SpvCapabilityImageMipmap: return "ImageMipmap"; ++ case SpvCapabilityPipes: return "Pipes"; ++ case SpvCapabilityGroups: return "Groups"; ++ case SpvCapabilityDeviceEnqueue: return "DeviceEnqueue"; ++ case SpvCapabilityLiteralSampler: return "LiteralSampler"; ++ case SpvCapabilityAtomicStorage: return "AtomicStorage"; ++ case SpvCapabilityInt16: return "Int16"; ++ case SpvCapabilityTessellationPointSize: return "TessellationPointSize"; ++ case SpvCapabilityGeometryPointSize: return "GeometryPointSize"; ++ case SpvCapabilityImageGatherExtended: return "ImageGatherExtended"; ++ case SpvCapabilityStorageImageMultisample: return "StorageImageMultisample"; ++ case SpvCapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; ++ case SpvCapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; ++ case SpvCapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; ++ case SpvCapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; ++ case SpvCapabilityClipDistance: return "ClipDistance"; ++ case SpvCapabilityCullDistance: return "CullDistance"; ++ case SpvCapabilityImageCubeArray: return "ImageCubeArray"; ++ case SpvCapabilitySampleRateShading: return "SampleRateShading"; ++ case SpvCapabilityImageRect: return "ImageRect"; ++ case SpvCapabilitySampledRect: return "SampledRect"; ++ case SpvCapabilityGenericPointer: return "GenericPointer"; ++ case SpvCapabilityInt8: return "Int8"; ++ case SpvCapabilityInputAttachment: return "InputAttachment"; ++ case SpvCapabilitySparseResidency: return "SparseResidency"; ++ case SpvCapabilityMinLod: return "MinLod"; ++ case SpvCapabilitySampled1D: return "Sampled1D"; ++ case SpvCapabilityImage1D: return "Image1D"; ++ case SpvCapabilitySampledCubeArray: return "SampledCubeArray"; ++ case SpvCapabilitySampledBuffer: return "SampledBuffer"; ++ case SpvCapabilityImageBuffer: return "ImageBuffer"; ++ case SpvCapabilityImageMSArray: return "ImageMSArray"; ++ case SpvCapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; ++ case SpvCapabilityImageQuery: return "ImageQuery"; ++ case SpvCapabilityDerivativeControl: return "DerivativeControl"; ++ case SpvCapabilityInterpolationFunction: return "InterpolationFunction"; ++ case SpvCapabilityTransformFeedback: return "TransformFeedback"; ++ case SpvCapabilityGeometryStreams: return "GeometryStreams"; ++ case SpvCapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; ++ case SpvCapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; ++ case SpvCapabilityMultiViewport: return "MultiViewport"; ++ case SpvCapabilitySubgroupDispatch: return "SubgroupDispatch"; ++ case SpvCapabilityNamedBarrier: return "NamedBarrier"; ++ case SpvCapabilityPipeStorage: return "PipeStorage"; ++ case SpvCapabilityGroupNonUniform: return "GroupNonUniform"; ++ case SpvCapabilityGroupNonUniformVote: return "GroupNonUniformVote"; ++ case SpvCapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; ++ case SpvCapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; ++ case SpvCapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; ++ case SpvCapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; ++ case SpvCapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; ++ case SpvCapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; ++ case SpvCapabilityShaderLayer: return "ShaderLayer"; ++ case SpvCapabilityShaderViewportIndex: return "ShaderViewportIndex"; ++ case SpvCapabilityUniformDecoration: return "UniformDecoration"; ++ case SpvCapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; ++ case SpvCapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; ++ case SpvCapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; ++ case SpvCapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; ++ case SpvCapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; ++ case SpvCapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; ++ case SpvCapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; ++ case SpvCapabilityDrawParameters: return "DrawParameters"; ++ case SpvCapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; ++ case SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; ++ case SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; ++ case SpvCapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; ++ case SpvCapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; ++ case SpvCapabilityStorageUniform16: return "StorageUniform16"; ++ case SpvCapabilityStoragePushConstant16: return "StoragePushConstant16"; ++ case SpvCapabilityStorageInputOutput16: return "StorageInputOutput16"; ++ case SpvCapabilityDeviceGroup: return "DeviceGroup"; ++ case SpvCapabilityMultiView: return "MultiView"; ++ case SpvCapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; ++ case SpvCapabilityVariablePointers: return "VariablePointers"; ++ case SpvCapabilityAtomicStorageOps: return "AtomicStorageOps"; ++ case SpvCapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; ++ case SpvCapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; ++ case SpvCapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; ++ case SpvCapabilityStoragePushConstant8: return "StoragePushConstant8"; ++ case SpvCapabilityDenormPreserve: return "DenormPreserve"; ++ case SpvCapabilityDenormFlushToZero: return "DenormFlushToZero"; ++ case SpvCapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case SpvCapabilityRoundingModeRTE: return "RoundingModeRTE"; ++ case SpvCapabilityRoundingModeRTZ: return "RoundingModeRTZ"; ++ case SpvCapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; ++ case SpvCapabilityRayQueryKHR: return "RayQueryKHR"; ++ case SpvCapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; ++ case SpvCapabilityRayTracingKHR: return "RayTracingKHR"; ++ case SpvCapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; ++ case SpvCapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; ++ case SpvCapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; ++ case SpvCapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; ++ case SpvCapabilityFloat16ImageAMD: return "Float16ImageAMD"; ++ case SpvCapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; ++ case SpvCapabilityFragmentMaskAMD: return "FragmentMaskAMD"; ++ case SpvCapabilityStencilExportEXT: return "StencilExportEXT"; ++ case SpvCapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; ++ case SpvCapabilityInt64ImageEXT: return "Int64ImageEXT"; ++ case SpvCapabilityShaderClockKHR: return "ShaderClockKHR"; ++ case SpvCapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; ++ case SpvCapabilityQuadControlKHR: return "QuadControlKHR"; ++ case SpvCapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; ++ case SpvCapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; ++ case SpvCapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; ++ case SpvCapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; ++ case SpvCapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; ++ case SpvCapabilityPerViewAttributesNV: return "PerViewAttributesNV"; ++ case SpvCapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; ++ case SpvCapabilityMeshShadingNV: return "MeshShadingNV"; ++ case SpvCapabilityImageFootprintNV: return "ImageFootprintNV"; ++ case SpvCapabilityMeshShadingEXT: return "MeshShadingEXT"; ++ case SpvCapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; ++ case SpvCapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; ++ case SpvCapabilityFragmentDensityEXT: return "FragmentDensityEXT"; ++ case SpvCapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; ++ case SpvCapabilityShaderNonUniform: return "ShaderNonUniform"; ++ case SpvCapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; ++ case SpvCapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; ++ case SpvCapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; ++ case SpvCapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; ++ case SpvCapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; ++ case SpvCapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; ++ case SpvCapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; ++ case SpvCapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; ++ case SpvCapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; ++ case SpvCapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; ++ case SpvCapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; ++ case SpvCapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; ++ case SpvCapabilityRayTracingNV: return "RayTracingNV"; ++ case SpvCapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; ++ case SpvCapabilityVulkanMemoryModel: return "VulkanMemoryModel"; ++ case SpvCapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; ++ case SpvCapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; ++ case SpvCapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; ++ case SpvCapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; ++ case SpvCapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; ++ case SpvCapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; ++ case SpvCapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; ++ case SpvCapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; ++ case SpvCapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; ++ case SpvCapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; ++ case SpvCapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; ++ case SpvCapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; ++ case SpvCapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; ++ case SpvCapabilityBindlessTextureNV: return "BindlessTextureNV"; ++ case SpvCapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; ++ case SpvCapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; ++ case SpvCapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; ++ case SpvCapabilityRawAccessChainsNV: return "RawAccessChainsNV"; ++ case SpvCapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; ++ case SpvCapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; ++ case SpvCapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; ++ case SpvCapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; ++ case SpvCapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; ++ case SpvCapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; ++ case SpvCapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; ++ case SpvCapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; ++ case SpvCapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; ++ case SpvCapabilityAsmINTEL: return "AsmINTEL"; ++ case SpvCapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; ++ case SpvCapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; ++ case SpvCapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; ++ case SpvCapabilityVectorComputeINTEL: return "VectorComputeINTEL"; ++ case SpvCapabilityVectorAnyINTEL: return "VectorAnyINTEL"; ++ case SpvCapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; ++ case SpvCapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; ++ case SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; ++ case SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; ++ case SpvCapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; ++ case SpvCapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; ++ case SpvCapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; ++ case SpvCapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; ++ case SpvCapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; ++ case SpvCapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; ++ case SpvCapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; ++ case SpvCapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; ++ case SpvCapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; ++ case SpvCapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; ++ case SpvCapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; ++ case SpvCapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; ++ case SpvCapabilityLoopFuseINTEL: return "LoopFuseINTEL"; ++ case SpvCapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; ++ case SpvCapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; ++ case SpvCapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; ++ case SpvCapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; ++ case SpvCapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; ++ case SpvCapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; ++ case SpvCapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; ++ case SpvCapabilityIOPipesINTEL: return "IOPipesINTEL"; ++ case SpvCapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; ++ case SpvCapabilityFPGARegINTEL: return "FPGARegINTEL"; ++ case SpvCapabilityDotProductInputAll: return "DotProductInputAll"; ++ case SpvCapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; ++ case SpvCapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; ++ case SpvCapabilityDotProduct: return "DotProduct"; ++ case SpvCapabilityRayCullMaskKHR: return "RayCullMaskKHR"; ++ case SpvCapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; ++ case SpvCapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; ++ case SpvCapabilityBitInstructions: return "BitInstructions"; ++ case SpvCapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; ++ case SpvCapabilityFloatControls2: return "FloatControls2"; ++ case SpvCapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; ++ case SpvCapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; ++ case SpvCapabilityLongCompositesINTEL: return "LongCompositesINTEL"; ++ case SpvCapabilityOptNoneINTEL: return "OptNoneINTEL"; ++ case SpvCapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; ++ case SpvCapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; ++ case SpvCapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; ++ case SpvCapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; ++ case SpvCapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; ++ case SpvCapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; ++ case SpvCapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; ++ case SpvCapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; ++ case SpvCapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; ++ case SpvCapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; ++ case SpvCapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; ++ case SpvCapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; ++ case SpvCapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; ++ case SpvCapabilityCacheControlsINTEL: return "CacheControlsINTEL"; ++ case SpvCapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvRayQueryIntersectionToString(SpvRayQueryIntersection value) { ++ switch (value) { ++ case SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; ++ case SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvRayQueryCommittedIntersectionTypeToString(SpvRayQueryCommittedIntersectionType value) { ++ switch (value) { ++ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; ++ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; ++ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvRayQueryCandidateIntersectionTypeToString(SpvRayQueryCandidateIntersectionType value) { ++ switch (value) { ++ case SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; ++ case SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvFPDenormModeToString(SpvFPDenormMode value) { ++ switch (value) { ++ case SpvFPDenormModePreserve: return "Preserve"; ++ case SpvFPDenormModeFlushToZero: return "FlushToZero"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvFPOperationModeToString(SpvFPOperationMode value) { ++ switch (value) { ++ case SpvFPOperationModeIEEE: return "IEEE"; ++ case SpvFPOperationModeALT: return "ALT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvQuantizationModesToString(SpvQuantizationModes value) { ++ switch (value) { ++ case SpvQuantizationModesTRN: return "TRN"; ++ case SpvQuantizationModesTRN_ZERO: return "TRN_ZERO"; ++ case SpvQuantizationModesRND: return "RND"; ++ case SpvQuantizationModesRND_ZERO: return "RND_ZERO"; ++ case SpvQuantizationModesRND_INF: return "RND_INF"; ++ case SpvQuantizationModesRND_MIN_INF: return "RND_MIN_INF"; ++ case SpvQuantizationModesRND_CONV: return "RND_CONV"; ++ case SpvQuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvOverflowModesToString(SpvOverflowModes value) { ++ switch (value) { ++ case SpvOverflowModesWRAP: return "WRAP"; ++ case SpvOverflowModesSAT: return "SAT"; ++ case SpvOverflowModesSAT_ZERO: return "SAT_ZERO"; ++ case SpvOverflowModesSAT_SYM: return "SAT_SYM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvPackedVectorFormatToString(SpvPackedVectorFormat value) { ++ switch (value) { ++ case SpvPackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvCooperativeMatrixLayoutToString(SpvCooperativeMatrixLayout value) { ++ switch (value) { ++ case SpvCooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; ++ case SpvCooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; ++ case SpvCooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; ++ case SpvCooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvCooperativeMatrixUseToString(SpvCooperativeMatrixUse value) { ++ switch (value) { ++ case SpvCooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; ++ case SpvCooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; ++ case SpvCooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvInitializationModeQualifierToString(SpvInitializationModeQualifier value) { ++ switch (value) { ++ case SpvInitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; ++ case SpvInitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvHostAccessQualifierToString(SpvHostAccessQualifier value) { ++ switch (value) { ++ case SpvHostAccessQualifierNoneINTEL: return "NoneINTEL"; ++ case SpvHostAccessQualifierReadINTEL: return "ReadINTEL"; ++ case SpvHostAccessQualifierWriteINTEL: return "WriteINTEL"; ++ case SpvHostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvLoadCacheControlToString(SpvLoadCacheControl value) { ++ switch (value) { ++ case SpvLoadCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case SpvLoadCacheControlCachedINTEL: return "CachedINTEL"; ++ case SpvLoadCacheControlStreamingINTEL: return "StreamingINTEL"; ++ case SpvLoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; ++ case SpvLoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvStoreCacheControlToString(SpvStoreCacheControl value) { ++ switch (value) { ++ case SpvStoreCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case SpvStoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; ++ case SpvStoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; ++ case SpvStoreCacheControlStreamingINTEL: return "StreamingINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvNamedMaximumNumberOfRegistersToString(SpvNamedMaximumNumberOfRegisters value) { ++ switch (value) { ++ case SpvNamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SpvOpToString(SpvOp value) { ++ switch (value) { ++ case SpvOpNop: return "OpNop"; ++ case SpvOpUndef: return "OpUndef"; ++ case SpvOpSourceContinued: return "OpSourceContinued"; ++ case SpvOpSource: return "OpSource"; ++ case SpvOpSourceExtension: return "OpSourceExtension"; ++ case SpvOpName: return "OpName"; ++ case SpvOpMemberName: return "OpMemberName"; ++ case SpvOpString: return "OpString"; ++ case SpvOpLine: return "OpLine"; ++ case SpvOpExtension: return "OpExtension"; ++ case SpvOpExtInstImport: return "OpExtInstImport"; ++ case SpvOpExtInst: return "OpExtInst"; ++ case SpvOpMemoryModel: return "OpMemoryModel"; ++ case SpvOpEntryPoint: return "OpEntryPoint"; ++ case SpvOpExecutionMode: return "OpExecutionMode"; ++ case SpvOpCapability: return "OpCapability"; ++ case SpvOpTypeVoid: return "OpTypeVoid"; ++ case SpvOpTypeBool: return "OpTypeBool"; ++ case SpvOpTypeInt: return "OpTypeInt"; ++ case SpvOpTypeFloat: return "OpTypeFloat"; ++ case SpvOpTypeVector: return "OpTypeVector"; ++ case SpvOpTypeMatrix: return "OpTypeMatrix"; ++ case SpvOpTypeImage: return "OpTypeImage"; ++ case SpvOpTypeSampler: return "OpTypeSampler"; ++ case SpvOpTypeSampledImage: return "OpTypeSampledImage"; ++ case SpvOpTypeArray: return "OpTypeArray"; ++ case SpvOpTypeRuntimeArray: return "OpTypeRuntimeArray"; ++ case SpvOpTypeStruct: return "OpTypeStruct"; ++ case SpvOpTypeOpaque: return "OpTypeOpaque"; ++ case SpvOpTypePointer: return "OpTypePointer"; ++ case SpvOpTypeFunction: return "OpTypeFunction"; ++ case SpvOpTypeEvent: return "OpTypeEvent"; ++ case SpvOpTypeDeviceEvent: return "OpTypeDeviceEvent"; ++ case SpvOpTypeReserveId: return "OpTypeReserveId"; ++ case SpvOpTypeQueue: return "OpTypeQueue"; ++ case SpvOpTypePipe: return "OpTypePipe"; ++ case SpvOpTypeForwardPointer: return "OpTypeForwardPointer"; ++ case SpvOpConstantTrue: return "OpConstantTrue"; ++ case SpvOpConstantFalse: return "OpConstantFalse"; ++ case SpvOpConstant: return "OpConstant"; ++ case SpvOpConstantComposite: return "OpConstantComposite"; ++ case SpvOpConstantSampler: return "OpConstantSampler"; ++ case SpvOpConstantNull: return "OpConstantNull"; ++ case SpvOpSpecConstantTrue: return "OpSpecConstantTrue"; ++ case SpvOpSpecConstantFalse: return "OpSpecConstantFalse"; ++ case SpvOpSpecConstant: return "OpSpecConstant"; ++ case SpvOpSpecConstantComposite: return "OpSpecConstantComposite"; ++ case SpvOpSpecConstantOp: return "OpSpecConstantOp"; ++ case SpvOpFunction: return "OpFunction"; ++ case SpvOpFunctionParameter: return "OpFunctionParameter"; ++ case SpvOpFunctionEnd: return "OpFunctionEnd"; ++ case SpvOpFunctionCall: return "OpFunctionCall"; ++ case SpvOpVariable: return "OpVariable"; ++ case SpvOpImageTexelPointer: return "OpImageTexelPointer"; ++ case SpvOpLoad: return "OpLoad"; ++ case SpvOpStore: return "OpStore"; ++ case SpvOpCopyMemory: return "OpCopyMemory"; ++ case SpvOpCopyMemorySized: return "OpCopyMemorySized"; ++ case SpvOpAccessChain: return "OpAccessChain"; ++ case SpvOpInBoundsAccessChain: return "OpInBoundsAccessChain"; ++ case SpvOpPtrAccessChain: return "OpPtrAccessChain"; ++ case SpvOpArrayLength: return "OpArrayLength"; ++ case SpvOpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; ++ case SpvOpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; ++ case SpvOpDecorate: return "OpDecorate"; ++ case SpvOpMemberDecorate: return "OpMemberDecorate"; ++ case SpvOpDecorationGroup: return "OpDecorationGroup"; ++ case SpvOpGroupDecorate: return "OpGroupDecorate"; ++ case SpvOpGroupMemberDecorate: return "OpGroupMemberDecorate"; ++ case SpvOpVectorExtractDynamic: return "OpVectorExtractDynamic"; ++ case SpvOpVectorInsertDynamic: return "OpVectorInsertDynamic"; ++ case SpvOpVectorShuffle: return "OpVectorShuffle"; ++ case SpvOpCompositeConstruct: return "OpCompositeConstruct"; ++ case SpvOpCompositeExtract: return "OpCompositeExtract"; ++ case SpvOpCompositeInsert: return "OpCompositeInsert"; ++ case SpvOpCopyObject: return "OpCopyObject"; ++ case SpvOpTranspose: return "OpTranspose"; ++ case SpvOpSampledImage: return "OpSampledImage"; ++ case SpvOpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; ++ case SpvOpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; ++ case SpvOpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; ++ case SpvOpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; ++ case SpvOpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; ++ case SpvOpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; ++ case SpvOpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; ++ case SpvOpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; ++ case SpvOpImageFetch: return "OpImageFetch"; ++ case SpvOpImageGather: return "OpImageGather"; ++ case SpvOpImageDrefGather: return "OpImageDrefGather"; ++ case SpvOpImageRead: return "OpImageRead"; ++ case SpvOpImageWrite: return "OpImageWrite"; ++ case SpvOpImage: return "OpImage"; ++ case SpvOpImageQueryFormat: return "OpImageQueryFormat"; ++ case SpvOpImageQueryOrder: return "OpImageQueryOrder"; ++ case SpvOpImageQuerySizeLod: return "OpImageQuerySizeLod"; ++ case SpvOpImageQuerySize: return "OpImageQuerySize"; ++ case SpvOpImageQueryLod: return "OpImageQueryLod"; ++ case SpvOpImageQueryLevels: return "OpImageQueryLevels"; ++ case SpvOpImageQuerySamples: return "OpImageQuerySamples"; ++ case SpvOpConvertFToU: return "OpConvertFToU"; ++ case SpvOpConvertFToS: return "OpConvertFToS"; ++ case SpvOpConvertSToF: return "OpConvertSToF"; ++ case SpvOpConvertUToF: return "OpConvertUToF"; ++ case SpvOpUConvert: return "OpUConvert"; ++ case SpvOpSConvert: return "OpSConvert"; ++ case SpvOpFConvert: return "OpFConvert"; ++ case SpvOpQuantizeToF16: return "OpQuantizeToF16"; ++ case SpvOpConvertPtrToU: return "OpConvertPtrToU"; ++ case SpvOpSatConvertSToU: return "OpSatConvertSToU"; ++ case SpvOpSatConvertUToS: return "OpSatConvertUToS"; ++ case SpvOpConvertUToPtr: return "OpConvertUToPtr"; ++ case SpvOpPtrCastToGeneric: return "OpPtrCastToGeneric"; ++ case SpvOpGenericCastToPtr: return "OpGenericCastToPtr"; ++ case SpvOpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; ++ case SpvOpBitcast: return "OpBitcast"; ++ case SpvOpSNegate: return "OpSNegate"; ++ case SpvOpFNegate: return "OpFNegate"; ++ case SpvOpIAdd: return "OpIAdd"; ++ case SpvOpFAdd: return "OpFAdd"; ++ case SpvOpISub: return "OpISub"; ++ case SpvOpFSub: return "OpFSub"; ++ case SpvOpIMul: return "OpIMul"; ++ case SpvOpFMul: return "OpFMul"; ++ case SpvOpUDiv: return "OpUDiv"; ++ case SpvOpSDiv: return "OpSDiv"; ++ case SpvOpFDiv: return "OpFDiv"; ++ case SpvOpUMod: return "OpUMod"; ++ case SpvOpSRem: return "OpSRem"; ++ case SpvOpSMod: return "OpSMod"; ++ case SpvOpFRem: return "OpFRem"; ++ case SpvOpFMod: return "OpFMod"; ++ case SpvOpVectorTimesScalar: return "OpVectorTimesScalar"; ++ case SpvOpMatrixTimesScalar: return "OpMatrixTimesScalar"; ++ case SpvOpVectorTimesMatrix: return "OpVectorTimesMatrix"; ++ case SpvOpMatrixTimesVector: return "OpMatrixTimesVector"; ++ case SpvOpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; ++ case SpvOpOuterProduct: return "OpOuterProduct"; ++ case SpvOpDot: return "OpDot"; ++ case SpvOpIAddCarry: return "OpIAddCarry"; ++ case SpvOpISubBorrow: return "OpISubBorrow"; ++ case SpvOpUMulExtended: return "OpUMulExtended"; ++ case SpvOpSMulExtended: return "OpSMulExtended"; ++ case SpvOpAny: return "OpAny"; ++ case SpvOpAll: return "OpAll"; ++ case SpvOpIsNan: return "OpIsNan"; ++ case SpvOpIsInf: return "OpIsInf"; ++ case SpvOpIsFinite: return "OpIsFinite"; ++ case SpvOpIsNormal: return "OpIsNormal"; ++ case SpvOpSignBitSet: return "OpSignBitSet"; ++ case SpvOpLessOrGreater: return "OpLessOrGreater"; ++ case SpvOpOrdered: return "OpOrdered"; ++ case SpvOpUnordered: return "OpUnordered"; ++ case SpvOpLogicalEqual: return "OpLogicalEqual"; ++ case SpvOpLogicalNotEqual: return "OpLogicalNotEqual"; ++ case SpvOpLogicalOr: return "OpLogicalOr"; ++ case SpvOpLogicalAnd: return "OpLogicalAnd"; ++ case SpvOpLogicalNot: return "OpLogicalNot"; ++ case SpvOpSelect: return "OpSelect"; ++ case SpvOpIEqual: return "OpIEqual"; ++ case SpvOpINotEqual: return "OpINotEqual"; ++ case SpvOpUGreaterThan: return "OpUGreaterThan"; ++ case SpvOpSGreaterThan: return "OpSGreaterThan"; ++ case SpvOpUGreaterThanEqual: return "OpUGreaterThanEqual"; ++ case SpvOpSGreaterThanEqual: return "OpSGreaterThanEqual"; ++ case SpvOpULessThan: return "OpULessThan"; ++ case SpvOpSLessThan: return "OpSLessThan"; ++ case SpvOpULessThanEqual: return "OpULessThanEqual"; ++ case SpvOpSLessThanEqual: return "OpSLessThanEqual"; ++ case SpvOpFOrdEqual: return "OpFOrdEqual"; ++ case SpvOpFUnordEqual: return "OpFUnordEqual"; ++ case SpvOpFOrdNotEqual: return "OpFOrdNotEqual"; ++ case SpvOpFUnordNotEqual: return "OpFUnordNotEqual"; ++ case SpvOpFOrdLessThan: return "OpFOrdLessThan"; ++ case SpvOpFUnordLessThan: return "OpFUnordLessThan"; ++ case SpvOpFOrdGreaterThan: return "OpFOrdGreaterThan"; ++ case SpvOpFUnordGreaterThan: return "OpFUnordGreaterThan"; ++ case SpvOpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; ++ case SpvOpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; ++ case SpvOpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; ++ case SpvOpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; ++ case SpvOpShiftRightLogical: return "OpShiftRightLogical"; ++ case SpvOpShiftRightArithmetic: return "OpShiftRightArithmetic"; ++ case SpvOpShiftLeftLogical: return "OpShiftLeftLogical"; ++ case SpvOpBitwiseOr: return "OpBitwiseOr"; ++ case SpvOpBitwiseXor: return "OpBitwiseXor"; ++ case SpvOpBitwiseAnd: return "OpBitwiseAnd"; ++ case SpvOpNot: return "OpNot"; ++ case SpvOpBitFieldInsert: return "OpBitFieldInsert"; ++ case SpvOpBitFieldSExtract: return "OpBitFieldSExtract"; ++ case SpvOpBitFieldUExtract: return "OpBitFieldUExtract"; ++ case SpvOpBitReverse: return "OpBitReverse"; ++ case SpvOpBitCount: return "OpBitCount"; ++ case SpvOpDPdx: return "OpDPdx"; ++ case SpvOpDPdy: return "OpDPdy"; ++ case SpvOpFwidth: return "OpFwidth"; ++ case SpvOpDPdxFine: return "OpDPdxFine"; ++ case SpvOpDPdyFine: return "OpDPdyFine"; ++ case SpvOpFwidthFine: return "OpFwidthFine"; ++ case SpvOpDPdxCoarse: return "OpDPdxCoarse"; ++ case SpvOpDPdyCoarse: return "OpDPdyCoarse"; ++ case SpvOpFwidthCoarse: return "OpFwidthCoarse"; ++ case SpvOpEmitVertex: return "OpEmitVertex"; ++ case SpvOpEndPrimitive: return "OpEndPrimitive"; ++ case SpvOpEmitStreamVertex: return "OpEmitStreamVertex"; ++ case SpvOpEndStreamPrimitive: return "OpEndStreamPrimitive"; ++ case SpvOpControlBarrier: return "OpControlBarrier"; ++ case SpvOpMemoryBarrier: return "OpMemoryBarrier"; ++ case SpvOpAtomicLoad: return "OpAtomicLoad"; ++ case SpvOpAtomicStore: return "OpAtomicStore"; ++ case SpvOpAtomicExchange: return "OpAtomicExchange"; ++ case SpvOpAtomicCompareExchange: return "OpAtomicCompareExchange"; ++ case SpvOpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; ++ case SpvOpAtomicIIncrement: return "OpAtomicIIncrement"; ++ case SpvOpAtomicIDecrement: return "OpAtomicIDecrement"; ++ case SpvOpAtomicIAdd: return "OpAtomicIAdd"; ++ case SpvOpAtomicISub: return "OpAtomicISub"; ++ case SpvOpAtomicSMin: return "OpAtomicSMin"; ++ case SpvOpAtomicUMin: return "OpAtomicUMin"; ++ case SpvOpAtomicSMax: return "OpAtomicSMax"; ++ case SpvOpAtomicUMax: return "OpAtomicUMax"; ++ case SpvOpAtomicAnd: return "OpAtomicAnd"; ++ case SpvOpAtomicOr: return "OpAtomicOr"; ++ case SpvOpAtomicXor: return "OpAtomicXor"; ++ case SpvOpPhi: return "OpPhi"; ++ case SpvOpLoopMerge: return "OpLoopMerge"; ++ case SpvOpSelectionMerge: return "OpSelectionMerge"; ++ case SpvOpLabel: return "OpLabel"; ++ case SpvOpBranch: return "OpBranch"; ++ case SpvOpBranchConditional: return "OpBranchConditional"; ++ case SpvOpSwitch: return "OpSwitch"; ++ case SpvOpKill: return "OpKill"; ++ case SpvOpReturn: return "OpReturn"; ++ case SpvOpReturnValue: return "OpReturnValue"; ++ case SpvOpUnreachable: return "OpUnreachable"; ++ case SpvOpLifetimeStart: return "OpLifetimeStart"; ++ case SpvOpLifetimeStop: return "OpLifetimeStop"; ++ case SpvOpGroupAsyncCopy: return "OpGroupAsyncCopy"; ++ case SpvOpGroupWaitEvents: return "OpGroupWaitEvents"; ++ case SpvOpGroupAll: return "OpGroupAll"; ++ case SpvOpGroupAny: return "OpGroupAny"; ++ case SpvOpGroupBroadcast: return "OpGroupBroadcast"; ++ case SpvOpGroupIAdd: return "OpGroupIAdd"; ++ case SpvOpGroupFAdd: return "OpGroupFAdd"; ++ case SpvOpGroupFMin: return "OpGroupFMin"; ++ case SpvOpGroupUMin: return "OpGroupUMin"; ++ case SpvOpGroupSMin: return "OpGroupSMin"; ++ case SpvOpGroupFMax: return "OpGroupFMax"; ++ case SpvOpGroupUMax: return "OpGroupUMax"; ++ case SpvOpGroupSMax: return "OpGroupSMax"; ++ case SpvOpReadPipe: return "OpReadPipe"; ++ case SpvOpWritePipe: return "OpWritePipe"; ++ case SpvOpReservedReadPipe: return "OpReservedReadPipe"; ++ case SpvOpReservedWritePipe: return "OpReservedWritePipe"; ++ case SpvOpReserveReadPipePackets: return "OpReserveReadPipePackets"; ++ case SpvOpReserveWritePipePackets: return "OpReserveWritePipePackets"; ++ case SpvOpCommitReadPipe: return "OpCommitReadPipe"; ++ case SpvOpCommitWritePipe: return "OpCommitWritePipe"; ++ case SpvOpIsValidReserveId: return "OpIsValidReserveId"; ++ case SpvOpGetNumPipePackets: return "OpGetNumPipePackets"; ++ case SpvOpGetMaxPipePackets: return "OpGetMaxPipePackets"; ++ case SpvOpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; ++ case SpvOpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; ++ case SpvOpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; ++ case SpvOpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; ++ case SpvOpEnqueueMarker: return "OpEnqueueMarker"; ++ case SpvOpEnqueueKernel: return "OpEnqueueKernel"; ++ case SpvOpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; ++ case SpvOpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; ++ case SpvOpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; ++ case SpvOpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; ++ case SpvOpRetainEvent: return "OpRetainEvent"; ++ case SpvOpReleaseEvent: return "OpReleaseEvent"; ++ case SpvOpCreateUserEvent: return "OpCreateUserEvent"; ++ case SpvOpIsValidEvent: return "OpIsValidEvent"; ++ case SpvOpSetUserEventStatus: return "OpSetUserEventStatus"; ++ case SpvOpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; ++ case SpvOpGetDefaultQueue: return "OpGetDefaultQueue"; ++ case SpvOpBuildNDRange: return "OpBuildNDRange"; ++ case SpvOpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; ++ case SpvOpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; ++ case SpvOpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; ++ case SpvOpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; ++ case SpvOpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; ++ case SpvOpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; ++ case SpvOpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; ++ case SpvOpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; ++ case SpvOpImageSparseFetch: return "OpImageSparseFetch"; ++ case SpvOpImageSparseGather: return "OpImageSparseGather"; ++ case SpvOpImageSparseDrefGather: return "OpImageSparseDrefGather"; ++ case SpvOpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; ++ case SpvOpNoLine: return "OpNoLine"; ++ case SpvOpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; ++ case SpvOpAtomicFlagClear: return "OpAtomicFlagClear"; ++ case SpvOpImageSparseRead: return "OpImageSparseRead"; ++ case SpvOpSizeOf: return "OpSizeOf"; ++ case SpvOpTypePipeStorage: return "OpTypePipeStorage"; ++ case SpvOpConstantPipeStorage: return "OpConstantPipeStorage"; ++ case SpvOpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; ++ case SpvOpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; ++ case SpvOpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; ++ case SpvOpTypeNamedBarrier: return "OpTypeNamedBarrier"; ++ case SpvOpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; ++ case SpvOpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; ++ case SpvOpModuleProcessed: return "OpModuleProcessed"; ++ case SpvOpExecutionModeId: return "OpExecutionModeId"; ++ case SpvOpDecorateId: return "OpDecorateId"; ++ case SpvOpGroupNonUniformElect: return "OpGroupNonUniformElect"; ++ case SpvOpGroupNonUniformAll: return "OpGroupNonUniformAll"; ++ case SpvOpGroupNonUniformAny: return "OpGroupNonUniformAny"; ++ case SpvOpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; ++ case SpvOpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; ++ case SpvOpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; ++ case SpvOpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; ++ case SpvOpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; ++ case SpvOpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; ++ case SpvOpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; ++ case SpvOpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; ++ case SpvOpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; ++ case SpvOpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; ++ case SpvOpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; ++ case SpvOpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; ++ case SpvOpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; ++ case SpvOpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; ++ case SpvOpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; ++ case SpvOpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; ++ case SpvOpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; ++ case SpvOpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; ++ case SpvOpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; ++ case SpvOpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; ++ case SpvOpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; ++ case SpvOpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; ++ case SpvOpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; ++ case SpvOpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; ++ case SpvOpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; ++ case SpvOpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; ++ case SpvOpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; ++ case SpvOpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; ++ case SpvOpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; ++ case SpvOpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; ++ case SpvOpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; ++ case SpvOpCopyLogical: return "OpCopyLogical"; ++ case SpvOpPtrEqual: return "OpPtrEqual"; ++ case SpvOpPtrNotEqual: return "OpPtrNotEqual"; ++ case SpvOpPtrDiff: return "OpPtrDiff"; ++ case SpvOpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; ++ case SpvOpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; ++ case SpvOpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; ++ case SpvOpTerminateInvocation: return "OpTerminateInvocation"; ++ case SpvOpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; ++ case SpvOpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; ++ case SpvOpSubgroupAllKHR: return "OpSubgroupAllKHR"; ++ case SpvOpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; ++ case SpvOpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; ++ case SpvOpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; ++ case SpvOpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; ++ case SpvOpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; ++ case SpvOpTraceRayKHR: return "OpTraceRayKHR"; ++ case SpvOpExecuteCallableKHR: return "OpExecuteCallableKHR"; ++ case SpvOpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; ++ case SpvOpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; ++ case SpvOpTerminateRayKHR: return "OpTerminateRayKHR"; ++ case SpvOpSDot: return "OpSDot"; ++ case SpvOpUDot: return "OpUDot"; ++ case SpvOpSUDot: return "OpSUDot"; ++ case SpvOpSDotAccSat: return "OpSDotAccSat"; ++ case SpvOpUDotAccSat: return "OpUDotAccSat"; ++ case SpvOpSUDotAccSat: return "OpSUDotAccSat"; ++ case SpvOpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; ++ case SpvOpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; ++ case SpvOpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; ++ case SpvOpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; ++ case SpvOpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; ++ case SpvOpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; ++ case SpvOpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; ++ case SpvOpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; ++ case SpvOpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; ++ case SpvOpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; ++ case SpvOpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; ++ case SpvOpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; ++ case SpvOpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; ++ case SpvOpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; ++ case SpvOpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; ++ case SpvOpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; ++ case SpvOpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; ++ case SpvOpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; ++ case SpvOpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; ++ case SpvOpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; ++ case SpvOpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; ++ case SpvOpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; ++ case SpvOpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; ++ case SpvOpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; ++ case SpvOpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; ++ case SpvOpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; ++ case SpvOpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; ++ case SpvOpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; ++ case SpvOpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; ++ case SpvOpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; ++ case SpvOpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; ++ case SpvOpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; ++ case SpvOpFragmentFetchAMD: return "OpFragmentFetchAMD"; ++ case SpvOpReadClockKHR: return "OpReadClockKHR"; ++ case SpvOpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; ++ case SpvOpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; ++ case SpvOpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; ++ case SpvOpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; ++ case SpvOpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; ++ case SpvOpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; ++ case SpvOpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; ++ case SpvOpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; ++ case SpvOpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; ++ case SpvOpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; ++ case SpvOpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; ++ case SpvOpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; ++ case SpvOpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; ++ case SpvOpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; ++ case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; ++ case SpvOpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; ++ case SpvOpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; ++ case SpvOpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; ++ case SpvOpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; ++ case SpvOpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; ++ case SpvOpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; ++ case SpvOpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; ++ case SpvOpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; ++ case SpvOpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; ++ case SpvOpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; ++ case SpvOpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; ++ case SpvOpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; ++ case SpvOpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; ++ case SpvOpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; ++ case SpvOpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; ++ case SpvOpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; ++ case SpvOpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; ++ case SpvOpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; ++ case SpvOpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; ++ case SpvOpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; ++ case SpvOpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; ++ case SpvOpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; ++ case SpvOpTypeHitObjectNV: return "OpTypeHitObjectNV"; ++ case SpvOpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; ++ case SpvOpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; ++ case SpvOpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; ++ case SpvOpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; ++ case SpvOpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; ++ case SpvOpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; ++ case SpvOpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; ++ case SpvOpReportIntersectionKHR: return "OpReportIntersectionKHR"; ++ case SpvOpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; ++ case SpvOpTerminateRayNV: return "OpTerminateRayNV"; ++ case SpvOpTraceNV: return "OpTraceNV"; ++ case SpvOpTraceMotionNV: return "OpTraceMotionNV"; ++ case SpvOpTraceRayMotionNV: return "OpTraceRayMotionNV"; ++ case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; ++ case SpvOpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; ++ case SpvOpExecuteCallableNV: return "OpExecuteCallableNV"; ++ case SpvOpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; ++ case SpvOpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; ++ case SpvOpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; ++ case SpvOpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; ++ case SpvOpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; ++ case SpvOpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; ++ case SpvOpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; ++ case SpvOpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; ++ case SpvOpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; ++ case SpvOpConvertUToImageNV: return "OpConvertUToImageNV"; ++ case SpvOpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; ++ case SpvOpConvertImageToUNV: return "OpConvertImageToUNV"; ++ case SpvOpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; ++ case SpvOpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; ++ case SpvOpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; ++ case SpvOpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; ++ case SpvOpRawAccessChainNV: return "OpRawAccessChainNV"; ++ case SpvOpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; ++ case SpvOpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; ++ case SpvOpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; ++ case SpvOpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; ++ case SpvOpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; ++ case SpvOpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; ++ case SpvOpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; ++ case SpvOpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; ++ case SpvOpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; ++ case SpvOpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; ++ case SpvOpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; ++ case SpvOpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; ++ case SpvOpAbsISubINTEL: return "OpAbsISubINTEL"; ++ case SpvOpAbsUSubINTEL: return "OpAbsUSubINTEL"; ++ case SpvOpIAddSatINTEL: return "OpIAddSatINTEL"; ++ case SpvOpUAddSatINTEL: return "OpUAddSatINTEL"; ++ case SpvOpIAverageINTEL: return "OpIAverageINTEL"; ++ case SpvOpUAverageINTEL: return "OpUAverageINTEL"; ++ case SpvOpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; ++ case SpvOpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; ++ case SpvOpISubSatINTEL: return "OpISubSatINTEL"; ++ case SpvOpUSubSatINTEL: return "OpUSubSatINTEL"; ++ case SpvOpIMul32x16INTEL: return "OpIMul32x16INTEL"; ++ case SpvOpUMul32x16INTEL: return "OpUMul32x16INTEL"; ++ case SpvOpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; ++ case SpvOpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; ++ case SpvOpAsmTargetINTEL: return "OpAsmTargetINTEL"; ++ case SpvOpAsmINTEL: return "OpAsmINTEL"; ++ case SpvOpAsmCallINTEL: return "OpAsmCallINTEL"; ++ case SpvOpAtomicFMinEXT: return "OpAtomicFMinEXT"; ++ case SpvOpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; ++ case SpvOpAssumeTrueKHR: return "OpAssumeTrueKHR"; ++ case SpvOpExpectKHR: return "OpExpectKHR"; ++ case SpvOpDecorateString: return "OpDecorateString"; ++ case SpvOpMemberDecorateString: return "OpMemberDecorateString"; ++ case SpvOpVmeImageINTEL: return "OpVmeImageINTEL"; ++ case SpvOpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; ++ case SpvOpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; ++ case SpvOpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; ++ case SpvOpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; ++ case SpvOpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; ++ case SpvOpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; ++ case SpvOpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; ++ case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; ++ case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; ++ case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; ++ case SpvOpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; ++ case SpvOpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; ++ case SpvOpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; ++ case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; ++ case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; ++ case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; ++ case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; ++ case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; ++ case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; ++ case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; ++ case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; ++ case SpvOpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; ++ case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; ++ case SpvOpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; ++ case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; ++ case SpvOpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; ++ case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; ++ case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; ++ case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; ++ case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; ++ case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; ++ case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; ++ case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; ++ case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; ++ case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; ++ case SpvOpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; ++ case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; ++ case SpvOpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; ++ case SpvOpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; ++ case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; ++ case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; ++ case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; ++ case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; ++ case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; ++ case SpvOpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; ++ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; ++ case SpvOpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; ++ case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; ++ case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; ++ case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; ++ case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; ++ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; ++ case SpvOpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; ++ case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; ++ case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; ++ case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; ++ case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; ++ case SpvOpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; ++ case SpvOpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; ++ case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; ++ case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; ++ case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; ++ case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; ++ case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; ++ case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; ++ case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; ++ case SpvOpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; ++ case SpvOpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; ++ case SpvOpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; ++ case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; ++ case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; ++ case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; ++ case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; ++ case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; ++ case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; ++ case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; ++ case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; ++ case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; ++ case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; ++ case SpvOpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; ++ case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; ++ case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; ++ case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; ++ case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; ++ case SpvOpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; ++ case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; ++ case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; ++ case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; ++ case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; ++ case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; ++ case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; ++ case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; ++ case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; ++ case SpvOpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; ++ case SpvOpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; ++ case SpvOpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; ++ case SpvOpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; ++ case SpvOpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; ++ case SpvOpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; ++ case SpvOpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; ++ case SpvOpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; ++ case SpvOpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; ++ case SpvOpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; ++ case SpvOpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; ++ case SpvOpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; ++ case SpvOpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; ++ case SpvOpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; ++ case SpvOpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; ++ case SpvOpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; ++ case SpvOpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; ++ case SpvOpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; ++ case SpvOpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; ++ case SpvOpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; ++ case SpvOpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; ++ case SpvOpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; ++ case SpvOpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; ++ case SpvOpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; ++ case SpvOpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; ++ case SpvOpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; ++ case SpvOpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; ++ case SpvOpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; ++ case SpvOpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; ++ case SpvOpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; ++ case SpvOpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; ++ case SpvOpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; ++ case SpvOpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; ++ case SpvOpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; ++ case SpvOpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; ++ case SpvOpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; ++ case SpvOpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; ++ case SpvOpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; ++ case SpvOpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; ++ case SpvOpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; ++ case SpvOpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; ++ case SpvOpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; ++ case SpvOpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; ++ case SpvOpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; ++ case SpvOpLoopControlINTEL: return "OpLoopControlINTEL"; ++ case SpvOpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; ++ case SpvOpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; ++ case SpvOpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; ++ case SpvOpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; ++ case SpvOpFixedRecipINTEL: return "OpFixedRecipINTEL"; ++ case SpvOpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; ++ case SpvOpFixedSinINTEL: return "OpFixedSinINTEL"; ++ case SpvOpFixedCosINTEL: return "OpFixedCosINTEL"; ++ case SpvOpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; ++ case SpvOpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; ++ case SpvOpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; ++ case SpvOpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; ++ case SpvOpFixedLogINTEL: return "OpFixedLogINTEL"; ++ case SpvOpFixedExpINTEL: return "OpFixedExpINTEL"; ++ case SpvOpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; ++ case SpvOpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; ++ case SpvOpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; ++ case SpvOpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; ++ case SpvOpFPGARegINTEL: return "OpFPGARegINTEL"; ++ case SpvOpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; ++ case SpvOpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; ++ case SpvOpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; ++ case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; ++ case SpvOpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; ++ case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; ++ case SpvOpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; ++ case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; ++ case SpvOpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; ++ case SpvOpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; ++ case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; ++ case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; ++ case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; ++ case SpvOpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; ++ case SpvOpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; ++ case SpvOpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; ++ case SpvOpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; ++ case SpvOpAtomicFAddEXT: return "OpAtomicFAddEXT"; ++ case SpvOpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; ++ case SpvOpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; ++ case SpvOpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; ++ case SpvOpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; ++ case SpvOpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; ++ case SpvOpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; ++ case SpvOpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; ++ case SpvOpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; ++ case SpvOpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; ++ case SpvOpGroupIMulKHR: return "OpGroupIMulKHR"; ++ case SpvOpGroupFMulKHR: return "OpGroupFMulKHR"; ++ case SpvOpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; ++ case SpvOpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; ++ case SpvOpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; ++ case SpvOpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; ++ case SpvOpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; ++ case SpvOpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; ++ case SpvOpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; ++ case SpvOpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; ++ default: return "Unknown"; ++ } ++} ++ + #endif /* SPV_ENABLE_UTILITY_CODE */ + + #endif +diff --git include/spirv/unified1/spirv.hpp include/spirv/unified1/spirv.hpp +index a383739..2ebc387 100644 +--- include/spirv/unified1/spirv.hpp ++++ include/spirv/unified1/spirv.hpp +@@ -1045,6 +1045,7 @@ enum Capability { + CapabilityTileImageColorReadAccessEXT = 4166, + CapabilityTileImageDepthReadAccessEXT = 4167, + CapabilityTileImageStencilReadAccessEXT = 4168, ++ CapabilityCooperativeMatrixLayoutsARM = 4201, + CapabilityFragmentShadingRateKHR = 4422, + CapabilitySubgroupBallotKHR = 4423, + CapabilityDrawParameters = 4427, +@@ -1208,6 +1209,7 @@ enum Capability { + CapabilityDotProductKHR = 6019, + CapabilityRayCullMaskKHR = 6020, + CapabilityCooperativeMatrixKHR = 6022, ++ CapabilityReplicatedCompositesEXT = 6024, + CapabilityBitInstructions = 6025, + CapabilityGroupNonUniformRotateKHR = 6026, + CapabilityFloatControls2 = 6029, +@@ -1357,6 +1359,8 @@ enum CooperativeMatrixOperandsMask { + enum CooperativeMatrixLayout { + CooperativeMatrixLayoutRowMajorKHR = 0, + CooperativeMatrixLayoutColumnMajorKHR = 1, ++ CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202, ++ CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203, + CooperativeMatrixLayoutMax = 0x7fffffff, + }; + +@@ -1771,6 +1775,7 @@ enum Op { + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1793,6 +1798,9 @@ enum Op { + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +@@ -2515,6 +2523,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; ++ case OpExtInstWithForwardRefsKHR: *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; +@@ -2531,6 +2540,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; ++ case OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; + case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; + case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; +@@ -2602,14 +2614,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; + case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; +- case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; ++ case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; + case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case OpTraceNV: *hasResult = false; *hasResultType = false; break; + case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break; + case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; + case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; +- case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; ++ case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; + case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; +@@ -2884,6 +2896,1787 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; + } + } ++inline const char* SourceLanguageToString(SourceLanguage value) { ++ switch (value) { ++ case SourceLanguageUnknown: return "Unknown"; ++ case SourceLanguageESSL: return "ESSL"; ++ case SourceLanguageGLSL: return "GLSL"; ++ case SourceLanguageOpenCL_C: return "OpenCL_C"; ++ case SourceLanguageOpenCL_CPP: return "OpenCL_CPP"; ++ case SourceLanguageHLSL: return "HLSL"; ++ case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; ++ case SourceLanguageSYCL: return "SYCL"; ++ case SourceLanguageHERO_C: return "HERO_C"; ++ case SourceLanguageNZSL: return "NZSL"; ++ case SourceLanguageWGSL: return "WGSL"; ++ case SourceLanguageSlang: return "Slang"; ++ case SourceLanguageZig: return "Zig"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ExecutionModelToString(ExecutionModel value) { ++ switch (value) { ++ case ExecutionModelVertex: return "Vertex"; ++ case ExecutionModelTessellationControl: return "TessellationControl"; ++ case ExecutionModelTessellationEvaluation: return "TessellationEvaluation"; ++ case ExecutionModelGeometry: return "Geometry"; ++ case ExecutionModelFragment: return "Fragment"; ++ case ExecutionModelGLCompute: return "GLCompute"; ++ case ExecutionModelKernel: return "Kernel"; ++ case ExecutionModelTaskNV: return "TaskNV"; ++ case ExecutionModelMeshNV: return "MeshNV"; ++ case ExecutionModelRayGenerationKHR: return "RayGenerationKHR"; ++ case ExecutionModelIntersectionKHR: return "IntersectionKHR"; ++ case ExecutionModelAnyHitKHR: return "AnyHitKHR"; ++ case ExecutionModelClosestHitKHR: return "ClosestHitKHR"; ++ case ExecutionModelMissKHR: return "MissKHR"; ++ case ExecutionModelCallableKHR: return "CallableKHR"; ++ case ExecutionModelTaskEXT: return "TaskEXT"; ++ case ExecutionModelMeshEXT: return "MeshEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* AddressingModelToString(AddressingModel value) { ++ switch (value) { ++ case AddressingModelLogical: return "Logical"; ++ case AddressingModelPhysical32: return "Physical32"; ++ case AddressingModelPhysical64: return "Physical64"; ++ case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* MemoryModelToString(MemoryModel value) { ++ switch (value) { ++ case MemoryModelSimple: return "Simple"; ++ case MemoryModelGLSL450: return "GLSL450"; ++ case MemoryModelOpenCL: return "OpenCL"; ++ case MemoryModelVulkan: return "Vulkan"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ExecutionModeToString(ExecutionMode value) { ++ switch (value) { ++ case ExecutionModeInvocations: return "Invocations"; ++ case ExecutionModeSpacingEqual: return "SpacingEqual"; ++ case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; ++ case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; ++ case ExecutionModeVertexOrderCw: return "VertexOrderCw"; ++ case ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; ++ case ExecutionModePixelCenterInteger: return "PixelCenterInteger"; ++ case ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; ++ case ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; ++ case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; ++ case ExecutionModePointMode: return "PointMode"; ++ case ExecutionModeXfb: return "Xfb"; ++ case ExecutionModeDepthReplacing: return "DepthReplacing"; ++ case ExecutionModeDepthGreater: return "DepthGreater"; ++ case ExecutionModeDepthLess: return "DepthLess"; ++ case ExecutionModeDepthUnchanged: return "DepthUnchanged"; ++ case ExecutionModeLocalSize: return "LocalSize"; ++ case ExecutionModeLocalSizeHint: return "LocalSizeHint"; ++ case ExecutionModeInputPoints: return "InputPoints"; ++ case ExecutionModeInputLines: return "InputLines"; ++ case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; ++ case ExecutionModeTriangles: return "Triangles"; ++ case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; ++ case ExecutionModeQuads: return "Quads"; ++ case ExecutionModeIsolines: return "Isolines"; ++ case ExecutionModeOutputVertices: return "OutputVertices"; ++ case ExecutionModeOutputPoints: return "OutputPoints"; ++ case ExecutionModeOutputLineStrip: return "OutputLineStrip"; ++ case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; ++ case ExecutionModeVecTypeHint: return "VecTypeHint"; ++ case ExecutionModeContractionOff: return "ContractionOff"; ++ case ExecutionModeInitializer: return "Initializer"; ++ case ExecutionModeFinalizer: return "Finalizer"; ++ case ExecutionModeSubgroupSize: return "SubgroupSize"; ++ case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; ++ case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; ++ case ExecutionModeLocalSizeId: return "LocalSizeId"; ++ case ExecutionModeLocalSizeHintId: return "LocalSizeHintId"; ++ case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; ++ case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; ++ case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; ++ case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; ++ case ExecutionModePostDepthCoverage: return "PostDepthCoverage"; ++ case ExecutionModeDenormPreserve: return "DenormPreserve"; ++ case ExecutionModeDenormFlushToZero: return "DenormFlushToZero"; ++ case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; ++ case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; ++ case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; ++ case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; ++ case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; ++ case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; ++ case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; ++ case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; ++ case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; ++ case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; ++ case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; ++ case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; ++ case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; ++ case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; ++ case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; ++ case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; ++ case ExecutionModeOutputLinesEXT: return "OutputLinesEXT"; ++ case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; ++ case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; ++ case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; ++ case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; ++ case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; ++ case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; ++ case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; ++ case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; ++ case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; ++ case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; ++ case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; ++ case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; ++ case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; ++ case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; ++ case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; ++ case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; ++ case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; ++ case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; ++ case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; ++ case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; ++ case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; ++ case ExecutionModeFPFastMathDefault: return "FPFastMathDefault"; ++ case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; ++ case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; ++ case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; ++ case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; ++ case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; ++ case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* StorageClassToString(StorageClass value) { ++ switch (value) { ++ case StorageClassUniformConstant: return "UniformConstant"; ++ case StorageClassInput: return "Input"; ++ case StorageClassUniform: return "Uniform"; ++ case StorageClassOutput: return "Output"; ++ case StorageClassWorkgroup: return "Workgroup"; ++ case StorageClassCrossWorkgroup: return "CrossWorkgroup"; ++ case StorageClassPrivate: return "Private"; ++ case StorageClassFunction: return "Function"; ++ case StorageClassGeneric: return "Generic"; ++ case StorageClassPushConstant: return "PushConstant"; ++ case StorageClassAtomicCounter: return "AtomicCounter"; ++ case StorageClassImage: return "Image"; ++ case StorageClassStorageBuffer: return "StorageBuffer"; ++ case StorageClassTileImageEXT: return "TileImageEXT"; ++ case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; ++ case StorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; ++ case StorageClassCallableDataKHR: return "CallableDataKHR"; ++ case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; ++ case StorageClassRayPayloadKHR: return "RayPayloadKHR"; ++ case StorageClassHitAttributeKHR: return "HitAttributeKHR"; ++ case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; ++ case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; ++ case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; ++ case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; ++ case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; ++ case StorageClassCodeSectionINTEL: return "CodeSectionINTEL"; ++ case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; ++ case StorageClassHostOnlyINTEL: return "HostOnlyINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* DimToString(Dim value) { ++ switch (value) { ++ case Dim1D: return "1D"; ++ case Dim2D: return "2D"; ++ case Dim3D: return "3D"; ++ case DimCube: return "Cube"; ++ case DimRect: return "Rect"; ++ case DimBuffer: return "Buffer"; ++ case DimSubpassData: return "SubpassData"; ++ case DimTileImageDataEXT: return "TileImageDataEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) { ++ switch (value) { ++ case SamplerAddressingModeNone: return "None"; ++ case SamplerAddressingModeClampToEdge: return "ClampToEdge"; ++ case SamplerAddressingModeClamp: return "Clamp"; ++ case SamplerAddressingModeRepeat: return "Repeat"; ++ case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SamplerFilterModeToString(SamplerFilterMode value) { ++ switch (value) { ++ case SamplerFilterModeNearest: return "Nearest"; ++ case SamplerFilterModeLinear: return "Linear"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageFormatToString(ImageFormat value) { ++ switch (value) { ++ case ImageFormatUnknown: return "Unknown"; ++ case ImageFormatRgba32f: return "Rgba32f"; ++ case ImageFormatRgba16f: return "Rgba16f"; ++ case ImageFormatR32f: return "R32f"; ++ case ImageFormatRgba8: return "Rgba8"; ++ case ImageFormatRgba8Snorm: return "Rgba8Snorm"; ++ case ImageFormatRg32f: return "Rg32f"; ++ case ImageFormatRg16f: return "Rg16f"; ++ case ImageFormatR11fG11fB10f: return "R11fG11fB10f"; ++ case ImageFormatR16f: return "R16f"; ++ case ImageFormatRgba16: return "Rgba16"; ++ case ImageFormatRgb10A2: return "Rgb10A2"; ++ case ImageFormatRg16: return "Rg16"; ++ case ImageFormatRg8: return "Rg8"; ++ case ImageFormatR16: return "R16"; ++ case ImageFormatR8: return "R8"; ++ case ImageFormatRgba16Snorm: return "Rgba16Snorm"; ++ case ImageFormatRg16Snorm: return "Rg16Snorm"; ++ case ImageFormatRg8Snorm: return "Rg8Snorm"; ++ case ImageFormatR16Snorm: return "R16Snorm"; ++ case ImageFormatR8Snorm: return "R8Snorm"; ++ case ImageFormatRgba32i: return "Rgba32i"; ++ case ImageFormatRgba16i: return "Rgba16i"; ++ case ImageFormatRgba8i: return "Rgba8i"; ++ case ImageFormatR32i: return "R32i"; ++ case ImageFormatRg32i: return "Rg32i"; ++ case ImageFormatRg16i: return "Rg16i"; ++ case ImageFormatRg8i: return "Rg8i"; ++ case ImageFormatR16i: return "R16i"; ++ case ImageFormatR8i: return "R8i"; ++ case ImageFormatRgba32ui: return "Rgba32ui"; ++ case ImageFormatRgba16ui: return "Rgba16ui"; ++ case ImageFormatRgba8ui: return "Rgba8ui"; ++ case ImageFormatR32ui: return "R32ui"; ++ case ImageFormatRgb10a2ui: return "Rgb10a2ui"; ++ case ImageFormatRg32ui: return "Rg32ui"; ++ case ImageFormatRg16ui: return "Rg16ui"; ++ case ImageFormatRg8ui: return "Rg8ui"; ++ case ImageFormatR16ui: return "R16ui"; ++ case ImageFormatR8ui: return "R8ui"; ++ case ImageFormatR64ui: return "R64ui"; ++ case ImageFormatR64i: return "R64i"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageChannelOrderToString(ImageChannelOrder value) { ++ switch (value) { ++ case ImageChannelOrderR: return "R"; ++ case ImageChannelOrderA: return "A"; ++ case ImageChannelOrderRG: return "RG"; ++ case ImageChannelOrderRA: return "RA"; ++ case ImageChannelOrderRGB: return "RGB"; ++ case ImageChannelOrderRGBA: return "RGBA"; ++ case ImageChannelOrderBGRA: return "BGRA"; ++ case ImageChannelOrderARGB: return "ARGB"; ++ case ImageChannelOrderIntensity: return "Intensity"; ++ case ImageChannelOrderLuminance: return "Luminance"; ++ case ImageChannelOrderRx: return "Rx"; ++ case ImageChannelOrderRGx: return "RGx"; ++ case ImageChannelOrderRGBx: return "RGBx"; ++ case ImageChannelOrderDepth: return "Depth"; ++ case ImageChannelOrderDepthStencil: return "DepthStencil"; ++ case ImageChannelOrdersRGB: return "sRGB"; ++ case ImageChannelOrdersRGBx: return "sRGBx"; ++ case ImageChannelOrdersRGBA: return "sRGBA"; ++ case ImageChannelOrdersBGRA: return "sBGRA"; ++ case ImageChannelOrderABGR: return "ABGR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) { ++ switch (value) { ++ case ImageChannelDataTypeSnormInt8: return "SnormInt8"; ++ case ImageChannelDataTypeSnormInt16: return "SnormInt16"; ++ case ImageChannelDataTypeUnormInt8: return "UnormInt8"; ++ case ImageChannelDataTypeUnormInt16: return "UnormInt16"; ++ case ImageChannelDataTypeUnormShort565: return "UnormShort565"; ++ case ImageChannelDataTypeUnormShort555: return "UnormShort555"; ++ case ImageChannelDataTypeUnormInt101010: return "UnormInt101010"; ++ case ImageChannelDataTypeSignedInt8: return "SignedInt8"; ++ case ImageChannelDataTypeSignedInt16: return "SignedInt16"; ++ case ImageChannelDataTypeSignedInt32: return "SignedInt32"; ++ case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; ++ case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; ++ case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; ++ case ImageChannelDataTypeHalfFloat: return "HalfFloat"; ++ case ImageChannelDataTypeFloat: return "Float"; ++ case ImageChannelDataTypeUnormInt24: return "UnormInt24"; ++ case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; ++ case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; ++ case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPRoundingModeToString(FPRoundingMode value) { ++ switch (value) { ++ case FPRoundingModeRTE: return "RTE"; ++ case FPRoundingModeRTZ: return "RTZ"; ++ case FPRoundingModeRTP: return "RTP"; ++ case FPRoundingModeRTN: return "RTN"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* LinkageTypeToString(LinkageType value) { ++ switch (value) { ++ case LinkageTypeExport: return "Export"; ++ case LinkageTypeImport: return "Import"; ++ case LinkageTypeLinkOnceODR: return "LinkOnceODR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* AccessQualifierToString(AccessQualifier value) { ++ switch (value) { ++ case AccessQualifierReadOnly: return "ReadOnly"; ++ case AccessQualifierWriteOnly: return "WriteOnly"; ++ case AccessQualifierReadWrite: return "ReadWrite"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) { ++ switch (value) { ++ case FunctionParameterAttributeZext: return "Zext"; ++ case FunctionParameterAttributeSext: return "Sext"; ++ case FunctionParameterAttributeByVal: return "ByVal"; ++ case FunctionParameterAttributeSret: return "Sret"; ++ case FunctionParameterAttributeNoAlias: return "NoAlias"; ++ case FunctionParameterAttributeNoCapture: return "NoCapture"; ++ case FunctionParameterAttributeNoWrite: return "NoWrite"; ++ case FunctionParameterAttributeNoReadWrite: return "NoReadWrite"; ++ case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* DecorationToString(Decoration value) { ++ switch (value) { ++ case DecorationRelaxedPrecision: return "RelaxedPrecision"; ++ case DecorationSpecId: return "SpecId"; ++ case DecorationBlock: return "Block"; ++ case DecorationBufferBlock: return "BufferBlock"; ++ case DecorationRowMajor: return "RowMajor"; ++ case DecorationColMajor: return "ColMajor"; ++ case DecorationArrayStride: return "ArrayStride"; ++ case DecorationMatrixStride: return "MatrixStride"; ++ case DecorationGLSLShared: return "GLSLShared"; ++ case DecorationGLSLPacked: return "GLSLPacked"; ++ case DecorationCPacked: return "CPacked"; ++ case DecorationBuiltIn: return "BuiltIn"; ++ case DecorationNoPerspective: return "NoPerspective"; ++ case DecorationFlat: return "Flat"; ++ case DecorationPatch: return "Patch"; ++ case DecorationCentroid: return "Centroid"; ++ case DecorationSample: return "Sample"; ++ case DecorationInvariant: return "Invariant"; ++ case DecorationRestrict: return "Restrict"; ++ case DecorationAliased: return "Aliased"; ++ case DecorationVolatile: return "Volatile"; ++ case DecorationConstant: return "Constant"; ++ case DecorationCoherent: return "Coherent"; ++ case DecorationNonWritable: return "NonWritable"; ++ case DecorationNonReadable: return "NonReadable"; ++ case DecorationUniform: return "Uniform"; ++ case DecorationUniformId: return "UniformId"; ++ case DecorationSaturatedConversion: return "SaturatedConversion"; ++ case DecorationStream: return "Stream"; ++ case DecorationLocation: return "Location"; ++ case DecorationComponent: return "Component"; ++ case DecorationIndex: return "Index"; ++ case DecorationBinding: return "Binding"; ++ case DecorationDescriptorSet: return "DescriptorSet"; ++ case DecorationOffset: return "Offset"; ++ case DecorationXfbBuffer: return "XfbBuffer"; ++ case DecorationXfbStride: return "XfbStride"; ++ case DecorationFuncParamAttr: return "FuncParamAttr"; ++ case DecorationFPRoundingMode: return "FPRoundingMode"; ++ case DecorationFPFastMathMode: return "FPFastMathMode"; ++ case DecorationLinkageAttributes: return "LinkageAttributes"; ++ case DecorationNoContraction: return "NoContraction"; ++ case DecorationInputAttachmentIndex: return "InputAttachmentIndex"; ++ case DecorationAlignment: return "Alignment"; ++ case DecorationMaxByteOffset: return "MaxByteOffset"; ++ case DecorationAlignmentId: return "AlignmentId"; ++ case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; ++ case DecorationNoSignedWrap: return "NoSignedWrap"; ++ case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; ++ case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; ++ case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; ++ case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; ++ case DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; ++ case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; ++ case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; ++ case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; ++ case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; ++ case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; ++ case DecorationPassthroughNV: return "PassthroughNV"; ++ case DecorationViewportRelativeNV: return "ViewportRelativeNV"; ++ case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; ++ case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; ++ case DecorationPerViewNV: return "PerViewNV"; ++ case DecorationPerTaskNV: return "PerTaskNV"; ++ case DecorationPerVertexKHR: return "PerVertexKHR"; ++ case DecorationNonUniform: return "NonUniform"; ++ case DecorationRestrictPointer: return "RestrictPointer"; ++ case DecorationAliasedPointer: return "AliasedPointer"; ++ case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; ++ case DecorationBindlessSamplerNV: return "BindlessSamplerNV"; ++ case DecorationBindlessImageNV: return "BindlessImageNV"; ++ case DecorationBoundSamplerNV: return "BoundSamplerNV"; ++ case DecorationBoundImageNV: return "BoundImageNV"; ++ case DecorationSIMTCallINTEL: return "SIMTCallINTEL"; ++ case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; ++ case DecorationClobberINTEL: return "ClobberINTEL"; ++ case DecorationSideEffectsINTEL: return "SideEffectsINTEL"; ++ case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; ++ case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; ++ case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; ++ case DecorationStackCallINTEL: return "StackCallINTEL"; ++ case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; ++ case DecorationCounterBuffer: return "CounterBuffer"; ++ case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; ++ case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; ++ case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; ++ case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; ++ case DecorationRegisterINTEL: return "RegisterINTEL"; ++ case DecorationMemoryINTEL: return "MemoryINTEL"; ++ case DecorationNumbanksINTEL: return "NumbanksINTEL"; ++ case DecorationBankwidthINTEL: return "BankwidthINTEL"; ++ case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; ++ case DecorationSinglepumpINTEL: return "SinglepumpINTEL"; ++ case DecorationDoublepumpINTEL: return "DoublepumpINTEL"; ++ case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; ++ case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; ++ case DecorationMergeINTEL: return "MergeINTEL"; ++ case DecorationBankBitsINTEL: return "BankBitsINTEL"; ++ case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; ++ case DecorationStridesizeINTEL: return "StridesizeINTEL"; ++ case DecorationWordsizeINTEL: return "WordsizeINTEL"; ++ case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; ++ case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; ++ case DecorationCacheSizeINTEL: return "CacheSizeINTEL"; ++ case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; ++ case DecorationPrefetchINTEL: return "PrefetchINTEL"; ++ case DecorationStallEnableINTEL: return "StallEnableINTEL"; ++ case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; ++ case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; ++ case DecorationAliasScopeINTEL: return "AliasScopeINTEL"; ++ case DecorationNoAliasINTEL: return "NoAliasINTEL"; ++ case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; ++ case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; ++ case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; ++ case DecorationBufferLocationINTEL: return "BufferLocationINTEL"; ++ case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; ++ case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; ++ case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; ++ case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; ++ case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; ++ case DecorationStallFreeINTEL: return "StallFreeINTEL"; ++ case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; ++ case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; ++ case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; ++ case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; ++ case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; ++ case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; ++ case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; ++ case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; ++ case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; ++ case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; ++ case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; ++ case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; ++ case DecorationHostAccessINTEL: return "HostAccessINTEL"; ++ case DecorationInitModeINTEL: return "InitModeINTEL"; ++ case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; ++ case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; ++ case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* BuiltInToString(BuiltIn value) { ++ switch (value) { ++ case BuiltInPosition: return "Position"; ++ case BuiltInPointSize: return "PointSize"; ++ case BuiltInClipDistance: return "ClipDistance"; ++ case BuiltInCullDistance: return "CullDistance"; ++ case BuiltInVertexId: return "VertexId"; ++ case BuiltInInstanceId: return "InstanceId"; ++ case BuiltInPrimitiveId: return "PrimitiveId"; ++ case BuiltInInvocationId: return "InvocationId"; ++ case BuiltInLayer: return "Layer"; ++ case BuiltInViewportIndex: return "ViewportIndex"; ++ case BuiltInTessLevelOuter: return "TessLevelOuter"; ++ case BuiltInTessLevelInner: return "TessLevelInner"; ++ case BuiltInTessCoord: return "TessCoord"; ++ case BuiltInPatchVertices: return "PatchVertices"; ++ case BuiltInFragCoord: return "FragCoord"; ++ case BuiltInPointCoord: return "PointCoord"; ++ case BuiltInFrontFacing: return "FrontFacing"; ++ case BuiltInSampleId: return "SampleId"; ++ case BuiltInSamplePosition: return "SamplePosition"; ++ case BuiltInSampleMask: return "SampleMask"; ++ case BuiltInFragDepth: return "FragDepth"; ++ case BuiltInHelperInvocation: return "HelperInvocation"; ++ case BuiltInNumWorkgroups: return "NumWorkgroups"; ++ case BuiltInWorkgroupSize: return "WorkgroupSize"; ++ case BuiltInWorkgroupId: return "WorkgroupId"; ++ case BuiltInLocalInvocationId: return "LocalInvocationId"; ++ case BuiltInGlobalInvocationId: return "GlobalInvocationId"; ++ case BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; ++ case BuiltInWorkDim: return "WorkDim"; ++ case BuiltInGlobalSize: return "GlobalSize"; ++ case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; ++ case BuiltInGlobalOffset: return "GlobalOffset"; ++ case BuiltInGlobalLinearId: return "GlobalLinearId"; ++ case BuiltInSubgroupSize: return "SubgroupSize"; ++ case BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; ++ case BuiltInNumSubgroups: return "NumSubgroups"; ++ case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; ++ case BuiltInSubgroupId: return "SubgroupId"; ++ case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; ++ case BuiltInVertexIndex: return "VertexIndex"; ++ case BuiltInInstanceIndex: return "InstanceIndex"; ++ case BuiltInCoreIDARM: return "CoreIDARM"; ++ case BuiltInCoreCountARM: return "CoreCountARM"; ++ case BuiltInCoreMaxIDARM: return "CoreMaxIDARM"; ++ case BuiltInWarpIDARM: return "WarpIDARM"; ++ case BuiltInWarpMaxIDARM: return "WarpMaxIDARM"; ++ case BuiltInSubgroupEqMask: return "SubgroupEqMask"; ++ case BuiltInSubgroupGeMask: return "SubgroupGeMask"; ++ case BuiltInSubgroupGtMask: return "SubgroupGtMask"; ++ case BuiltInSubgroupLeMask: return "SubgroupLeMask"; ++ case BuiltInSubgroupLtMask: return "SubgroupLtMask"; ++ case BuiltInBaseVertex: return "BaseVertex"; ++ case BuiltInBaseInstance: return "BaseInstance"; ++ case BuiltInDrawIndex: return "DrawIndex"; ++ case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; ++ case BuiltInDeviceIndex: return "DeviceIndex"; ++ case BuiltInViewIndex: return "ViewIndex"; ++ case BuiltInShadingRateKHR: return "ShadingRateKHR"; ++ case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; ++ case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; ++ case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; ++ case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; ++ case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; ++ case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; ++ case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; ++ case BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; ++ case BuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; ++ case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case BuiltInViewportMaskNV: return "ViewportMaskNV"; ++ case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; ++ case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; ++ case BuiltInPositionPerViewNV: return "PositionPerViewNV"; ++ case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; ++ case BuiltInFullyCoveredEXT: return "FullyCoveredEXT"; ++ case BuiltInTaskCountNV: return "TaskCountNV"; ++ case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; ++ case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; ++ case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; ++ case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; ++ case BuiltInLayerPerViewNV: return "LayerPerViewNV"; ++ case BuiltInMeshViewCountNV: return "MeshViewCountNV"; ++ case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; ++ case BuiltInBaryCoordKHR: return "BaryCoordKHR"; ++ case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; ++ case BuiltInFragSizeEXT: return "FragSizeEXT"; ++ case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; ++ case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; ++ case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; ++ case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; ++ case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; ++ case BuiltInLaunchIdKHR: return "LaunchIdKHR"; ++ case BuiltInLaunchSizeKHR: return "LaunchSizeKHR"; ++ case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; ++ case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; ++ case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; ++ case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; ++ case BuiltInRayTminKHR: return "RayTminKHR"; ++ case BuiltInRayTmaxKHR: return "RayTmaxKHR"; ++ case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; ++ case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; ++ case BuiltInWorldToObjectKHR: return "WorldToObjectKHR"; ++ case BuiltInHitTNV: return "HitTNV"; ++ case BuiltInHitKindKHR: return "HitKindKHR"; ++ case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; ++ case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; ++ case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; ++ case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; ++ case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; ++ case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; ++ case BuiltInWarpsPerSMNV: return "WarpsPerSMNV"; ++ case BuiltInSMCountNV: return "SMCountNV"; ++ case BuiltInWarpIDNV: return "WarpIDNV"; ++ case BuiltInSMIDNV: return "SMIDNV"; ++ case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; ++ case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; ++ case BuiltInCullMaskKHR: return "CullMaskKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ScopeToString(Scope value) { ++ switch (value) { ++ case ScopeCrossDevice: return "CrossDevice"; ++ case ScopeDevice: return "Device"; ++ case ScopeWorkgroup: return "Workgroup"; ++ case ScopeSubgroup: return "Subgroup"; ++ case ScopeInvocation: return "Invocation"; ++ case ScopeQueueFamily: return "QueueFamily"; ++ case ScopeShaderCallKHR: return "ShaderCallKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* GroupOperationToString(GroupOperation value) { ++ switch (value) { ++ case GroupOperationReduce: return "Reduce"; ++ case GroupOperationInclusiveScan: return "InclusiveScan"; ++ case GroupOperationExclusiveScan: return "ExclusiveScan"; ++ case GroupOperationClusteredReduce: return "ClusteredReduce"; ++ case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; ++ case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; ++ case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) { ++ switch (value) { ++ case KernelEnqueueFlagsNoWait: return "NoWait"; ++ case KernelEnqueueFlagsWaitKernel: return "WaitKernel"; ++ case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CapabilityToString(Capability value) { ++ switch (value) { ++ case CapabilityMatrix: return "Matrix"; ++ case CapabilityShader: return "Shader"; ++ case CapabilityGeometry: return "Geometry"; ++ case CapabilityTessellation: return "Tessellation"; ++ case CapabilityAddresses: return "Addresses"; ++ case CapabilityLinkage: return "Linkage"; ++ case CapabilityKernel: return "Kernel"; ++ case CapabilityVector16: return "Vector16"; ++ case CapabilityFloat16Buffer: return "Float16Buffer"; ++ case CapabilityFloat16: return "Float16"; ++ case CapabilityFloat64: return "Float64"; ++ case CapabilityInt64: return "Int64"; ++ case CapabilityInt64Atomics: return "Int64Atomics"; ++ case CapabilityImageBasic: return "ImageBasic"; ++ case CapabilityImageReadWrite: return "ImageReadWrite"; ++ case CapabilityImageMipmap: return "ImageMipmap"; ++ case CapabilityPipes: return "Pipes"; ++ case CapabilityGroups: return "Groups"; ++ case CapabilityDeviceEnqueue: return "DeviceEnqueue"; ++ case CapabilityLiteralSampler: return "LiteralSampler"; ++ case CapabilityAtomicStorage: return "AtomicStorage"; ++ case CapabilityInt16: return "Int16"; ++ case CapabilityTessellationPointSize: return "TessellationPointSize"; ++ case CapabilityGeometryPointSize: return "GeometryPointSize"; ++ case CapabilityImageGatherExtended: return "ImageGatherExtended"; ++ case CapabilityStorageImageMultisample: return "StorageImageMultisample"; ++ case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; ++ case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; ++ case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; ++ case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; ++ case CapabilityClipDistance: return "ClipDistance"; ++ case CapabilityCullDistance: return "CullDistance"; ++ case CapabilityImageCubeArray: return "ImageCubeArray"; ++ case CapabilitySampleRateShading: return "SampleRateShading"; ++ case CapabilityImageRect: return "ImageRect"; ++ case CapabilitySampledRect: return "SampledRect"; ++ case CapabilityGenericPointer: return "GenericPointer"; ++ case CapabilityInt8: return "Int8"; ++ case CapabilityInputAttachment: return "InputAttachment"; ++ case CapabilitySparseResidency: return "SparseResidency"; ++ case CapabilityMinLod: return "MinLod"; ++ case CapabilitySampled1D: return "Sampled1D"; ++ case CapabilityImage1D: return "Image1D"; ++ case CapabilitySampledCubeArray: return "SampledCubeArray"; ++ case CapabilitySampledBuffer: return "SampledBuffer"; ++ case CapabilityImageBuffer: return "ImageBuffer"; ++ case CapabilityImageMSArray: return "ImageMSArray"; ++ case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; ++ case CapabilityImageQuery: return "ImageQuery"; ++ case CapabilityDerivativeControl: return "DerivativeControl"; ++ case CapabilityInterpolationFunction: return "InterpolationFunction"; ++ case CapabilityTransformFeedback: return "TransformFeedback"; ++ case CapabilityGeometryStreams: return "GeometryStreams"; ++ case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; ++ case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; ++ case CapabilityMultiViewport: return "MultiViewport"; ++ case CapabilitySubgroupDispatch: return "SubgroupDispatch"; ++ case CapabilityNamedBarrier: return "NamedBarrier"; ++ case CapabilityPipeStorage: return "PipeStorage"; ++ case CapabilityGroupNonUniform: return "GroupNonUniform"; ++ case CapabilityGroupNonUniformVote: return "GroupNonUniformVote"; ++ case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; ++ case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; ++ case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; ++ case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; ++ case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; ++ case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; ++ case CapabilityShaderLayer: return "ShaderLayer"; ++ case CapabilityShaderViewportIndex: return "ShaderViewportIndex"; ++ case CapabilityUniformDecoration: return "UniformDecoration"; ++ case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; ++ case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; ++ case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; ++ case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; ++ case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; ++ case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; ++ case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; ++ case CapabilityDrawParameters: return "DrawParameters"; ++ case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; ++ case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; ++ case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; ++ case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; ++ case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; ++ case CapabilityStorageUniform16: return "StorageUniform16"; ++ case CapabilityStoragePushConstant16: return "StoragePushConstant16"; ++ case CapabilityStorageInputOutput16: return "StorageInputOutput16"; ++ case CapabilityDeviceGroup: return "DeviceGroup"; ++ case CapabilityMultiView: return "MultiView"; ++ case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; ++ case CapabilityVariablePointers: return "VariablePointers"; ++ case CapabilityAtomicStorageOps: return "AtomicStorageOps"; ++ case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; ++ case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; ++ case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; ++ case CapabilityStoragePushConstant8: return "StoragePushConstant8"; ++ case CapabilityDenormPreserve: return "DenormPreserve"; ++ case CapabilityDenormFlushToZero: return "DenormFlushToZero"; ++ case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case CapabilityRoundingModeRTE: return "RoundingModeRTE"; ++ case CapabilityRoundingModeRTZ: return "RoundingModeRTZ"; ++ case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; ++ case CapabilityRayQueryKHR: return "RayQueryKHR"; ++ case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; ++ case CapabilityRayTracingKHR: return "RayTracingKHR"; ++ case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; ++ case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; ++ case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; ++ case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; ++ case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; ++ case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; ++ case CapabilityFragmentMaskAMD: return "FragmentMaskAMD"; ++ case CapabilityStencilExportEXT: return "StencilExportEXT"; ++ case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; ++ case CapabilityInt64ImageEXT: return "Int64ImageEXT"; ++ case CapabilityShaderClockKHR: return "ShaderClockKHR"; ++ case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; ++ case CapabilityQuadControlKHR: return "QuadControlKHR"; ++ case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; ++ case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; ++ case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; ++ case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; ++ case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; ++ case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; ++ case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; ++ case CapabilityMeshShadingNV: return "MeshShadingNV"; ++ case CapabilityImageFootprintNV: return "ImageFootprintNV"; ++ case CapabilityMeshShadingEXT: return "MeshShadingEXT"; ++ case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; ++ case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; ++ case CapabilityFragmentDensityEXT: return "FragmentDensityEXT"; ++ case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; ++ case CapabilityShaderNonUniform: return "ShaderNonUniform"; ++ case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; ++ case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; ++ case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; ++ case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; ++ case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; ++ case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; ++ case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; ++ case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; ++ case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; ++ case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; ++ case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; ++ case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; ++ case CapabilityRayTracingNV: return "RayTracingNV"; ++ case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; ++ case CapabilityVulkanMemoryModel: return "VulkanMemoryModel"; ++ case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; ++ case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; ++ case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; ++ case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; ++ case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; ++ case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; ++ case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; ++ case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; ++ case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; ++ case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; ++ case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; ++ case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; ++ case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; ++ case CapabilityBindlessTextureNV: return "BindlessTextureNV"; ++ case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; ++ case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; ++ case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; ++ case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; ++ case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; ++ case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; ++ case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; ++ case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; ++ case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; ++ case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; ++ case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; ++ case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; ++ case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; ++ case CapabilityAsmINTEL: return "AsmINTEL"; ++ case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; ++ case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; ++ case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; ++ case CapabilityVectorComputeINTEL: return "VectorComputeINTEL"; ++ case CapabilityVectorAnyINTEL: return "VectorAnyINTEL"; ++ case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; ++ case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; ++ case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; ++ case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; ++ case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; ++ case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; ++ case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; ++ case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; ++ case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; ++ case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; ++ case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; ++ case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; ++ case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; ++ case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; ++ case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; ++ case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; ++ case CapabilityLoopFuseINTEL: return "LoopFuseINTEL"; ++ case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; ++ case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; ++ case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; ++ case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; ++ case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; ++ case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; ++ case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; ++ case CapabilityIOPipesINTEL: return "IOPipesINTEL"; ++ case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; ++ case CapabilityFPGARegINTEL: return "FPGARegINTEL"; ++ case CapabilityDotProductInputAll: return "DotProductInputAll"; ++ case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; ++ case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; ++ case CapabilityDotProduct: return "DotProduct"; ++ case CapabilityRayCullMaskKHR: return "RayCullMaskKHR"; ++ case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; ++ case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; ++ case CapabilityBitInstructions: return "BitInstructions"; ++ case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; ++ case CapabilityFloatControls2: return "FloatControls2"; ++ case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; ++ case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; ++ case CapabilityLongCompositesINTEL: return "LongCompositesINTEL"; ++ case CapabilityOptNoneINTEL: return "OptNoneINTEL"; ++ case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; ++ case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; ++ case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; ++ case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; ++ case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; ++ case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; ++ case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; ++ case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; ++ case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; ++ case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; ++ case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; ++ case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; ++ case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; ++ case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; ++ case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryIntersectionToString(RayQueryIntersection value) { ++ switch (value) { ++ case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; ++ case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) { ++ switch (value) { ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) { ++ switch (value) { ++ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; ++ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPDenormModeToString(FPDenormMode value) { ++ switch (value) { ++ case FPDenormModePreserve: return "Preserve"; ++ case FPDenormModeFlushToZero: return "FlushToZero"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPOperationModeToString(FPOperationMode value) { ++ switch (value) { ++ case FPOperationModeIEEE: return "IEEE"; ++ case FPOperationModeALT: return "ALT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* QuantizationModesToString(QuantizationModes value) { ++ switch (value) { ++ case QuantizationModesTRN: return "TRN"; ++ case QuantizationModesTRN_ZERO: return "TRN_ZERO"; ++ case QuantizationModesRND: return "RND"; ++ case QuantizationModesRND_ZERO: return "RND_ZERO"; ++ case QuantizationModesRND_INF: return "RND_INF"; ++ case QuantizationModesRND_MIN_INF: return "RND_MIN_INF"; ++ case QuantizationModesRND_CONV: return "RND_CONV"; ++ case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* OverflowModesToString(OverflowModes value) { ++ switch (value) { ++ case OverflowModesWRAP: return "WRAP"; ++ case OverflowModesSAT: return "SAT"; ++ case OverflowModesSAT_ZERO: return "SAT_ZERO"; ++ case OverflowModesSAT_SYM: return "SAT_SYM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* PackedVectorFormatToString(PackedVectorFormat value) { ++ switch (value) { ++ case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) { ++ switch (value) { ++ case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; ++ case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; ++ case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; ++ case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) { ++ switch (value) { ++ case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; ++ case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; ++ case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) { ++ switch (value) { ++ case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; ++ case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* HostAccessQualifierToString(HostAccessQualifier value) { ++ switch (value) { ++ case HostAccessQualifierNoneINTEL: return "NoneINTEL"; ++ case HostAccessQualifierReadINTEL: return "ReadINTEL"; ++ case HostAccessQualifierWriteINTEL: return "WriteINTEL"; ++ case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* LoadCacheControlToString(LoadCacheControl value) { ++ switch (value) { ++ case LoadCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case LoadCacheControlCachedINTEL: return "CachedINTEL"; ++ case LoadCacheControlStreamingINTEL: return "StreamingINTEL"; ++ case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; ++ case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* StoreCacheControlToString(StoreCacheControl value) { ++ switch (value) { ++ case StoreCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; ++ case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; ++ case StoreCacheControlStreamingINTEL: return "StreamingINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) { ++ switch (value) { ++ case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* OpToString(Op value) { ++ switch (value) { ++ case OpNop: return "OpNop"; ++ case OpUndef: return "OpUndef"; ++ case OpSourceContinued: return "OpSourceContinued"; ++ case OpSource: return "OpSource"; ++ case OpSourceExtension: return "OpSourceExtension"; ++ case OpName: return "OpName"; ++ case OpMemberName: return "OpMemberName"; ++ case OpString: return "OpString"; ++ case OpLine: return "OpLine"; ++ case OpExtension: return "OpExtension"; ++ case OpExtInstImport: return "OpExtInstImport"; ++ case OpExtInst: return "OpExtInst"; ++ case OpMemoryModel: return "OpMemoryModel"; ++ case OpEntryPoint: return "OpEntryPoint"; ++ case OpExecutionMode: return "OpExecutionMode"; ++ case OpCapability: return "OpCapability"; ++ case OpTypeVoid: return "OpTypeVoid"; ++ case OpTypeBool: return "OpTypeBool"; ++ case OpTypeInt: return "OpTypeInt"; ++ case OpTypeFloat: return "OpTypeFloat"; ++ case OpTypeVector: return "OpTypeVector"; ++ case OpTypeMatrix: return "OpTypeMatrix"; ++ case OpTypeImage: return "OpTypeImage"; ++ case OpTypeSampler: return "OpTypeSampler"; ++ case OpTypeSampledImage: return "OpTypeSampledImage"; ++ case OpTypeArray: return "OpTypeArray"; ++ case OpTypeRuntimeArray: return "OpTypeRuntimeArray"; ++ case OpTypeStruct: return "OpTypeStruct"; ++ case OpTypeOpaque: return "OpTypeOpaque"; ++ case OpTypePointer: return "OpTypePointer"; ++ case OpTypeFunction: return "OpTypeFunction"; ++ case OpTypeEvent: return "OpTypeEvent"; ++ case OpTypeDeviceEvent: return "OpTypeDeviceEvent"; ++ case OpTypeReserveId: return "OpTypeReserveId"; ++ case OpTypeQueue: return "OpTypeQueue"; ++ case OpTypePipe: return "OpTypePipe"; ++ case OpTypeForwardPointer: return "OpTypeForwardPointer"; ++ case OpConstantTrue: return "OpConstantTrue"; ++ case OpConstantFalse: return "OpConstantFalse"; ++ case OpConstant: return "OpConstant"; ++ case OpConstantComposite: return "OpConstantComposite"; ++ case OpConstantSampler: return "OpConstantSampler"; ++ case OpConstantNull: return "OpConstantNull"; ++ case OpSpecConstantTrue: return "OpSpecConstantTrue"; ++ case OpSpecConstantFalse: return "OpSpecConstantFalse"; ++ case OpSpecConstant: return "OpSpecConstant"; ++ case OpSpecConstantComposite: return "OpSpecConstantComposite"; ++ case OpSpecConstantOp: return "OpSpecConstantOp"; ++ case OpFunction: return "OpFunction"; ++ case OpFunctionParameter: return "OpFunctionParameter"; ++ case OpFunctionEnd: return "OpFunctionEnd"; ++ case OpFunctionCall: return "OpFunctionCall"; ++ case OpVariable: return "OpVariable"; ++ case OpImageTexelPointer: return "OpImageTexelPointer"; ++ case OpLoad: return "OpLoad"; ++ case OpStore: return "OpStore"; ++ case OpCopyMemory: return "OpCopyMemory"; ++ case OpCopyMemorySized: return "OpCopyMemorySized"; ++ case OpAccessChain: return "OpAccessChain"; ++ case OpInBoundsAccessChain: return "OpInBoundsAccessChain"; ++ case OpPtrAccessChain: return "OpPtrAccessChain"; ++ case OpArrayLength: return "OpArrayLength"; ++ case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; ++ case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; ++ case OpDecorate: return "OpDecorate"; ++ case OpMemberDecorate: return "OpMemberDecorate"; ++ case OpDecorationGroup: return "OpDecorationGroup"; ++ case OpGroupDecorate: return "OpGroupDecorate"; ++ case OpGroupMemberDecorate: return "OpGroupMemberDecorate"; ++ case OpVectorExtractDynamic: return "OpVectorExtractDynamic"; ++ case OpVectorInsertDynamic: return "OpVectorInsertDynamic"; ++ case OpVectorShuffle: return "OpVectorShuffle"; ++ case OpCompositeConstruct: return "OpCompositeConstruct"; ++ case OpCompositeExtract: return "OpCompositeExtract"; ++ case OpCompositeInsert: return "OpCompositeInsert"; ++ case OpCopyObject: return "OpCopyObject"; ++ case OpTranspose: return "OpTranspose"; ++ case OpSampledImage: return "OpSampledImage"; ++ case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; ++ case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; ++ case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; ++ case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; ++ case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; ++ case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; ++ case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; ++ case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; ++ case OpImageFetch: return "OpImageFetch"; ++ case OpImageGather: return "OpImageGather"; ++ case OpImageDrefGather: return "OpImageDrefGather"; ++ case OpImageRead: return "OpImageRead"; ++ case OpImageWrite: return "OpImageWrite"; ++ case OpImage: return "OpImage"; ++ case OpImageQueryFormat: return "OpImageQueryFormat"; ++ case OpImageQueryOrder: return "OpImageQueryOrder"; ++ case OpImageQuerySizeLod: return "OpImageQuerySizeLod"; ++ case OpImageQuerySize: return "OpImageQuerySize"; ++ case OpImageQueryLod: return "OpImageQueryLod"; ++ case OpImageQueryLevels: return "OpImageQueryLevels"; ++ case OpImageQuerySamples: return "OpImageQuerySamples"; ++ case OpConvertFToU: return "OpConvertFToU"; ++ case OpConvertFToS: return "OpConvertFToS"; ++ case OpConvertSToF: return "OpConvertSToF"; ++ case OpConvertUToF: return "OpConvertUToF"; ++ case OpUConvert: return "OpUConvert"; ++ case OpSConvert: return "OpSConvert"; ++ case OpFConvert: return "OpFConvert"; ++ case OpQuantizeToF16: return "OpQuantizeToF16"; ++ case OpConvertPtrToU: return "OpConvertPtrToU"; ++ case OpSatConvertSToU: return "OpSatConvertSToU"; ++ case OpSatConvertUToS: return "OpSatConvertUToS"; ++ case OpConvertUToPtr: return "OpConvertUToPtr"; ++ case OpPtrCastToGeneric: return "OpPtrCastToGeneric"; ++ case OpGenericCastToPtr: return "OpGenericCastToPtr"; ++ case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; ++ case OpBitcast: return "OpBitcast"; ++ case OpSNegate: return "OpSNegate"; ++ case OpFNegate: return "OpFNegate"; ++ case OpIAdd: return "OpIAdd"; ++ case OpFAdd: return "OpFAdd"; ++ case OpISub: return "OpISub"; ++ case OpFSub: return "OpFSub"; ++ case OpIMul: return "OpIMul"; ++ case OpFMul: return "OpFMul"; ++ case OpUDiv: return "OpUDiv"; ++ case OpSDiv: return "OpSDiv"; ++ case OpFDiv: return "OpFDiv"; ++ case OpUMod: return "OpUMod"; ++ case OpSRem: return "OpSRem"; ++ case OpSMod: return "OpSMod"; ++ case OpFRem: return "OpFRem"; ++ case OpFMod: return "OpFMod"; ++ case OpVectorTimesScalar: return "OpVectorTimesScalar"; ++ case OpMatrixTimesScalar: return "OpMatrixTimesScalar"; ++ case OpVectorTimesMatrix: return "OpVectorTimesMatrix"; ++ case OpMatrixTimesVector: return "OpMatrixTimesVector"; ++ case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; ++ case OpOuterProduct: return "OpOuterProduct"; ++ case OpDot: return "OpDot"; ++ case OpIAddCarry: return "OpIAddCarry"; ++ case OpISubBorrow: return "OpISubBorrow"; ++ case OpUMulExtended: return "OpUMulExtended"; ++ case OpSMulExtended: return "OpSMulExtended"; ++ case OpAny: return "OpAny"; ++ case OpAll: return "OpAll"; ++ case OpIsNan: return "OpIsNan"; ++ case OpIsInf: return "OpIsInf"; ++ case OpIsFinite: return "OpIsFinite"; ++ case OpIsNormal: return "OpIsNormal"; ++ case OpSignBitSet: return "OpSignBitSet"; ++ case OpLessOrGreater: return "OpLessOrGreater"; ++ case OpOrdered: return "OpOrdered"; ++ case OpUnordered: return "OpUnordered"; ++ case OpLogicalEqual: return "OpLogicalEqual"; ++ case OpLogicalNotEqual: return "OpLogicalNotEqual"; ++ case OpLogicalOr: return "OpLogicalOr"; ++ case OpLogicalAnd: return "OpLogicalAnd"; ++ case OpLogicalNot: return "OpLogicalNot"; ++ case OpSelect: return "OpSelect"; ++ case OpIEqual: return "OpIEqual"; ++ case OpINotEqual: return "OpINotEqual"; ++ case OpUGreaterThan: return "OpUGreaterThan"; ++ case OpSGreaterThan: return "OpSGreaterThan"; ++ case OpUGreaterThanEqual: return "OpUGreaterThanEqual"; ++ case OpSGreaterThanEqual: return "OpSGreaterThanEqual"; ++ case OpULessThan: return "OpULessThan"; ++ case OpSLessThan: return "OpSLessThan"; ++ case OpULessThanEqual: return "OpULessThanEqual"; ++ case OpSLessThanEqual: return "OpSLessThanEqual"; ++ case OpFOrdEqual: return "OpFOrdEqual"; ++ case OpFUnordEqual: return "OpFUnordEqual"; ++ case OpFOrdNotEqual: return "OpFOrdNotEqual"; ++ case OpFUnordNotEqual: return "OpFUnordNotEqual"; ++ case OpFOrdLessThan: return "OpFOrdLessThan"; ++ case OpFUnordLessThan: return "OpFUnordLessThan"; ++ case OpFOrdGreaterThan: return "OpFOrdGreaterThan"; ++ case OpFUnordGreaterThan: return "OpFUnordGreaterThan"; ++ case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; ++ case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; ++ case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; ++ case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; ++ case OpShiftRightLogical: return "OpShiftRightLogical"; ++ case OpShiftRightArithmetic: return "OpShiftRightArithmetic"; ++ case OpShiftLeftLogical: return "OpShiftLeftLogical"; ++ case OpBitwiseOr: return "OpBitwiseOr"; ++ case OpBitwiseXor: return "OpBitwiseXor"; ++ case OpBitwiseAnd: return "OpBitwiseAnd"; ++ case OpNot: return "OpNot"; ++ case OpBitFieldInsert: return "OpBitFieldInsert"; ++ case OpBitFieldSExtract: return "OpBitFieldSExtract"; ++ case OpBitFieldUExtract: return "OpBitFieldUExtract"; ++ case OpBitReverse: return "OpBitReverse"; ++ case OpBitCount: return "OpBitCount"; ++ case OpDPdx: return "OpDPdx"; ++ case OpDPdy: return "OpDPdy"; ++ case OpFwidth: return "OpFwidth"; ++ case OpDPdxFine: return "OpDPdxFine"; ++ case OpDPdyFine: return "OpDPdyFine"; ++ case OpFwidthFine: return "OpFwidthFine"; ++ case OpDPdxCoarse: return "OpDPdxCoarse"; ++ case OpDPdyCoarse: return "OpDPdyCoarse"; ++ case OpFwidthCoarse: return "OpFwidthCoarse"; ++ case OpEmitVertex: return "OpEmitVertex"; ++ case OpEndPrimitive: return "OpEndPrimitive"; ++ case OpEmitStreamVertex: return "OpEmitStreamVertex"; ++ case OpEndStreamPrimitive: return "OpEndStreamPrimitive"; ++ case OpControlBarrier: return "OpControlBarrier"; ++ case OpMemoryBarrier: return "OpMemoryBarrier"; ++ case OpAtomicLoad: return "OpAtomicLoad"; ++ case OpAtomicStore: return "OpAtomicStore"; ++ case OpAtomicExchange: return "OpAtomicExchange"; ++ case OpAtomicCompareExchange: return "OpAtomicCompareExchange"; ++ case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; ++ case OpAtomicIIncrement: return "OpAtomicIIncrement"; ++ case OpAtomicIDecrement: return "OpAtomicIDecrement"; ++ case OpAtomicIAdd: return "OpAtomicIAdd"; ++ case OpAtomicISub: return "OpAtomicISub"; ++ case OpAtomicSMin: return "OpAtomicSMin"; ++ case OpAtomicUMin: return "OpAtomicUMin"; ++ case OpAtomicSMax: return "OpAtomicSMax"; ++ case OpAtomicUMax: return "OpAtomicUMax"; ++ case OpAtomicAnd: return "OpAtomicAnd"; ++ case OpAtomicOr: return "OpAtomicOr"; ++ case OpAtomicXor: return "OpAtomicXor"; ++ case OpPhi: return "OpPhi"; ++ case OpLoopMerge: return "OpLoopMerge"; ++ case OpSelectionMerge: return "OpSelectionMerge"; ++ case OpLabel: return "OpLabel"; ++ case OpBranch: return "OpBranch"; ++ case OpBranchConditional: return "OpBranchConditional"; ++ case OpSwitch: return "OpSwitch"; ++ case OpKill: return "OpKill"; ++ case OpReturn: return "OpReturn"; ++ case OpReturnValue: return "OpReturnValue"; ++ case OpUnreachable: return "OpUnreachable"; ++ case OpLifetimeStart: return "OpLifetimeStart"; ++ case OpLifetimeStop: return "OpLifetimeStop"; ++ case OpGroupAsyncCopy: return "OpGroupAsyncCopy"; ++ case OpGroupWaitEvents: return "OpGroupWaitEvents"; ++ case OpGroupAll: return "OpGroupAll"; ++ case OpGroupAny: return "OpGroupAny"; ++ case OpGroupBroadcast: return "OpGroupBroadcast"; ++ case OpGroupIAdd: return "OpGroupIAdd"; ++ case OpGroupFAdd: return "OpGroupFAdd"; ++ case OpGroupFMin: return "OpGroupFMin"; ++ case OpGroupUMin: return "OpGroupUMin"; ++ case OpGroupSMin: return "OpGroupSMin"; ++ case OpGroupFMax: return "OpGroupFMax"; ++ case OpGroupUMax: return "OpGroupUMax"; ++ case OpGroupSMax: return "OpGroupSMax"; ++ case OpReadPipe: return "OpReadPipe"; ++ case OpWritePipe: return "OpWritePipe"; ++ case OpReservedReadPipe: return "OpReservedReadPipe"; ++ case OpReservedWritePipe: return "OpReservedWritePipe"; ++ case OpReserveReadPipePackets: return "OpReserveReadPipePackets"; ++ case OpReserveWritePipePackets: return "OpReserveWritePipePackets"; ++ case OpCommitReadPipe: return "OpCommitReadPipe"; ++ case OpCommitWritePipe: return "OpCommitWritePipe"; ++ case OpIsValidReserveId: return "OpIsValidReserveId"; ++ case OpGetNumPipePackets: return "OpGetNumPipePackets"; ++ case OpGetMaxPipePackets: return "OpGetMaxPipePackets"; ++ case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; ++ case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; ++ case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; ++ case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; ++ case OpEnqueueMarker: return "OpEnqueueMarker"; ++ case OpEnqueueKernel: return "OpEnqueueKernel"; ++ case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; ++ case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; ++ case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; ++ case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; ++ case OpRetainEvent: return "OpRetainEvent"; ++ case OpReleaseEvent: return "OpReleaseEvent"; ++ case OpCreateUserEvent: return "OpCreateUserEvent"; ++ case OpIsValidEvent: return "OpIsValidEvent"; ++ case OpSetUserEventStatus: return "OpSetUserEventStatus"; ++ case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; ++ case OpGetDefaultQueue: return "OpGetDefaultQueue"; ++ case OpBuildNDRange: return "OpBuildNDRange"; ++ case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; ++ case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; ++ case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; ++ case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; ++ case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; ++ case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; ++ case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; ++ case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; ++ case OpImageSparseFetch: return "OpImageSparseFetch"; ++ case OpImageSparseGather: return "OpImageSparseGather"; ++ case OpImageSparseDrefGather: return "OpImageSparseDrefGather"; ++ case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; ++ case OpNoLine: return "OpNoLine"; ++ case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; ++ case OpAtomicFlagClear: return "OpAtomicFlagClear"; ++ case OpImageSparseRead: return "OpImageSparseRead"; ++ case OpSizeOf: return "OpSizeOf"; ++ case OpTypePipeStorage: return "OpTypePipeStorage"; ++ case OpConstantPipeStorage: return "OpConstantPipeStorage"; ++ case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; ++ case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; ++ case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; ++ case OpTypeNamedBarrier: return "OpTypeNamedBarrier"; ++ case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; ++ case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; ++ case OpModuleProcessed: return "OpModuleProcessed"; ++ case OpExecutionModeId: return "OpExecutionModeId"; ++ case OpDecorateId: return "OpDecorateId"; ++ case OpGroupNonUniformElect: return "OpGroupNonUniformElect"; ++ case OpGroupNonUniformAll: return "OpGroupNonUniformAll"; ++ case OpGroupNonUniformAny: return "OpGroupNonUniformAny"; ++ case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; ++ case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; ++ case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; ++ case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; ++ case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; ++ case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; ++ case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; ++ case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; ++ case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; ++ case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; ++ case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; ++ case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; ++ case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; ++ case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; ++ case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; ++ case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; ++ case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; ++ case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; ++ case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; ++ case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; ++ case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; ++ case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; ++ case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; ++ case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; ++ case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; ++ case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; ++ case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; ++ case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; ++ case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; ++ case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; ++ case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; ++ case OpCopyLogical: return "OpCopyLogical"; ++ case OpPtrEqual: return "OpPtrEqual"; ++ case OpPtrNotEqual: return "OpPtrNotEqual"; ++ case OpPtrDiff: return "OpPtrDiff"; ++ case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; ++ case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; ++ case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; ++ case OpTerminateInvocation: return "OpTerminateInvocation"; ++ case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; ++ case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; ++ case OpSubgroupAllKHR: return "OpSubgroupAllKHR"; ++ case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; ++ case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; ++ case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; ++ case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; ++ case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; ++ case OpTraceRayKHR: return "OpTraceRayKHR"; ++ case OpExecuteCallableKHR: return "OpExecuteCallableKHR"; ++ case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; ++ case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; ++ case OpTerminateRayKHR: return "OpTerminateRayKHR"; ++ case OpSDot: return "OpSDot"; ++ case OpUDot: return "OpUDot"; ++ case OpSUDot: return "OpSUDot"; ++ case OpSDotAccSat: return "OpSDotAccSat"; ++ case OpUDotAccSat: return "OpUDotAccSat"; ++ case OpSUDotAccSat: return "OpSUDotAccSat"; ++ case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; ++ case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; ++ case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; ++ case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; ++ case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; ++ case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; ++ case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; ++ case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; ++ case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; ++ case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; ++ case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; ++ case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; ++ case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; ++ case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; ++ case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; ++ case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; ++ case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; ++ case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; ++ case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; ++ case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; ++ case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; ++ case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; ++ case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; ++ case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; ++ case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; ++ case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; ++ case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; ++ case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; ++ case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; ++ case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; ++ case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; ++ case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; ++ case OpFragmentFetchAMD: return "OpFragmentFetchAMD"; ++ case OpReadClockKHR: return "OpReadClockKHR"; ++ case OpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; ++ case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; ++ case OpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; ++ case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; ++ case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; ++ case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; ++ case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; ++ case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; ++ case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; ++ case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; ++ case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; ++ case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; ++ case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; ++ case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; ++ case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; ++ case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; ++ case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; ++ case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; ++ case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; ++ case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; ++ case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; ++ case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; ++ case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; ++ case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; ++ case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; ++ case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; ++ case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; ++ case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; ++ case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; ++ case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; ++ case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; ++ case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; ++ case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; ++ case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; ++ case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; ++ case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; ++ case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; ++ case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; ++ case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; ++ case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; ++ case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; ++ case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; ++ case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; ++ case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; ++ case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; ++ case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; ++ case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; ++ case OpTerminateRayNV: return "OpTerminateRayNV"; ++ case OpTraceNV: return "OpTraceNV"; ++ case OpTraceMotionNV: return "OpTraceMotionNV"; ++ case OpTraceRayMotionNV: return "OpTraceRayMotionNV"; ++ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; ++ case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; ++ case OpExecuteCallableNV: return "OpExecuteCallableNV"; ++ case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; ++ case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; ++ case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; ++ case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; ++ case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; ++ case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; ++ case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; ++ case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; ++ case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; ++ case OpConvertUToImageNV: return "OpConvertUToImageNV"; ++ case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; ++ case OpConvertImageToUNV: return "OpConvertImageToUNV"; ++ case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; ++ case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; ++ case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; ++ case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; ++ case OpRawAccessChainNV: return "OpRawAccessChainNV"; ++ case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; ++ case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; ++ case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; ++ case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; ++ case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; ++ case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; ++ case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; ++ case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; ++ case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; ++ case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; ++ case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; ++ case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; ++ case OpAbsISubINTEL: return "OpAbsISubINTEL"; ++ case OpAbsUSubINTEL: return "OpAbsUSubINTEL"; ++ case OpIAddSatINTEL: return "OpIAddSatINTEL"; ++ case OpUAddSatINTEL: return "OpUAddSatINTEL"; ++ case OpIAverageINTEL: return "OpIAverageINTEL"; ++ case OpUAverageINTEL: return "OpUAverageINTEL"; ++ case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; ++ case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; ++ case OpISubSatINTEL: return "OpISubSatINTEL"; ++ case OpUSubSatINTEL: return "OpUSubSatINTEL"; ++ case OpIMul32x16INTEL: return "OpIMul32x16INTEL"; ++ case OpUMul32x16INTEL: return "OpUMul32x16INTEL"; ++ case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; ++ case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; ++ case OpAsmTargetINTEL: return "OpAsmTargetINTEL"; ++ case OpAsmINTEL: return "OpAsmINTEL"; ++ case OpAsmCallINTEL: return "OpAsmCallINTEL"; ++ case OpAtomicFMinEXT: return "OpAtomicFMinEXT"; ++ case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; ++ case OpAssumeTrueKHR: return "OpAssumeTrueKHR"; ++ case OpExpectKHR: return "OpExpectKHR"; ++ case OpDecorateString: return "OpDecorateString"; ++ case OpMemberDecorateString: return "OpMemberDecorateString"; ++ case OpVmeImageINTEL: return "OpVmeImageINTEL"; ++ case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; ++ case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; ++ case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; ++ case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; ++ case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; ++ case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; ++ case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; ++ case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; ++ case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; ++ case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; ++ case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; ++ case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; ++ case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; ++ case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; ++ case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; ++ case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; ++ case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; ++ case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; ++ case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; ++ case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; ++ case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; ++ case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; ++ case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; ++ case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; ++ case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; ++ case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; ++ case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; ++ case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; ++ case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; ++ case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; ++ case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; ++ case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; ++ case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; ++ case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; ++ case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; ++ case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; ++ case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; ++ case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; ++ case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; ++ case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; ++ case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; ++ case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; ++ case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; ++ case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; ++ case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; ++ case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; ++ case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; ++ case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; ++ case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; ++ case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; ++ case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; ++ case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; ++ case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; ++ case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; ++ case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; ++ case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; ++ case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; ++ case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; ++ case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; ++ case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; ++ case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; ++ case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; ++ case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; ++ case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; ++ case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; ++ case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; ++ case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; ++ case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; ++ case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; ++ case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; ++ case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; ++ case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; ++ case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; ++ case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; ++ case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; ++ case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; ++ case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; ++ case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; ++ case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; ++ case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; ++ case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; ++ case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; ++ case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; ++ case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; ++ case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; ++ case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; ++ case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; ++ case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; ++ case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; ++ case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; ++ case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; ++ case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; ++ case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; ++ case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; ++ case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; ++ case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; ++ case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; ++ case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; ++ case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; ++ case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; ++ case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; ++ case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; ++ case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; ++ case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; ++ case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; ++ case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; ++ case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; ++ case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; ++ case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; ++ case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; ++ case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; ++ case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; ++ case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; ++ case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; ++ case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; ++ case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; ++ case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; ++ case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; ++ case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; ++ case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; ++ case OpLoopControlINTEL: return "OpLoopControlINTEL"; ++ case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; ++ case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; ++ case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; ++ case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; ++ case OpFixedRecipINTEL: return "OpFixedRecipINTEL"; ++ case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; ++ case OpFixedSinINTEL: return "OpFixedSinINTEL"; ++ case OpFixedCosINTEL: return "OpFixedCosINTEL"; ++ case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; ++ case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; ++ case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; ++ case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; ++ case OpFixedLogINTEL: return "OpFixedLogINTEL"; ++ case OpFixedExpINTEL: return "OpFixedExpINTEL"; ++ case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; ++ case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; ++ case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; ++ case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; ++ case OpFPGARegINTEL: return "OpFPGARegINTEL"; ++ case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; ++ case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; ++ case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; ++ case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; ++ case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; ++ case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; ++ case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; ++ case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; ++ case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; ++ case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; ++ case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; ++ case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; ++ case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; ++ case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; ++ case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; ++ case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; ++ case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; ++ case OpAtomicFAddEXT: return "OpAtomicFAddEXT"; ++ case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; ++ case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; ++ case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; ++ case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; ++ case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; ++ case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; ++ case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; ++ case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; ++ case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; ++ case OpGroupIMulKHR: return "OpGroupIMulKHR"; ++ case OpGroupFMulKHR: return "OpGroupFMulKHR"; ++ case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; ++ case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; ++ case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; ++ case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; ++ case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; ++ case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; ++ case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; ++ case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; ++ default: return "Unknown"; ++ } ++} ++ + #endif /* SPV_ENABLE_UTILITY_CODE */ + + // Overload bitwise operators for mask bit combining +diff --git include/spirv/unified1/spirv.hpp11 include/spirv/unified1/spirv.hpp11 +index d6b4fb7..25177a4 100644 +--- include/spirv/unified1/spirv.hpp11 ++++ include/spirv/unified1/spirv.hpp11 +@@ -1045,6 +1045,7 @@ enum class Capability : unsigned { + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, ++ CooperativeMatrixLayoutsARM = 4201, + FragmentShadingRateKHR = 4422, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, +@@ -1208,6 +1209,7 @@ enum class Capability : unsigned { + DotProductKHR = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, ++ ReplicatedCompositesEXT = 6024, + BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, +@@ -1357,6 +1359,8 @@ enum class CooperativeMatrixOperandsMask : unsigned { + enum class CooperativeMatrixLayout : unsigned { + RowMajorKHR = 0, + ColumnMajorKHR = 1, ++ RowBlockedInterleavedARM = 4202, ++ ColumnBlockedInterleavedARM = 4203, + Max = 0x7fffffff, + }; + +@@ -1771,6 +1775,7 @@ enum class Op : unsigned { + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1793,6 +1798,9 @@ enum class Op : unsigned { + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +@@ -2515,6 +2523,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; ++ case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break; + case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; + case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; +@@ -2531,6 +2540,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case Op::OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; + case Op::OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; ++ case Op::OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case Op::OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; ++ case Op::OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; + case Op::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; + case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; +@@ -2602,14 +2614,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case Op::OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case Op::OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; + case Op::OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; +- case Op::OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; ++ case Op::OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case Op::OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case Op::OpTraceNV: *hasResult = false; *hasResultType = false; break; + case Op::OpTraceMotionNV: *hasResult = false; *hasResultType = false; break; + case Op::OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; + case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; +- case Op::OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; ++ case Op::OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; + case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; +@@ -2884,6 +2896,1787 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + case Op::OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; + } + } ++inline const char* SourceLanguageToString(SourceLanguage value) { ++ switch (value) { ++ case SourceLanguageUnknown: return "Unknown"; ++ case SourceLanguageESSL: return "ESSL"; ++ case SourceLanguageGLSL: return "GLSL"; ++ case SourceLanguageOpenCL_C: return "OpenCL_C"; ++ case SourceLanguageOpenCL_CPP: return "OpenCL_CPP"; ++ case SourceLanguageHLSL: return "HLSL"; ++ case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; ++ case SourceLanguageSYCL: return "SYCL"; ++ case SourceLanguageHERO_C: return "HERO_C"; ++ case SourceLanguageNZSL: return "NZSL"; ++ case SourceLanguageWGSL: return "WGSL"; ++ case SourceLanguageSlang: return "Slang"; ++ case SourceLanguageZig: return "Zig"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ExecutionModelToString(ExecutionModel value) { ++ switch (value) { ++ case ExecutionModelVertex: return "Vertex"; ++ case ExecutionModelTessellationControl: return "TessellationControl"; ++ case ExecutionModelTessellationEvaluation: return "TessellationEvaluation"; ++ case ExecutionModelGeometry: return "Geometry"; ++ case ExecutionModelFragment: return "Fragment"; ++ case ExecutionModelGLCompute: return "GLCompute"; ++ case ExecutionModelKernel: return "Kernel"; ++ case ExecutionModelTaskNV: return "TaskNV"; ++ case ExecutionModelMeshNV: return "MeshNV"; ++ case ExecutionModelRayGenerationKHR: return "RayGenerationKHR"; ++ case ExecutionModelIntersectionKHR: return "IntersectionKHR"; ++ case ExecutionModelAnyHitKHR: return "AnyHitKHR"; ++ case ExecutionModelClosestHitKHR: return "ClosestHitKHR"; ++ case ExecutionModelMissKHR: return "MissKHR"; ++ case ExecutionModelCallableKHR: return "CallableKHR"; ++ case ExecutionModelTaskEXT: return "TaskEXT"; ++ case ExecutionModelMeshEXT: return "MeshEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* AddressingModelToString(AddressingModel value) { ++ switch (value) { ++ case AddressingModelLogical: return "Logical"; ++ case AddressingModelPhysical32: return "Physical32"; ++ case AddressingModelPhysical64: return "Physical64"; ++ case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* MemoryModelToString(MemoryModel value) { ++ switch (value) { ++ case MemoryModelSimple: return "Simple"; ++ case MemoryModelGLSL450: return "GLSL450"; ++ case MemoryModelOpenCL: return "OpenCL"; ++ case MemoryModelVulkan: return "Vulkan"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ExecutionModeToString(ExecutionMode value) { ++ switch (value) { ++ case ExecutionModeInvocations: return "Invocations"; ++ case ExecutionModeSpacingEqual: return "SpacingEqual"; ++ case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; ++ case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; ++ case ExecutionModeVertexOrderCw: return "VertexOrderCw"; ++ case ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; ++ case ExecutionModePixelCenterInteger: return "PixelCenterInteger"; ++ case ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; ++ case ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; ++ case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; ++ case ExecutionModePointMode: return "PointMode"; ++ case ExecutionModeXfb: return "Xfb"; ++ case ExecutionModeDepthReplacing: return "DepthReplacing"; ++ case ExecutionModeDepthGreater: return "DepthGreater"; ++ case ExecutionModeDepthLess: return "DepthLess"; ++ case ExecutionModeDepthUnchanged: return "DepthUnchanged"; ++ case ExecutionModeLocalSize: return "LocalSize"; ++ case ExecutionModeLocalSizeHint: return "LocalSizeHint"; ++ case ExecutionModeInputPoints: return "InputPoints"; ++ case ExecutionModeInputLines: return "InputLines"; ++ case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; ++ case ExecutionModeTriangles: return "Triangles"; ++ case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; ++ case ExecutionModeQuads: return "Quads"; ++ case ExecutionModeIsolines: return "Isolines"; ++ case ExecutionModeOutputVertices: return "OutputVertices"; ++ case ExecutionModeOutputPoints: return "OutputPoints"; ++ case ExecutionModeOutputLineStrip: return "OutputLineStrip"; ++ case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; ++ case ExecutionModeVecTypeHint: return "VecTypeHint"; ++ case ExecutionModeContractionOff: return "ContractionOff"; ++ case ExecutionModeInitializer: return "Initializer"; ++ case ExecutionModeFinalizer: return "Finalizer"; ++ case ExecutionModeSubgroupSize: return "SubgroupSize"; ++ case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; ++ case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; ++ case ExecutionModeLocalSizeId: return "LocalSizeId"; ++ case ExecutionModeLocalSizeHintId: return "LocalSizeHintId"; ++ case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; ++ case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; ++ case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; ++ case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; ++ case ExecutionModePostDepthCoverage: return "PostDepthCoverage"; ++ case ExecutionModeDenormPreserve: return "DenormPreserve"; ++ case ExecutionModeDenormFlushToZero: return "DenormFlushToZero"; ++ case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; ++ case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; ++ case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; ++ case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; ++ case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; ++ case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; ++ case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; ++ case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; ++ case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; ++ case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; ++ case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; ++ case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; ++ case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; ++ case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; ++ case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; ++ case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; ++ case ExecutionModeOutputLinesEXT: return "OutputLinesEXT"; ++ case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; ++ case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; ++ case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; ++ case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; ++ case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; ++ case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; ++ case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; ++ case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; ++ case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; ++ case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; ++ case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; ++ case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; ++ case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; ++ case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; ++ case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; ++ case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; ++ case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; ++ case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; ++ case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; ++ case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; ++ case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; ++ case ExecutionModeFPFastMathDefault: return "FPFastMathDefault"; ++ case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; ++ case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; ++ case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; ++ case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; ++ case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; ++ case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* StorageClassToString(StorageClass value) { ++ switch (value) { ++ case StorageClassUniformConstant: return "UniformConstant"; ++ case StorageClassInput: return "Input"; ++ case StorageClassUniform: return "Uniform"; ++ case StorageClassOutput: return "Output"; ++ case StorageClassWorkgroup: return "Workgroup"; ++ case StorageClassCrossWorkgroup: return "CrossWorkgroup"; ++ case StorageClassPrivate: return "Private"; ++ case StorageClassFunction: return "Function"; ++ case StorageClassGeneric: return "Generic"; ++ case StorageClassPushConstant: return "PushConstant"; ++ case StorageClassAtomicCounter: return "AtomicCounter"; ++ case StorageClassImage: return "Image"; ++ case StorageClassStorageBuffer: return "StorageBuffer"; ++ case StorageClassTileImageEXT: return "TileImageEXT"; ++ case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; ++ case StorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; ++ case StorageClassCallableDataKHR: return "CallableDataKHR"; ++ case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; ++ case StorageClassRayPayloadKHR: return "RayPayloadKHR"; ++ case StorageClassHitAttributeKHR: return "HitAttributeKHR"; ++ case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; ++ case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; ++ case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; ++ case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; ++ case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; ++ case StorageClassCodeSectionINTEL: return "CodeSectionINTEL"; ++ case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; ++ case StorageClassHostOnlyINTEL: return "HostOnlyINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* DimToString(Dim value) { ++ switch (value) { ++ case Dim1D: return "1D"; ++ case Dim2D: return "2D"; ++ case Dim3D: return "3D"; ++ case DimCube: return "Cube"; ++ case DimRect: return "Rect"; ++ case DimBuffer: return "Buffer"; ++ case DimSubpassData: return "SubpassData"; ++ case DimTileImageDataEXT: return "TileImageDataEXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) { ++ switch (value) { ++ case SamplerAddressingModeNone: return "None"; ++ case SamplerAddressingModeClampToEdge: return "ClampToEdge"; ++ case SamplerAddressingModeClamp: return "Clamp"; ++ case SamplerAddressingModeRepeat: return "Repeat"; ++ case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* SamplerFilterModeToString(SamplerFilterMode value) { ++ switch (value) { ++ case SamplerFilterModeNearest: return "Nearest"; ++ case SamplerFilterModeLinear: return "Linear"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageFormatToString(ImageFormat value) { ++ switch (value) { ++ case ImageFormatUnknown: return "Unknown"; ++ case ImageFormatRgba32f: return "Rgba32f"; ++ case ImageFormatRgba16f: return "Rgba16f"; ++ case ImageFormatR32f: return "R32f"; ++ case ImageFormatRgba8: return "Rgba8"; ++ case ImageFormatRgba8Snorm: return "Rgba8Snorm"; ++ case ImageFormatRg32f: return "Rg32f"; ++ case ImageFormatRg16f: return "Rg16f"; ++ case ImageFormatR11fG11fB10f: return "R11fG11fB10f"; ++ case ImageFormatR16f: return "R16f"; ++ case ImageFormatRgba16: return "Rgba16"; ++ case ImageFormatRgb10A2: return "Rgb10A2"; ++ case ImageFormatRg16: return "Rg16"; ++ case ImageFormatRg8: return "Rg8"; ++ case ImageFormatR16: return "R16"; ++ case ImageFormatR8: return "R8"; ++ case ImageFormatRgba16Snorm: return "Rgba16Snorm"; ++ case ImageFormatRg16Snorm: return "Rg16Snorm"; ++ case ImageFormatRg8Snorm: return "Rg8Snorm"; ++ case ImageFormatR16Snorm: return "R16Snorm"; ++ case ImageFormatR8Snorm: return "R8Snorm"; ++ case ImageFormatRgba32i: return "Rgba32i"; ++ case ImageFormatRgba16i: return "Rgba16i"; ++ case ImageFormatRgba8i: return "Rgba8i"; ++ case ImageFormatR32i: return "R32i"; ++ case ImageFormatRg32i: return "Rg32i"; ++ case ImageFormatRg16i: return "Rg16i"; ++ case ImageFormatRg8i: return "Rg8i"; ++ case ImageFormatR16i: return "R16i"; ++ case ImageFormatR8i: return "R8i"; ++ case ImageFormatRgba32ui: return "Rgba32ui"; ++ case ImageFormatRgba16ui: return "Rgba16ui"; ++ case ImageFormatRgba8ui: return "Rgba8ui"; ++ case ImageFormatR32ui: return "R32ui"; ++ case ImageFormatRgb10a2ui: return "Rgb10a2ui"; ++ case ImageFormatRg32ui: return "Rg32ui"; ++ case ImageFormatRg16ui: return "Rg16ui"; ++ case ImageFormatRg8ui: return "Rg8ui"; ++ case ImageFormatR16ui: return "R16ui"; ++ case ImageFormatR8ui: return "R8ui"; ++ case ImageFormatR64ui: return "R64ui"; ++ case ImageFormatR64i: return "R64i"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageChannelOrderToString(ImageChannelOrder value) { ++ switch (value) { ++ case ImageChannelOrderR: return "R"; ++ case ImageChannelOrderA: return "A"; ++ case ImageChannelOrderRG: return "RG"; ++ case ImageChannelOrderRA: return "RA"; ++ case ImageChannelOrderRGB: return "RGB"; ++ case ImageChannelOrderRGBA: return "RGBA"; ++ case ImageChannelOrderBGRA: return "BGRA"; ++ case ImageChannelOrderARGB: return "ARGB"; ++ case ImageChannelOrderIntensity: return "Intensity"; ++ case ImageChannelOrderLuminance: return "Luminance"; ++ case ImageChannelOrderRx: return "Rx"; ++ case ImageChannelOrderRGx: return "RGx"; ++ case ImageChannelOrderRGBx: return "RGBx"; ++ case ImageChannelOrderDepth: return "Depth"; ++ case ImageChannelOrderDepthStencil: return "DepthStencil"; ++ case ImageChannelOrdersRGB: return "sRGB"; ++ case ImageChannelOrdersRGBx: return "sRGBx"; ++ case ImageChannelOrdersRGBA: return "sRGBA"; ++ case ImageChannelOrdersBGRA: return "sBGRA"; ++ case ImageChannelOrderABGR: return "ABGR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) { ++ switch (value) { ++ case ImageChannelDataTypeSnormInt8: return "SnormInt8"; ++ case ImageChannelDataTypeSnormInt16: return "SnormInt16"; ++ case ImageChannelDataTypeUnormInt8: return "UnormInt8"; ++ case ImageChannelDataTypeUnormInt16: return "UnormInt16"; ++ case ImageChannelDataTypeUnormShort565: return "UnormShort565"; ++ case ImageChannelDataTypeUnormShort555: return "UnormShort555"; ++ case ImageChannelDataTypeUnormInt101010: return "UnormInt101010"; ++ case ImageChannelDataTypeSignedInt8: return "SignedInt8"; ++ case ImageChannelDataTypeSignedInt16: return "SignedInt16"; ++ case ImageChannelDataTypeSignedInt32: return "SignedInt32"; ++ case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; ++ case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; ++ case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; ++ case ImageChannelDataTypeHalfFloat: return "HalfFloat"; ++ case ImageChannelDataTypeFloat: return "Float"; ++ case ImageChannelDataTypeUnormInt24: return "UnormInt24"; ++ case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; ++ case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; ++ case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPRoundingModeToString(FPRoundingMode value) { ++ switch (value) { ++ case FPRoundingModeRTE: return "RTE"; ++ case FPRoundingModeRTZ: return "RTZ"; ++ case FPRoundingModeRTP: return "RTP"; ++ case FPRoundingModeRTN: return "RTN"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* LinkageTypeToString(LinkageType value) { ++ switch (value) { ++ case LinkageTypeExport: return "Export"; ++ case LinkageTypeImport: return "Import"; ++ case LinkageTypeLinkOnceODR: return "LinkOnceODR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* AccessQualifierToString(AccessQualifier value) { ++ switch (value) { ++ case AccessQualifierReadOnly: return "ReadOnly"; ++ case AccessQualifierWriteOnly: return "WriteOnly"; ++ case AccessQualifierReadWrite: return "ReadWrite"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) { ++ switch (value) { ++ case FunctionParameterAttributeZext: return "Zext"; ++ case FunctionParameterAttributeSext: return "Sext"; ++ case FunctionParameterAttributeByVal: return "ByVal"; ++ case FunctionParameterAttributeSret: return "Sret"; ++ case FunctionParameterAttributeNoAlias: return "NoAlias"; ++ case FunctionParameterAttributeNoCapture: return "NoCapture"; ++ case FunctionParameterAttributeNoWrite: return "NoWrite"; ++ case FunctionParameterAttributeNoReadWrite: return "NoReadWrite"; ++ case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* DecorationToString(Decoration value) { ++ switch (value) { ++ case DecorationRelaxedPrecision: return "RelaxedPrecision"; ++ case DecorationSpecId: return "SpecId"; ++ case DecorationBlock: return "Block"; ++ case DecorationBufferBlock: return "BufferBlock"; ++ case DecorationRowMajor: return "RowMajor"; ++ case DecorationColMajor: return "ColMajor"; ++ case DecorationArrayStride: return "ArrayStride"; ++ case DecorationMatrixStride: return "MatrixStride"; ++ case DecorationGLSLShared: return "GLSLShared"; ++ case DecorationGLSLPacked: return "GLSLPacked"; ++ case DecorationCPacked: return "CPacked"; ++ case DecorationBuiltIn: return "BuiltIn"; ++ case DecorationNoPerspective: return "NoPerspective"; ++ case DecorationFlat: return "Flat"; ++ case DecorationPatch: return "Patch"; ++ case DecorationCentroid: return "Centroid"; ++ case DecorationSample: return "Sample"; ++ case DecorationInvariant: return "Invariant"; ++ case DecorationRestrict: return "Restrict"; ++ case DecorationAliased: return "Aliased"; ++ case DecorationVolatile: return "Volatile"; ++ case DecorationConstant: return "Constant"; ++ case DecorationCoherent: return "Coherent"; ++ case DecorationNonWritable: return "NonWritable"; ++ case DecorationNonReadable: return "NonReadable"; ++ case DecorationUniform: return "Uniform"; ++ case DecorationUniformId: return "UniformId"; ++ case DecorationSaturatedConversion: return "SaturatedConversion"; ++ case DecorationStream: return "Stream"; ++ case DecorationLocation: return "Location"; ++ case DecorationComponent: return "Component"; ++ case DecorationIndex: return "Index"; ++ case DecorationBinding: return "Binding"; ++ case DecorationDescriptorSet: return "DescriptorSet"; ++ case DecorationOffset: return "Offset"; ++ case DecorationXfbBuffer: return "XfbBuffer"; ++ case DecorationXfbStride: return "XfbStride"; ++ case DecorationFuncParamAttr: return "FuncParamAttr"; ++ case DecorationFPRoundingMode: return "FPRoundingMode"; ++ case DecorationFPFastMathMode: return "FPFastMathMode"; ++ case DecorationLinkageAttributes: return "LinkageAttributes"; ++ case DecorationNoContraction: return "NoContraction"; ++ case DecorationInputAttachmentIndex: return "InputAttachmentIndex"; ++ case DecorationAlignment: return "Alignment"; ++ case DecorationMaxByteOffset: return "MaxByteOffset"; ++ case DecorationAlignmentId: return "AlignmentId"; ++ case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; ++ case DecorationNoSignedWrap: return "NoSignedWrap"; ++ case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; ++ case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; ++ case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; ++ case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; ++ case DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; ++ case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; ++ case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; ++ case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; ++ case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; ++ case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; ++ case DecorationPassthroughNV: return "PassthroughNV"; ++ case DecorationViewportRelativeNV: return "ViewportRelativeNV"; ++ case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; ++ case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; ++ case DecorationPerViewNV: return "PerViewNV"; ++ case DecorationPerTaskNV: return "PerTaskNV"; ++ case DecorationPerVertexKHR: return "PerVertexKHR"; ++ case DecorationNonUniform: return "NonUniform"; ++ case DecorationRestrictPointer: return "RestrictPointer"; ++ case DecorationAliasedPointer: return "AliasedPointer"; ++ case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; ++ case DecorationBindlessSamplerNV: return "BindlessSamplerNV"; ++ case DecorationBindlessImageNV: return "BindlessImageNV"; ++ case DecorationBoundSamplerNV: return "BoundSamplerNV"; ++ case DecorationBoundImageNV: return "BoundImageNV"; ++ case DecorationSIMTCallINTEL: return "SIMTCallINTEL"; ++ case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; ++ case DecorationClobberINTEL: return "ClobberINTEL"; ++ case DecorationSideEffectsINTEL: return "SideEffectsINTEL"; ++ case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; ++ case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; ++ case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; ++ case DecorationStackCallINTEL: return "StackCallINTEL"; ++ case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; ++ case DecorationCounterBuffer: return "CounterBuffer"; ++ case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; ++ case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; ++ case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; ++ case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; ++ case DecorationRegisterINTEL: return "RegisterINTEL"; ++ case DecorationMemoryINTEL: return "MemoryINTEL"; ++ case DecorationNumbanksINTEL: return "NumbanksINTEL"; ++ case DecorationBankwidthINTEL: return "BankwidthINTEL"; ++ case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; ++ case DecorationSinglepumpINTEL: return "SinglepumpINTEL"; ++ case DecorationDoublepumpINTEL: return "DoublepumpINTEL"; ++ case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; ++ case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; ++ case DecorationMergeINTEL: return "MergeINTEL"; ++ case DecorationBankBitsINTEL: return "BankBitsINTEL"; ++ case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; ++ case DecorationStridesizeINTEL: return "StridesizeINTEL"; ++ case DecorationWordsizeINTEL: return "WordsizeINTEL"; ++ case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; ++ case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; ++ case DecorationCacheSizeINTEL: return "CacheSizeINTEL"; ++ case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; ++ case DecorationPrefetchINTEL: return "PrefetchINTEL"; ++ case DecorationStallEnableINTEL: return "StallEnableINTEL"; ++ case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; ++ case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; ++ case DecorationAliasScopeINTEL: return "AliasScopeINTEL"; ++ case DecorationNoAliasINTEL: return "NoAliasINTEL"; ++ case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; ++ case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; ++ case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; ++ case DecorationBufferLocationINTEL: return "BufferLocationINTEL"; ++ case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; ++ case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; ++ case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; ++ case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; ++ case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; ++ case DecorationStallFreeINTEL: return "StallFreeINTEL"; ++ case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; ++ case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; ++ case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; ++ case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; ++ case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; ++ case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; ++ case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; ++ case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; ++ case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; ++ case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; ++ case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; ++ case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; ++ case DecorationHostAccessINTEL: return "HostAccessINTEL"; ++ case DecorationInitModeINTEL: return "InitModeINTEL"; ++ case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; ++ case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; ++ case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* BuiltInToString(BuiltIn value) { ++ switch (value) { ++ case BuiltInPosition: return "Position"; ++ case BuiltInPointSize: return "PointSize"; ++ case BuiltInClipDistance: return "ClipDistance"; ++ case BuiltInCullDistance: return "CullDistance"; ++ case BuiltInVertexId: return "VertexId"; ++ case BuiltInInstanceId: return "InstanceId"; ++ case BuiltInPrimitiveId: return "PrimitiveId"; ++ case BuiltInInvocationId: return "InvocationId"; ++ case BuiltInLayer: return "Layer"; ++ case BuiltInViewportIndex: return "ViewportIndex"; ++ case BuiltInTessLevelOuter: return "TessLevelOuter"; ++ case BuiltInTessLevelInner: return "TessLevelInner"; ++ case BuiltInTessCoord: return "TessCoord"; ++ case BuiltInPatchVertices: return "PatchVertices"; ++ case BuiltInFragCoord: return "FragCoord"; ++ case BuiltInPointCoord: return "PointCoord"; ++ case BuiltInFrontFacing: return "FrontFacing"; ++ case BuiltInSampleId: return "SampleId"; ++ case BuiltInSamplePosition: return "SamplePosition"; ++ case BuiltInSampleMask: return "SampleMask"; ++ case BuiltInFragDepth: return "FragDepth"; ++ case BuiltInHelperInvocation: return "HelperInvocation"; ++ case BuiltInNumWorkgroups: return "NumWorkgroups"; ++ case BuiltInWorkgroupSize: return "WorkgroupSize"; ++ case BuiltInWorkgroupId: return "WorkgroupId"; ++ case BuiltInLocalInvocationId: return "LocalInvocationId"; ++ case BuiltInGlobalInvocationId: return "GlobalInvocationId"; ++ case BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; ++ case BuiltInWorkDim: return "WorkDim"; ++ case BuiltInGlobalSize: return "GlobalSize"; ++ case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; ++ case BuiltInGlobalOffset: return "GlobalOffset"; ++ case BuiltInGlobalLinearId: return "GlobalLinearId"; ++ case BuiltInSubgroupSize: return "SubgroupSize"; ++ case BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; ++ case BuiltInNumSubgroups: return "NumSubgroups"; ++ case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; ++ case BuiltInSubgroupId: return "SubgroupId"; ++ case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; ++ case BuiltInVertexIndex: return "VertexIndex"; ++ case BuiltInInstanceIndex: return "InstanceIndex"; ++ case BuiltInCoreIDARM: return "CoreIDARM"; ++ case BuiltInCoreCountARM: return "CoreCountARM"; ++ case BuiltInCoreMaxIDARM: return "CoreMaxIDARM"; ++ case BuiltInWarpIDARM: return "WarpIDARM"; ++ case BuiltInWarpMaxIDARM: return "WarpMaxIDARM"; ++ case BuiltInSubgroupEqMask: return "SubgroupEqMask"; ++ case BuiltInSubgroupGeMask: return "SubgroupGeMask"; ++ case BuiltInSubgroupGtMask: return "SubgroupGtMask"; ++ case BuiltInSubgroupLeMask: return "SubgroupLeMask"; ++ case BuiltInSubgroupLtMask: return "SubgroupLtMask"; ++ case BuiltInBaseVertex: return "BaseVertex"; ++ case BuiltInBaseInstance: return "BaseInstance"; ++ case BuiltInDrawIndex: return "DrawIndex"; ++ case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; ++ case BuiltInDeviceIndex: return "DeviceIndex"; ++ case BuiltInViewIndex: return "ViewIndex"; ++ case BuiltInShadingRateKHR: return "ShadingRateKHR"; ++ case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; ++ case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; ++ case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; ++ case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; ++ case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; ++ case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; ++ case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; ++ case BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; ++ case BuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; ++ case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; ++ case BuiltInViewportMaskNV: return "ViewportMaskNV"; ++ case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; ++ case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; ++ case BuiltInPositionPerViewNV: return "PositionPerViewNV"; ++ case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; ++ case BuiltInFullyCoveredEXT: return "FullyCoveredEXT"; ++ case BuiltInTaskCountNV: return "TaskCountNV"; ++ case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; ++ case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; ++ case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; ++ case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; ++ case BuiltInLayerPerViewNV: return "LayerPerViewNV"; ++ case BuiltInMeshViewCountNV: return "MeshViewCountNV"; ++ case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; ++ case BuiltInBaryCoordKHR: return "BaryCoordKHR"; ++ case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; ++ case BuiltInFragSizeEXT: return "FragSizeEXT"; ++ case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; ++ case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; ++ case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; ++ case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; ++ case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; ++ case BuiltInLaunchIdKHR: return "LaunchIdKHR"; ++ case BuiltInLaunchSizeKHR: return "LaunchSizeKHR"; ++ case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; ++ case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; ++ case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; ++ case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; ++ case BuiltInRayTminKHR: return "RayTminKHR"; ++ case BuiltInRayTmaxKHR: return "RayTmaxKHR"; ++ case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; ++ case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; ++ case BuiltInWorldToObjectKHR: return "WorldToObjectKHR"; ++ case BuiltInHitTNV: return "HitTNV"; ++ case BuiltInHitKindKHR: return "HitKindKHR"; ++ case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; ++ case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; ++ case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; ++ case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; ++ case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; ++ case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; ++ case BuiltInWarpsPerSMNV: return "WarpsPerSMNV"; ++ case BuiltInSMCountNV: return "SMCountNV"; ++ case BuiltInWarpIDNV: return "WarpIDNV"; ++ case BuiltInSMIDNV: return "SMIDNV"; ++ case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; ++ case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; ++ case BuiltInCullMaskKHR: return "CullMaskKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* ScopeToString(Scope value) { ++ switch (value) { ++ case ScopeCrossDevice: return "CrossDevice"; ++ case ScopeDevice: return "Device"; ++ case ScopeWorkgroup: return "Workgroup"; ++ case ScopeSubgroup: return "Subgroup"; ++ case ScopeInvocation: return "Invocation"; ++ case ScopeQueueFamily: return "QueueFamily"; ++ case ScopeShaderCallKHR: return "ShaderCallKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* GroupOperationToString(GroupOperation value) { ++ switch (value) { ++ case GroupOperationReduce: return "Reduce"; ++ case GroupOperationInclusiveScan: return "InclusiveScan"; ++ case GroupOperationExclusiveScan: return "ExclusiveScan"; ++ case GroupOperationClusteredReduce: return "ClusteredReduce"; ++ case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; ++ case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; ++ case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) { ++ switch (value) { ++ case KernelEnqueueFlagsNoWait: return "NoWait"; ++ case KernelEnqueueFlagsWaitKernel: return "WaitKernel"; ++ case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CapabilityToString(Capability value) { ++ switch (value) { ++ case CapabilityMatrix: return "Matrix"; ++ case CapabilityShader: return "Shader"; ++ case CapabilityGeometry: return "Geometry"; ++ case CapabilityTessellation: return "Tessellation"; ++ case CapabilityAddresses: return "Addresses"; ++ case CapabilityLinkage: return "Linkage"; ++ case CapabilityKernel: return "Kernel"; ++ case CapabilityVector16: return "Vector16"; ++ case CapabilityFloat16Buffer: return "Float16Buffer"; ++ case CapabilityFloat16: return "Float16"; ++ case CapabilityFloat64: return "Float64"; ++ case CapabilityInt64: return "Int64"; ++ case CapabilityInt64Atomics: return "Int64Atomics"; ++ case CapabilityImageBasic: return "ImageBasic"; ++ case CapabilityImageReadWrite: return "ImageReadWrite"; ++ case CapabilityImageMipmap: return "ImageMipmap"; ++ case CapabilityPipes: return "Pipes"; ++ case CapabilityGroups: return "Groups"; ++ case CapabilityDeviceEnqueue: return "DeviceEnqueue"; ++ case CapabilityLiteralSampler: return "LiteralSampler"; ++ case CapabilityAtomicStorage: return "AtomicStorage"; ++ case CapabilityInt16: return "Int16"; ++ case CapabilityTessellationPointSize: return "TessellationPointSize"; ++ case CapabilityGeometryPointSize: return "GeometryPointSize"; ++ case CapabilityImageGatherExtended: return "ImageGatherExtended"; ++ case CapabilityStorageImageMultisample: return "StorageImageMultisample"; ++ case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; ++ case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; ++ case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; ++ case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; ++ case CapabilityClipDistance: return "ClipDistance"; ++ case CapabilityCullDistance: return "CullDistance"; ++ case CapabilityImageCubeArray: return "ImageCubeArray"; ++ case CapabilitySampleRateShading: return "SampleRateShading"; ++ case CapabilityImageRect: return "ImageRect"; ++ case CapabilitySampledRect: return "SampledRect"; ++ case CapabilityGenericPointer: return "GenericPointer"; ++ case CapabilityInt8: return "Int8"; ++ case CapabilityInputAttachment: return "InputAttachment"; ++ case CapabilitySparseResidency: return "SparseResidency"; ++ case CapabilityMinLod: return "MinLod"; ++ case CapabilitySampled1D: return "Sampled1D"; ++ case CapabilityImage1D: return "Image1D"; ++ case CapabilitySampledCubeArray: return "SampledCubeArray"; ++ case CapabilitySampledBuffer: return "SampledBuffer"; ++ case CapabilityImageBuffer: return "ImageBuffer"; ++ case CapabilityImageMSArray: return "ImageMSArray"; ++ case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; ++ case CapabilityImageQuery: return "ImageQuery"; ++ case CapabilityDerivativeControl: return "DerivativeControl"; ++ case CapabilityInterpolationFunction: return "InterpolationFunction"; ++ case CapabilityTransformFeedback: return "TransformFeedback"; ++ case CapabilityGeometryStreams: return "GeometryStreams"; ++ case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; ++ case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; ++ case CapabilityMultiViewport: return "MultiViewport"; ++ case CapabilitySubgroupDispatch: return "SubgroupDispatch"; ++ case CapabilityNamedBarrier: return "NamedBarrier"; ++ case CapabilityPipeStorage: return "PipeStorage"; ++ case CapabilityGroupNonUniform: return "GroupNonUniform"; ++ case CapabilityGroupNonUniformVote: return "GroupNonUniformVote"; ++ case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; ++ case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; ++ case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; ++ case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; ++ case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; ++ case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; ++ case CapabilityShaderLayer: return "ShaderLayer"; ++ case CapabilityShaderViewportIndex: return "ShaderViewportIndex"; ++ case CapabilityUniformDecoration: return "UniformDecoration"; ++ case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; ++ case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; ++ case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; ++ case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; ++ case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; ++ case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; ++ case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; ++ case CapabilityDrawParameters: return "DrawParameters"; ++ case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; ++ case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; ++ case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; ++ case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; ++ case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; ++ case CapabilityStorageUniform16: return "StorageUniform16"; ++ case CapabilityStoragePushConstant16: return "StoragePushConstant16"; ++ case CapabilityStorageInputOutput16: return "StorageInputOutput16"; ++ case CapabilityDeviceGroup: return "DeviceGroup"; ++ case CapabilityMultiView: return "MultiView"; ++ case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; ++ case CapabilityVariablePointers: return "VariablePointers"; ++ case CapabilityAtomicStorageOps: return "AtomicStorageOps"; ++ case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; ++ case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; ++ case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; ++ case CapabilityStoragePushConstant8: return "StoragePushConstant8"; ++ case CapabilityDenormPreserve: return "DenormPreserve"; ++ case CapabilityDenormFlushToZero: return "DenormFlushToZero"; ++ case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; ++ case CapabilityRoundingModeRTE: return "RoundingModeRTE"; ++ case CapabilityRoundingModeRTZ: return "RoundingModeRTZ"; ++ case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; ++ case CapabilityRayQueryKHR: return "RayQueryKHR"; ++ case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; ++ case CapabilityRayTracingKHR: return "RayTracingKHR"; ++ case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; ++ case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; ++ case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; ++ case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; ++ case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; ++ case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; ++ case CapabilityFragmentMaskAMD: return "FragmentMaskAMD"; ++ case CapabilityStencilExportEXT: return "StencilExportEXT"; ++ case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; ++ case CapabilityInt64ImageEXT: return "Int64ImageEXT"; ++ case CapabilityShaderClockKHR: return "ShaderClockKHR"; ++ case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; ++ case CapabilityQuadControlKHR: return "QuadControlKHR"; ++ case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; ++ case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; ++ case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; ++ case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; ++ case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; ++ case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; ++ case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; ++ case CapabilityMeshShadingNV: return "MeshShadingNV"; ++ case CapabilityImageFootprintNV: return "ImageFootprintNV"; ++ case CapabilityMeshShadingEXT: return "MeshShadingEXT"; ++ case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; ++ case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; ++ case CapabilityFragmentDensityEXT: return "FragmentDensityEXT"; ++ case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; ++ case CapabilityShaderNonUniform: return "ShaderNonUniform"; ++ case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; ++ case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; ++ case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; ++ case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; ++ case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; ++ case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; ++ case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; ++ case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; ++ case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; ++ case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; ++ case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; ++ case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; ++ case CapabilityRayTracingNV: return "RayTracingNV"; ++ case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; ++ case CapabilityVulkanMemoryModel: return "VulkanMemoryModel"; ++ case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; ++ case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; ++ case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; ++ case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; ++ case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; ++ case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; ++ case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; ++ case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; ++ case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; ++ case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; ++ case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; ++ case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; ++ case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; ++ case CapabilityBindlessTextureNV: return "BindlessTextureNV"; ++ case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; ++ case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; ++ case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; ++ case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; ++ case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; ++ case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; ++ case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; ++ case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; ++ case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; ++ case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; ++ case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; ++ case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; ++ case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; ++ case CapabilityAsmINTEL: return "AsmINTEL"; ++ case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; ++ case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; ++ case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; ++ case CapabilityVectorComputeINTEL: return "VectorComputeINTEL"; ++ case CapabilityVectorAnyINTEL: return "VectorAnyINTEL"; ++ case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; ++ case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; ++ case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; ++ case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; ++ case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; ++ case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; ++ case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; ++ case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; ++ case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; ++ case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; ++ case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; ++ case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; ++ case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; ++ case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; ++ case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; ++ case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; ++ case CapabilityLoopFuseINTEL: return "LoopFuseINTEL"; ++ case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; ++ case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; ++ case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; ++ case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; ++ case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; ++ case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; ++ case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; ++ case CapabilityIOPipesINTEL: return "IOPipesINTEL"; ++ case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; ++ case CapabilityFPGARegINTEL: return "FPGARegINTEL"; ++ case CapabilityDotProductInputAll: return "DotProductInputAll"; ++ case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; ++ case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; ++ case CapabilityDotProduct: return "DotProduct"; ++ case CapabilityRayCullMaskKHR: return "RayCullMaskKHR"; ++ case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; ++ case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; ++ case CapabilityBitInstructions: return "BitInstructions"; ++ case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; ++ case CapabilityFloatControls2: return "FloatControls2"; ++ case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; ++ case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; ++ case CapabilityLongCompositesINTEL: return "LongCompositesINTEL"; ++ case CapabilityOptNoneINTEL: return "OptNoneINTEL"; ++ case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; ++ case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; ++ case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; ++ case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; ++ case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; ++ case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; ++ case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; ++ case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; ++ case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; ++ case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; ++ case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; ++ case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; ++ case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; ++ case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; ++ case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryIntersectionToString(RayQueryIntersection value) { ++ switch (value) { ++ case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; ++ case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) { ++ switch (value) { ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; ++ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) { ++ switch (value) { ++ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; ++ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPDenormModeToString(FPDenormMode value) { ++ switch (value) { ++ case FPDenormModePreserve: return "Preserve"; ++ case FPDenormModeFlushToZero: return "FlushToZero"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* FPOperationModeToString(FPOperationMode value) { ++ switch (value) { ++ case FPOperationModeIEEE: return "IEEE"; ++ case FPOperationModeALT: return "ALT"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* QuantizationModesToString(QuantizationModes value) { ++ switch (value) { ++ case QuantizationModesTRN: return "TRN"; ++ case QuantizationModesTRN_ZERO: return "TRN_ZERO"; ++ case QuantizationModesRND: return "RND"; ++ case QuantizationModesRND_ZERO: return "RND_ZERO"; ++ case QuantizationModesRND_INF: return "RND_INF"; ++ case QuantizationModesRND_MIN_INF: return "RND_MIN_INF"; ++ case QuantizationModesRND_CONV: return "RND_CONV"; ++ case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* OverflowModesToString(OverflowModes value) { ++ switch (value) { ++ case OverflowModesWRAP: return "WRAP"; ++ case OverflowModesSAT: return "SAT"; ++ case OverflowModesSAT_ZERO: return "SAT_ZERO"; ++ case OverflowModesSAT_SYM: return "SAT_SYM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* PackedVectorFormatToString(PackedVectorFormat value) { ++ switch (value) { ++ case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) { ++ switch (value) { ++ case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; ++ case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; ++ case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; ++ case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) { ++ switch (value) { ++ case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; ++ case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; ++ case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) { ++ switch (value) { ++ case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; ++ case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* HostAccessQualifierToString(HostAccessQualifier value) { ++ switch (value) { ++ case HostAccessQualifierNoneINTEL: return "NoneINTEL"; ++ case HostAccessQualifierReadINTEL: return "ReadINTEL"; ++ case HostAccessQualifierWriteINTEL: return "WriteINTEL"; ++ case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* LoadCacheControlToString(LoadCacheControl value) { ++ switch (value) { ++ case LoadCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case LoadCacheControlCachedINTEL: return "CachedINTEL"; ++ case LoadCacheControlStreamingINTEL: return "StreamingINTEL"; ++ case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; ++ case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* StoreCacheControlToString(StoreCacheControl value) { ++ switch (value) { ++ case StoreCacheControlUncachedINTEL: return "UncachedINTEL"; ++ case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; ++ case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; ++ case StoreCacheControlStreamingINTEL: return "StreamingINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) { ++ switch (value) { ++ case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; ++ default: return "Unknown"; ++ } ++} ++ ++inline const char* OpToString(Op value) { ++ switch (value) { ++ case OpNop: return "OpNop"; ++ case OpUndef: return "OpUndef"; ++ case OpSourceContinued: return "OpSourceContinued"; ++ case OpSource: return "OpSource"; ++ case OpSourceExtension: return "OpSourceExtension"; ++ case OpName: return "OpName"; ++ case OpMemberName: return "OpMemberName"; ++ case OpString: return "OpString"; ++ case OpLine: return "OpLine"; ++ case OpExtension: return "OpExtension"; ++ case OpExtInstImport: return "OpExtInstImport"; ++ case OpExtInst: return "OpExtInst"; ++ case OpMemoryModel: return "OpMemoryModel"; ++ case OpEntryPoint: return "OpEntryPoint"; ++ case OpExecutionMode: return "OpExecutionMode"; ++ case OpCapability: return "OpCapability"; ++ case OpTypeVoid: return "OpTypeVoid"; ++ case OpTypeBool: return "OpTypeBool"; ++ case OpTypeInt: return "OpTypeInt"; ++ case OpTypeFloat: return "OpTypeFloat"; ++ case OpTypeVector: return "OpTypeVector"; ++ case OpTypeMatrix: return "OpTypeMatrix"; ++ case OpTypeImage: return "OpTypeImage"; ++ case OpTypeSampler: return "OpTypeSampler"; ++ case OpTypeSampledImage: return "OpTypeSampledImage"; ++ case OpTypeArray: return "OpTypeArray"; ++ case OpTypeRuntimeArray: return "OpTypeRuntimeArray"; ++ case OpTypeStruct: return "OpTypeStruct"; ++ case OpTypeOpaque: return "OpTypeOpaque"; ++ case OpTypePointer: return "OpTypePointer"; ++ case OpTypeFunction: return "OpTypeFunction"; ++ case OpTypeEvent: return "OpTypeEvent"; ++ case OpTypeDeviceEvent: return "OpTypeDeviceEvent"; ++ case OpTypeReserveId: return "OpTypeReserveId"; ++ case OpTypeQueue: return "OpTypeQueue"; ++ case OpTypePipe: return "OpTypePipe"; ++ case OpTypeForwardPointer: return "OpTypeForwardPointer"; ++ case OpConstantTrue: return "OpConstantTrue"; ++ case OpConstantFalse: return "OpConstantFalse"; ++ case OpConstant: return "OpConstant"; ++ case OpConstantComposite: return "OpConstantComposite"; ++ case OpConstantSampler: return "OpConstantSampler"; ++ case OpConstantNull: return "OpConstantNull"; ++ case OpSpecConstantTrue: return "OpSpecConstantTrue"; ++ case OpSpecConstantFalse: return "OpSpecConstantFalse"; ++ case OpSpecConstant: return "OpSpecConstant"; ++ case OpSpecConstantComposite: return "OpSpecConstantComposite"; ++ case OpSpecConstantOp: return "OpSpecConstantOp"; ++ case OpFunction: return "OpFunction"; ++ case OpFunctionParameter: return "OpFunctionParameter"; ++ case OpFunctionEnd: return "OpFunctionEnd"; ++ case OpFunctionCall: return "OpFunctionCall"; ++ case OpVariable: return "OpVariable"; ++ case OpImageTexelPointer: return "OpImageTexelPointer"; ++ case OpLoad: return "OpLoad"; ++ case OpStore: return "OpStore"; ++ case OpCopyMemory: return "OpCopyMemory"; ++ case OpCopyMemorySized: return "OpCopyMemorySized"; ++ case OpAccessChain: return "OpAccessChain"; ++ case OpInBoundsAccessChain: return "OpInBoundsAccessChain"; ++ case OpPtrAccessChain: return "OpPtrAccessChain"; ++ case OpArrayLength: return "OpArrayLength"; ++ case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; ++ case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; ++ case OpDecorate: return "OpDecorate"; ++ case OpMemberDecorate: return "OpMemberDecorate"; ++ case OpDecorationGroup: return "OpDecorationGroup"; ++ case OpGroupDecorate: return "OpGroupDecorate"; ++ case OpGroupMemberDecorate: return "OpGroupMemberDecorate"; ++ case OpVectorExtractDynamic: return "OpVectorExtractDynamic"; ++ case OpVectorInsertDynamic: return "OpVectorInsertDynamic"; ++ case OpVectorShuffle: return "OpVectorShuffle"; ++ case OpCompositeConstruct: return "OpCompositeConstruct"; ++ case OpCompositeExtract: return "OpCompositeExtract"; ++ case OpCompositeInsert: return "OpCompositeInsert"; ++ case OpCopyObject: return "OpCopyObject"; ++ case OpTranspose: return "OpTranspose"; ++ case OpSampledImage: return "OpSampledImage"; ++ case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; ++ case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; ++ case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; ++ case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; ++ case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; ++ case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; ++ case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; ++ case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; ++ case OpImageFetch: return "OpImageFetch"; ++ case OpImageGather: return "OpImageGather"; ++ case OpImageDrefGather: return "OpImageDrefGather"; ++ case OpImageRead: return "OpImageRead"; ++ case OpImageWrite: return "OpImageWrite"; ++ case OpImage: return "OpImage"; ++ case OpImageQueryFormat: return "OpImageQueryFormat"; ++ case OpImageQueryOrder: return "OpImageQueryOrder"; ++ case OpImageQuerySizeLod: return "OpImageQuerySizeLod"; ++ case OpImageQuerySize: return "OpImageQuerySize"; ++ case OpImageQueryLod: return "OpImageQueryLod"; ++ case OpImageQueryLevels: return "OpImageQueryLevels"; ++ case OpImageQuerySamples: return "OpImageQuerySamples"; ++ case OpConvertFToU: return "OpConvertFToU"; ++ case OpConvertFToS: return "OpConvertFToS"; ++ case OpConvertSToF: return "OpConvertSToF"; ++ case OpConvertUToF: return "OpConvertUToF"; ++ case OpUConvert: return "OpUConvert"; ++ case OpSConvert: return "OpSConvert"; ++ case OpFConvert: return "OpFConvert"; ++ case OpQuantizeToF16: return "OpQuantizeToF16"; ++ case OpConvertPtrToU: return "OpConvertPtrToU"; ++ case OpSatConvertSToU: return "OpSatConvertSToU"; ++ case OpSatConvertUToS: return "OpSatConvertUToS"; ++ case OpConvertUToPtr: return "OpConvertUToPtr"; ++ case OpPtrCastToGeneric: return "OpPtrCastToGeneric"; ++ case OpGenericCastToPtr: return "OpGenericCastToPtr"; ++ case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; ++ case OpBitcast: return "OpBitcast"; ++ case OpSNegate: return "OpSNegate"; ++ case OpFNegate: return "OpFNegate"; ++ case OpIAdd: return "OpIAdd"; ++ case OpFAdd: return "OpFAdd"; ++ case OpISub: return "OpISub"; ++ case OpFSub: return "OpFSub"; ++ case OpIMul: return "OpIMul"; ++ case OpFMul: return "OpFMul"; ++ case OpUDiv: return "OpUDiv"; ++ case OpSDiv: return "OpSDiv"; ++ case OpFDiv: return "OpFDiv"; ++ case OpUMod: return "OpUMod"; ++ case OpSRem: return "OpSRem"; ++ case OpSMod: return "OpSMod"; ++ case OpFRem: return "OpFRem"; ++ case OpFMod: return "OpFMod"; ++ case OpVectorTimesScalar: return "OpVectorTimesScalar"; ++ case OpMatrixTimesScalar: return "OpMatrixTimesScalar"; ++ case OpVectorTimesMatrix: return "OpVectorTimesMatrix"; ++ case OpMatrixTimesVector: return "OpMatrixTimesVector"; ++ case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; ++ case OpOuterProduct: return "OpOuterProduct"; ++ case OpDot: return "OpDot"; ++ case OpIAddCarry: return "OpIAddCarry"; ++ case OpISubBorrow: return "OpISubBorrow"; ++ case OpUMulExtended: return "OpUMulExtended"; ++ case OpSMulExtended: return "OpSMulExtended"; ++ case OpAny: return "OpAny"; ++ case OpAll: return "OpAll"; ++ case OpIsNan: return "OpIsNan"; ++ case OpIsInf: return "OpIsInf"; ++ case OpIsFinite: return "OpIsFinite"; ++ case OpIsNormal: return "OpIsNormal"; ++ case OpSignBitSet: return "OpSignBitSet"; ++ case OpLessOrGreater: return "OpLessOrGreater"; ++ case OpOrdered: return "OpOrdered"; ++ case OpUnordered: return "OpUnordered"; ++ case OpLogicalEqual: return "OpLogicalEqual"; ++ case OpLogicalNotEqual: return "OpLogicalNotEqual"; ++ case OpLogicalOr: return "OpLogicalOr"; ++ case OpLogicalAnd: return "OpLogicalAnd"; ++ case OpLogicalNot: return "OpLogicalNot"; ++ case OpSelect: return "OpSelect"; ++ case OpIEqual: return "OpIEqual"; ++ case OpINotEqual: return "OpINotEqual"; ++ case OpUGreaterThan: return "OpUGreaterThan"; ++ case OpSGreaterThan: return "OpSGreaterThan"; ++ case OpUGreaterThanEqual: return "OpUGreaterThanEqual"; ++ case OpSGreaterThanEqual: return "OpSGreaterThanEqual"; ++ case OpULessThan: return "OpULessThan"; ++ case OpSLessThan: return "OpSLessThan"; ++ case OpULessThanEqual: return "OpULessThanEqual"; ++ case OpSLessThanEqual: return "OpSLessThanEqual"; ++ case OpFOrdEqual: return "OpFOrdEqual"; ++ case OpFUnordEqual: return "OpFUnordEqual"; ++ case OpFOrdNotEqual: return "OpFOrdNotEqual"; ++ case OpFUnordNotEqual: return "OpFUnordNotEqual"; ++ case OpFOrdLessThan: return "OpFOrdLessThan"; ++ case OpFUnordLessThan: return "OpFUnordLessThan"; ++ case OpFOrdGreaterThan: return "OpFOrdGreaterThan"; ++ case OpFUnordGreaterThan: return "OpFUnordGreaterThan"; ++ case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; ++ case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; ++ case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; ++ case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; ++ case OpShiftRightLogical: return "OpShiftRightLogical"; ++ case OpShiftRightArithmetic: return "OpShiftRightArithmetic"; ++ case OpShiftLeftLogical: return "OpShiftLeftLogical"; ++ case OpBitwiseOr: return "OpBitwiseOr"; ++ case OpBitwiseXor: return "OpBitwiseXor"; ++ case OpBitwiseAnd: return "OpBitwiseAnd"; ++ case OpNot: return "OpNot"; ++ case OpBitFieldInsert: return "OpBitFieldInsert"; ++ case OpBitFieldSExtract: return "OpBitFieldSExtract"; ++ case OpBitFieldUExtract: return "OpBitFieldUExtract"; ++ case OpBitReverse: return "OpBitReverse"; ++ case OpBitCount: return "OpBitCount"; ++ case OpDPdx: return "OpDPdx"; ++ case OpDPdy: return "OpDPdy"; ++ case OpFwidth: return "OpFwidth"; ++ case OpDPdxFine: return "OpDPdxFine"; ++ case OpDPdyFine: return "OpDPdyFine"; ++ case OpFwidthFine: return "OpFwidthFine"; ++ case OpDPdxCoarse: return "OpDPdxCoarse"; ++ case OpDPdyCoarse: return "OpDPdyCoarse"; ++ case OpFwidthCoarse: return "OpFwidthCoarse"; ++ case OpEmitVertex: return "OpEmitVertex"; ++ case OpEndPrimitive: return "OpEndPrimitive"; ++ case OpEmitStreamVertex: return "OpEmitStreamVertex"; ++ case OpEndStreamPrimitive: return "OpEndStreamPrimitive"; ++ case OpControlBarrier: return "OpControlBarrier"; ++ case OpMemoryBarrier: return "OpMemoryBarrier"; ++ case OpAtomicLoad: return "OpAtomicLoad"; ++ case OpAtomicStore: return "OpAtomicStore"; ++ case OpAtomicExchange: return "OpAtomicExchange"; ++ case OpAtomicCompareExchange: return "OpAtomicCompareExchange"; ++ case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; ++ case OpAtomicIIncrement: return "OpAtomicIIncrement"; ++ case OpAtomicIDecrement: return "OpAtomicIDecrement"; ++ case OpAtomicIAdd: return "OpAtomicIAdd"; ++ case OpAtomicISub: return "OpAtomicISub"; ++ case OpAtomicSMin: return "OpAtomicSMin"; ++ case OpAtomicUMin: return "OpAtomicUMin"; ++ case OpAtomicSMax: return "OpAtomicSMax"; ++ case OpAtomicUMax: return "OpAtomicUMax"; ++ case OpAtomicAnd: return "OpAtomicAnd"; ++ case OpAtomicOr: return "OpAtomicOr"; ++ case OpAtomicXor: return "OpAtomicXor"; ++ case OpPhi: return "OpPhi"; ++ case OpLoopMerge: return "OpLoopMerge"; ++ case OpSelectionMerge: return "OpSelectionMerge"; ++ case OpLabel: return "OpLabel"; ++ case OpBranch: return "OpBranch"; ++ case OpBranchConditional: return "OpBranchConditional"; ++ case OpSwitch: return "OpSwitch"; ++ case OpKill: return "OpKill"; ++ case OpReturn: return "OpReturn"; ++ case OpReturnValue: return "OpReturnValue"; ++ case OpUnreachable: return "OpUnreachable"; ++ case OpLifetimeStart: return "OpLifetimeStart"; ++ case OpLifetimeStop: return "OpLifetimeStop"; ++ case OpGroupAsyncCopy: return "OpGroupAsyncCopy"; ++ case OpGroupWaitEvents: return "OpGroupWaitEvents"; ++ case OpGroupAll: return "OpGroupAll"; ++ case OpGroupAny: return "OpGroupAny"; ++ case OpGroupBroadcast: return "OpGroupBroadcast"; ++ case OpGroupIAdd: return "OpGroupIAdd"; ++ case OpGroupFAdd: return "OpGroupFAdd"; ++ case OpGroupFMin: return "OpGroupFMin"; ++ case OpGroupUMin: return "OpGroupUMin"; ++ case OpGroupSMin: return "OpGroupSMin"; ++ case OpGroupFMax: return "OpGroupFMax"; ++ case OpGroupUMax: return "OpGroupUMax"; ++ case OpGroupSMax: return "OpGroupSMax"; ++ case OpReadPipe: return "OpReadPipe"; ++ case OpWritePipe: return "OpWritePipe"; ++ case OpReservedReadPipe: return "OpReservedReadPipe"; ++ case OpReservedWritePipe: return "OpReservedWritePipe"; ++ case OpReserveReadPipePackets: return "OpReserveReadPipePackets"; ++ case OpReserveWritePipePackets: return "OpReserveWritePipePackets"; ++ case OpCommitReadPipe: return "OpCommitReadPipe"; ++ case OpCommitWritePipe: return "OpCommitWritePipe"; ++ case OpIsValidReserveId: return "OpIsValidReserveId"; ++ case OpGetNumPipePackets: return "OpGetNumPipePackets"; ++ case OpGetMaxPipePackets: return "OpGetMaxPipePackets"; ++ case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; ++ case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; ++ case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; ++ case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; ++ case OpEnqueueMarker: return "OpEnqueueMarker"; ++ case OpEnqueueKernel: return "OpEnqueueKernel"; ++ case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; ++ case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; ++ case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; ++ case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; ++ case OpRetainEvent: return "OpRetainEvent"; ++ case OpReleaseEvent: return "OpReleaseEvent"; ++ case OpCreateUserEvent: return "OpCreateUserEvent"; ++ case OpIsValidEvent: return "OpIsValidEvent"; ++ case OpSetUserEventStatus: return "OpSetUserEventStatus"; ++ case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; ++ case OpGetDefaultQueue: return "OpGetDefaultQueue"; ++ case OpBuildNDRange: return "OpBuildNDRange"; ++ case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; ++ case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; ++ case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; ++ case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; ++ case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; ++ case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; ++ case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; ++ case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; ++ case OpImageSparseFetch: return "OpImageSparseFetch"; ++ case OpImageSparseGather: return "OpImageSparseGather"; ++ case OpImageSparseDrefGather: return "OpImageSparseDrefGather"; ++ case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; ++ case OpNoLine: return "OpNoLine"; ++ case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; ++ case OpAtomicFlagClear: return "OpAtomicFlagClear"; ++ case OpImageSparseRead: return "OpImageSparseRead"; ++ case OpSizeOf: return "OpSizeOf"; ++ case OpTypePipeStorage: return "OpTypePipeStorage"; ++ case OpConstantPipeStorage: return "OpConstantPipeStorage"; ++ case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; ++ case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; ++ case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; ++ case OpTypeNamedBarrier: return "OpTypeNamedBarrier"; ++ case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; ++ case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; ++ case OpModuleProcessed: return "OpModuleProcessed"; ++ case OpExecutionModeId: return "OpExecutionModeId"; ++ case OpDecorateId: return "OpDecorateId"; ++ case OpGroupNonUniformElect: return "OpGroupNonUniformElect"; ++ case OpGroupNonUniformAll: return "OpGroupNonUniformAll"; ++ case OpGroupNonUniformAny: return "OpGroupNonUniformAny"; ++ case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; ++ case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; ++ case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; ++ case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; ++ case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; ++ case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; ++ case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; ++ case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; ++ case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; ++ case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; ++ case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; ++ case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; ++ case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; ++ case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; ++ case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; ++ case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; ++ case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; ++ case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; ++ case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; ++ case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; ++ case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; ++ case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; ++ case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; ++ case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; ++ case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; ++ case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; ++ case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; ++ case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; ++ case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; ++ case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; ++ case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; ++ case OpCopyLogical: return "OpCopyLogical"; ++ case OpPtrEqual: return "OpPtrEqual"; ++ case OpPtrNotEqual: return "OpPtrNotEqual"; ++ case OpPtrDiff: return "OpPtrDiff"; ++ case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; ++ case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; ++ case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; ++ case OpTerminateInvocation: return "OpTerminateInvocation"; ++ case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; ++ case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; ++ case OpSubgroupAllKHR: return "OpSubgroupAllKHR"; ++ case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; ++ case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; ++ case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; ++ case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; ++ case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; ++ case OpTraceRayKHR: return "OpTraceRayKHR"; ++ case OpExecuteCallableKHR: return "OpExecuteCallableKHR"; ++ case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; ++ case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; ++ case OpTerminateRayKHR: return "OpTerminateRayKHR"; ++ case OpSDot: return "OpSDot"; ++ case OpUDot: return "OpUDot"; ++ case OpSUDot: return "OpSUDot"; ++ case OpSDotAccSat: return "OpSDotAccSat"; ++ case OpUDotAccSat: return "OpUDotAccSat"; ++ case OpSUDotAccSat: return "OpSUDotAccSat"; ++ case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; ++ case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; ++ case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; ++ case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; ++ case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; ++ case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; ++ case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; ++ case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; ++ case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; ++ case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; ++ case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; ++ case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; ++ case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; ++ case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; ++ case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; ++ case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; ++ case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; ++ case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; ++ case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; ++ case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; ++ case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; ++ case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; ++ case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; ++ case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; ++ case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; ++ case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; ++ case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; ++ case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; ++ case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; ++ case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; ++ case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; ++ case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; ++ case OpFragmentFetchAMD: return "OpFragmentFetchAMD"; ++ case OpReadClockKHR: return "OpReadClockKHR"; ++ case OpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; ++ case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; ++ case OpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; ++ case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; ++ case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; ++ case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; ++ case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; ++ case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; ++ case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; ++ case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; ++ case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; ++ case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; ++ case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; ++ case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; ++ case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; ++ case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; ++ case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; ++ case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; ++ case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; ++ case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; ++ case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; ++ case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; ++ case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; ++ case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; ++ case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; ++ case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; ++ case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; ++ case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; ++ case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; ++ case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; ++ case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; ++ case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; ++ case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; ++ case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; ++ case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; ++ case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; ++ case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; ++ case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; ++ case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; ++ case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; ++ case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; ++ case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; ++ case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; ++ case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; ++ case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; ++ case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; ++ case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; ++ case OpTerminateRayNV: return "OpTerminateRayNV"; ++ case OpTraceNV: return "OpTraceNV"; ++ case OpTraceMotionNV: return "OpTraceMotionNV"; ++ case OpTraceRayMotionNV: return "OpTraceRayMotionNV"; ++ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; ++ case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; ++ case OpExecuteCallableNV: return "OpExecuteCallableNV"; ++ case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; ++ case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; ++ case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; ++ case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; ++ case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; ++ case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; ++ case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; ++ case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; ++ case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; ++ case OpConvertUToImageNV: return "OpConvertUToImageNV"; ++ case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; ++ case OpConvertImageToUNV: return "OpConvertImageToUNV"; ++ case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; ++ case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; ++ case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; ++ case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; ++ case OpRawAccessChainNV: return "OpRawAccessChainNV"; ++ case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; ++ case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; ++ case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; ++ case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; ++ case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; ++ case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; ++ case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; ++ case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; ++ case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; ++ case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; ++ case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; ++ case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; ++ case OpAbsISubINTEL: return "OpAbsISubINTEL"; ++ case OpAbsUSubINTEL: return "OpAbsUSubINTEL"; ++ case OpIAddSatINTEL: return "OpIAddSatINTEL"; ++ case OpUAddSatINTEL: return "OpUAddSatINTEL"; ++ case OpIAverageINTEL: return "OpIAverageINTEL"; ++ case OpUAverageINTEL: return "OpUAverageINTEL"; ++ case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; ++ case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; ++ case OpISubSatINTEL: return "OpISubSatINTEL"; ++ case OpUSubSatINTEL: return "OpUSubSatINTEL"; ++ case OpIMul32x16INTEL: return "OpIMul32x16INTEL"; ++ case OpUMul32x16INTEL: return "OpUMul32x16INTEL"; ++ case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; ++ case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; ++ case OpAsmTargetINTEL: return "OpAsmTargetINTEL"; ++ case OpAsmINTEL: return "OpAsmINTEL"; ++ case OpAsmCallINTEL: return "OpAsmCallINTEL"; ++ case OpAtomicFMinEXT: return "OpAtomicFMinEXT"; ++ case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; ++ case OpAssumeTrueKHR: return "OpAssumeTrueKHR"; ++ case OpExpectKHR: return "OpExpectKHR"; ++ case OpDecorateString: return "OpDecorateString"; ++ case OpMemberDecorateString: return "OpMemberDecorateString"; ++ case OpVmeImageINTEL: return "OpVmeImageINTEL"; ++ case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; ++ case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; ++ case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; ++ case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; ++ case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; ++ case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; ++ case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; ++ case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; ++ case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; ++ case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; ++ case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; ++ case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; ++ case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; ++ case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; ++ case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; ++ case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; ++ case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; ++ case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; ++ case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; ++ case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; ++ case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; ++ case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; ++ case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; ++ case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; ++ case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; ++ case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; ++ case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; ++ case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; ++ case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; ++ case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; ++ case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; ++ case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; ++ case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; ++ case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; ++ case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; ++ case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; ++ case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; ++ case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; ++ case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; ++ case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; ++ case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; ++ case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; ++ case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; ++ case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; ++ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; ++ case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; ++ case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; ++ case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; ++ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; ++ case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; ++ case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; ++ case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; ++ case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; ++ case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; ++ case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; ++ case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; ++ case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; ++ case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; ++ case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; ++ case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; ++ case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; ++ case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; ++ case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; ++ case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; ++ case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; ++ case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; ++ case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; ++ case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; ++ case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; ++ case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; ++ case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; ++ case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; ++ case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; ++ case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; ++ case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; ++ case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; ++ case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; ++ case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; ++ case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; ++ case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; ++ case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; ++ case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; ++ case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; ++ case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; ++ case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; ++ case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; ++ case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; ++ case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; ++ case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; ++ case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; ++ case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; ++ case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; ++ case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; ++ case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; ++ case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; ++ case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; ++ case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; ++ case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; ++ case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; ++ case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; ++ case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; ++ case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; ++ case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; ++ case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; ++ case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; ++ case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; ++ case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; ++ case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; ++ case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; ++ case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; ++ case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; ++ case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; ++ case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; ++ case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; ++ case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; ++ case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; ++ case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; ++ case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; ++ case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; ++ case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; ++ case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; ++ case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; ++ case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; ++ case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; ++ case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; ++ case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; ++ case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; ++ case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; ++ case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; ++ case OpLoopControlINTEL: return "OpLoopControlINTEL"; ++ case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; ++ case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; ++ case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; ++ case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; ++ case OpFixedRecipINTEL: return "OpFixedRecipINTEL"; ++ case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; ++ case OpFixedSinINTEL: return "OpFixedSinINTEL"; ++ case OpFixedCosINTEL: return "OpFixedCosINTEL"; ++ case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; ++ case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; ++ case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; ++ case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; ++ case OpFixedLogINTEL: return "OpFixedLogINTEL"; ++ case OpFixedExpINTEL: return "OpFixedExpINTEL"; ++ case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; ++ case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; ++ case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; ++ case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; ++ case OpFPGARegINTEL: return "OpFPGARegINTEL"; ++ case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; ++ case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; ++ case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; ++ case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; ++ case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; ++ case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; ++ case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; ++ case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; ++ case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; ++ case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; ++ case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; ++ case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; ++ case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; ++ case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; ++ case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; ++ case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; ++ case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; ++ case OpAtomicFAddEXT: return "OpAtomicFAddEXT"; ++ case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; ++ case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; ++ case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; ++ case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; ++ case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; ++ case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; ++ case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; ++ case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; ++ case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; ++ case OpGroupIMulKHR: return "OpGroupIMulKHR"; ++ case OpGroupFMulKHR: return "OpGroupFMulKHR"; ++ case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; ++ case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; ++ case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; ++ case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; ++ case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; ++ case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; ++ case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; ++ case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; ++ default: return "Unknown"; ++ } ++} ++ + #endif /* SPV_ENABLE_UTILITY_CODE */ + + // Overload bitwise operators for mask bit combining +diff --git include/spirv/unified1/spirv.json include/spirv/unified1/spirv.json +index 204a9c5..430c74f 100644 +--- include/spirv/unified1/spirv.json ++++ include/spirv/unified1/spirv.json +@@ -1022,6 +1022,7 @@ + "TileImageColorReadAccessEXT": 4166, + "TileImageDepthReadAccessEXT": 4167, + "TileImageStencilReadAccessEXT": 4168, ++ "CooperativeMatrixLayoutsARM": 4201, + "FragmentShadingRateKHR": 4422, + "SubgroupBallotKHR": 4423, + "DrawParameters": 4427, +@@ -1185,6 +1186,7 @@ + "DotProductKHR": 6019, + "RayCullMaskKHR": 6020, + "CooperativeMatrixKHR": 6022, ++ "ReplicatedCompositesEXT": 6024, + "BitInstructions": 6025, + "GroupNonUniformRotateKHR": 6026, + "FloatControls2": 6029, +@@ -1337,7 +1339,9 @@ + "Values": + { + "RowMajorKHR": 0, +- "ColumnMajorKHR": 1 ++ "ColumnMajorKHR": 1, ++ "RowBlockedInterleavedARM": 4202, ++ "ColumnBlockedInterleavedARM": 4203 + } + }, + { +@@ -1770,6 +1774,7 @@ + "OpSubgroupAllEqualKHR": 4430, + "OpGroupNonUniformRotateKHR": 4431, + "OpSubgroupReadInvocationKHR": 4432, ++ "OpExtInstWithForwardRefsKHR": 4433, + "OpTraceRayKHR": 4445, + "OpExecuteCallableKHR": 4446, + "OpConvertUToAccelerationStructureKHR": 4447, +@@ -1792,6 +1797,9 @@ + "OpCooperativeMatrixStoreKHR": 4458, + "OpCooperativeMatrixMulAddKHR": 4459, + "OpCooperativeMatrixLengthKHR": 4460, ++ "OpConstantCompositeReplicateEXT": 4461, ++ "OpSpecConstantCompositeReplicateEXT": 4462, ++ "OpCompositeConstructReplicateEXT": 4463, + "OpTypeRayQueryKHR": 4472, + "OpRayQueryInitializeKHR": 4473, + "OpRayQueryTerminateKHR": 4474, +diff --git include/spirv/unified1/spirv.lua include/spirv/unified1/spirv.lua +index 6dcd1b8..8f3ded0 100644 +--- include/spirv/unified1/spirv.lua ++++ include/spirv/unified1/spirv.lua +@@ -1007,6 +1007,7 @@ spv = { + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, ++ CooperativeMatrixLayoutsARM = 4201, + FragmentShadingRateKHR = 4422, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, +@@ -1170,6 +1171,7 @@ spv = { + DotProductKHR = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, ++ ReplicatedCompositesEXT = 6024, + BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, +@@ -1307,6 +1309,8 @@ spv = { + CooperativeMatrixLayout = { + RowMajorKHR = 0, + ColumnMajorKHR = 1, ++ RowBlockedInterleavedARM = 4202, ++ ColumnBlockedInterleavedARM = 4203, + }, + + CooperativeMatrixUse = { +@@ -1713,6 +1717,7 @@ spv = { + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1735,6 +1740,9 @@ spv = { + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +diff --git include/spirv/unified1/spirv.py include/spirv/unified1/spirv.py +index 4b011cf..23c0fcc 100644 +--- include/spirv/unified1/spirv.py ++++ include/spirv/unified1/spirv.py +@@ -1007,6 +1007,7 @@ spv = { + 'TileImageColorReadAccessEXT' : 4166, + 'TileImageDepthReadAccessEXT' : 4167, + 'TileImageStencilReadAccessEXT' : 4168, ++ 'CooperativeMatrixLayoutsARM' : 4201, + 'FragmentShadingRateKHR' : 4422, + 'SubgroupBallotKHR' : 4423, + 'DrawParameters' : 4427, +@@ -1170,6 +1171,7 @@ spv = { + 'DotProductKHR' : 6019, + 'RayCullMaskKHR' : 6020, + 'CooperativeMatrixKHR' : 6022, ++ 'ReplicatedCompositesEXT' : 6024, + 'BitInstructions' : 6025, + 'GroupNonUniformRotateKHR' : 6026, + 'FloatControls2' : 6029, +@@ -1307,6 +1309,8 @@ spv = { + 'CooperativeMatrixLayout' : { + 'RowMajorKHR' : 0, + 'ColumnMajorKHR' : 1, ++ 'RowBlockedInterleavedARM' : 4202, ++ 'ColumnBlockedInterleavedARM' : 4203, + }, + + 'CooperativeMatrixUse' : { +@@ -1713,6 +1717,7 @@ spv = { + 'OpSubgroupAllEqualKHR' : 4430, + 'OpGroupNonUniformRotateKHR' : 4431, + 'OpSubgroupReadInvocationKHR' : 4432, ++ 'OpExtInstWithForwardRefsKHR' : 4433, + 'OpTraceRayKHR' : 4445, + 'OpExecuteCallableKHR' : 4446, + 'OpConvertUToAccelerationStructureKHR' : 4447, +@@ -1735,6 +1740,9 @@ spv = { + 'OpCooperativeMatrixStoreKHR' : 4458, + 'OpCooperativeMatrixMulAddKHR' : 4459, + 'OpCooperativeMatrixLengthKHR' : 4460, ++ 'OpConstantCompositeReplicateEXT' : 4461, ++ 'OpSpecConstantCompositeReplicateEXT' : 4462, ++ 'OpCompositeConstructReplicateEXT' : 4463, + 'OpTypeRayQueryKHR' : 4472, + 'OpRayQueryInitializeKHR' : 4473, + 'OpRayQueryTerminateKHR' : 4474, +diff --git include/spirv/unified1/spv.d include/spirv/unified1/spv.d +index 64c115e..295678e 100644 +--- include/spirv/unified1/spv.d ++++ include/spirv/unified1/spv.d +@@ -1052,6 +1052,7 @@ enum Capability : uint + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, ++ CooperativeMatrixLayoutsARM = 4201, + FragmentShadingRateKHR = 4422, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, +@@ -1215,6 +1216,7 @@ enum Capability : uint + DotProductKHR = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, ++ ReplicatedCompositesEXT = 6024, + BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, +@@ -1367,6 +1369,8 @@ enum CooperativeMatrixLayout : uint + { + RowMajorKHR = 0, + ColumnMajorKHR = 1, ++ RowBlockedInterleavedARM = 4202, ++ ColumnBlockedInterleavedARM = 4203, + } + + enum CooperativeMatrixUse : uint +@@ -1782,6 +1786,7 @@ enum Op : uint + OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, + OpSubgroupReadInvocationKHR = 4432, ++ OpExtInstWithForwardRefsKHR = 4433, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, +@@ -1804,6 +1809,9 @@ enum Op : uint + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, ++ OpConstantCompositeReplicateEXT = 4461, ++ OpSpecConstantCompositeReplicateEXT = 4462, ++ OpCompositeConstructReplicateEXT = 4463, + OpTypeRayQueryKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, +diff --git tools/buildHeaders/header.cpp tools/buildHeaders/header.cpp +index d125a79..9dd4e40 100644 +--- tools/buildHeaders/header.cpp ++++ tools/buildHeaders/header.cpp +@@ -98,7 +98,7 @@ namespace { + virtual void printEpilogue(std::ostream&) const { } + virtual void printMeta(std::ostream&) const; + virtual void printTypes(std::ostream&) const { } +- virtual void printHasResultType(std::ostream&) const { }; ++ virtual void printUtility(std::ostream&) const { }; + + virtual std::string escapeComment(const std::string& s) const; + +@@ -369,7 +369,7 @@ IN THE MATERIALS. + printTypes(out); + printMeta(out); + printDefs(out); +- printHasResultType(out); ++ printUtility(out); + printEpilogue(out); + } + +@@ -503,8 +503,20 @@ IN THE MATERIALS. + + virtual std::string fmtEnumUse(const std::string& opPrefix, const std::string& name) const { return pre() + name; } + +- virtual void printHasResultType(std::ostream& out) const override ++ virtual void printUtility(std::ostream& out) const override + { ++ out << "#ifdef SPV_ENABLE_UTILITY_CODE" << std::endl; ++ out << "#ifndef __cplusplus" << std::endl; ++ out << "#include " << std::endl; ++ out << "#endif" << std::endl; ++ ++ printHasResultType(out); ++ printStringFunctions(out); ++ ++ out << "#endif /* SPV_ENABLE_UTILITY_CODE */" << std::endl << std::endl; ++ } ++ ++ void printHasResultType(std::ostream& out) const { + const Json::Value& enums = spvRoot["spv"]["enum"]; + + std::set seenValues; +@@ -515,10 +527,7 @@ IN THE MATERIALS. + continue; + } + +- out << "#ifdef SPV_ENABLE_UTILITY_CODE" << std::endl; +- out << "#ifndef __cplusplus" << std::endl; +- out << "#include " << std::endl; +- out << "#endif" << std::endl; ++ + out << "inline void " << pre() << "HasResultAndType(" << pre() << opName << " opcode, bool *hasResult, bool *hasResultType) {" << std::endl; + out << " *hasResult = *hasResultType = false;" << std::endl; + out << " switch (opcode) {" << std::endl; +@@ -539,7 +548,43 @@ IN THE MATERIALS. + + out << " }" << std::endl; + out << "}" << std::endl; +- out << "#endif /* SPV_ENABLE_UTILITY_CODE */" << std::endl << std::endl; ++ } ++ } ++ ++ void printStringFunctions(std::ostream& out) const { ++ const Json::Value& enums = spvRoot["spv"]["enum"]; ++ ++ for (auto it = enums.begin(); it != enums.end(); ++it) { ++ const auto type = (*it)["Type"].asString(); ++ // Skip bitmasks ++ if (type == "Bit") { ++ continue; ++ } ++ const auto name = (*it)["Name"].asString(); ++ const auto sorted = getSortedVals((*it)["Values"]); ++ ++ std::set seenValues; ++ std::string fullName = pre() + name; ++ ++ out << "inline const char* " << fullName << "ToString(" << fullName << " value) {" << std::endl; ++ out << " switch (value) {" << std::endl; ++ for (const auto& v : sorted) { ++ // Filter out duplicate enum values, which would break the switch statement. ++ // These are probably just extension enums promoted to core. ++ if (seenValues.count(v.first)) { ++ continue; ++ } ++ seenValues.insert(v.first); ++ ++ std::string label{name + v.second}; ++ if (name == "Op") { ++ label = v.second; ++ } ++ out << " " << "case " << pre() << label << ": return " << "\"" << v.second << "\";" << std::endl; ++ } ++ out << " default: return \"Unknown\";" << std::endl; ++ out << " }" << std::endl; ++ out << "}" << std::endl << std::endl; + } + } + }; +diff --git tools/buildHeaders/jsonToSpirv.cpp tools/buildHeaders/jsonToSpirv.cpp +index 34e0972..22beba7 100644 +--- tools/buildHeaders/jsonToSpirv.cpp ++++ tools/buildHeaders/jsonToSpirv.cpp +@@ -471,6 +471,37 @@ unsigned int NumberStringToBit(const std::string& str) + return bit; + } + ++// Given two pairs (name and in core) compares if the order is correct for naming ++// conventions. The conventions are: ++// * Core ++// * KHR ++// * EXT ++// * Vendor (no preference between vendors) ++// ++// Returns true if the order is valid. ++bool SuffixComparison(const std::string& prev, bool prevCore, ++ const std::string& cur, bool curCore) ++{ ++ // Duplicate entry ++ if (prev == cur) return false; ++ ++ if (prevCore) return true; ++ if (curCore) return false; ++ ++ // Both are suffixed names. ++ const bool prevKHR = prev.substr(prev.size() - 3) == "KHR"; ++ const bool prevEXT = prev.substr(prev.size() - 3) == "EXT"; ++ const bool curKHR = cur.substr(cur.size() - 3) == "KHR"; ++ const bool curEXT = cur.substr(cur.size() - 3) == "EXT"; ++ ++ if (prevKHR) return true; ++ if (curKHR) return false; ++ if (prevEXT) return true; ++ if (curEXT) return false; ++ ++ return true; ++} ++ + void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) + { + // only do this once. +@@ -547,6 +578,8 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) + // process the instructions + const Json::Value insts = root["instructions"]; + unsigned maxOpcode = 0; ++ std::string maxName = ""; ++ bool maxCore = false; + bool firstOpcode = true; + for (const auto& inst : insts) { + const auto printingClass = inst["class"].asString(); +@@ -565,8 +598,11 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) + } + const auto opcode = inst["opcode"].asUInt(); + const std::string name = inst["opname"].asString(); ++ std::string version = inst["version"].asString(); + if (firstOpcode) { + maxOpcode = opcode; ++ maxName = name; ++ maxCore = version != "None"; + firstOpcode = false; + } else { + if (maxOpcode > opcode) { +@@ -574,12 +610,20 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) + << " is out of order. It follows the instruction with opcode " << maxOpcode + << std::endl; + std::exit(1); ++ } else if (maxOpcode == opcode && ++ !SuffixComparison(maxName, maxCore, name, ++ version != "None")) { ++ std::cerr << "Error: " << name ++ << " is out of order. It follows alias " << maxName ++ << std::endl; ++ std::exit(1); + } else { + maxOpcode = opcode; ++ maxName = name; ++ maxCore = version != "None"; + } + } + EnumCaps caps = getCaps(inst); +- std::string version = inst["version"].asString(); + std::string lastVersion = inst["lastVersion"].asString(); + Extensions exts = getExts(inst); + OperandParameters operands; +@@ -625,28 +669,41 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) + }; + + unsigned maxValue = 0; ++ std::string maxName = ""; ++ bool maxCore = false; + bool firstValue = true; + for (const auto& enumerant : source["enumerants"]) { + unsigned value; + bool skip_zero_in_bitfield; + std::tie(value, skip_zero_in_bitfield) = getValue(enumerant); ++ std::string name = enumerant["enumerant"].asString(); ++ std::string version = enumerant["version"].asString(); + if (skip_zero_in_bitfield) + continue; + if (firstValue) { + maxValue = value; ++ maxName = name; ++ maxCore = version != "None"; + firstValue = false; + } else { + if (maxValue > value) { +- std::cerr << "Error: " << source["kind"] << " enumerant " << enumerant["enumerant"] ++ std::cerr << "Error: " << source["kind"] << " enumerant " << name + << " is out of order. It has value " << value + << " but follows the enumerant with value " << maxValue << std::endl; + std::exit(1); ++ } else if (maxValue == value && ++ !SuffixComparison(maxName, maxCore, name, ++ version != "None")) { ++ std::cerr << "Error: " << source["kind"] << " enumerant " << name ++ << " is out of order. It follows alias " << maxName << std::endl; ++ std::exit(1); + } else { + maxValue = value; ++ maxName = name; ++ maxCore = version != "None"; + } + } + EnumCaps caps(getCaps(enumerant)); +- std::string version = enumerant["version"].asString(); + std::string lastVersion = enumerant["lastVersion"].asString(); + Extensions exts(getExts(enumerant)); + OperandParameters params; diff --git a/vulkan-sdk-1.3.283.tar.gz b/vulkan-sdk-1.3.283.tar.gz new file mode 100644 index 0000000..c194065 --- /dev/null +++ b/vulkan-sdk-1.3.283.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c1bf1b9951a06d20329871ca8415b8ff5d0bebbc2f49cfd06fd095313e20dee +size 472243 From b36e6e5910d0b6bde62b5ea8814e7649e2fcef5e05175e4c720f132737b649a3 Mon Sep 17 00:00:00 2001 From: Jan Engelhardt Date: Wed, 3 Jul 2024 07:13:28 +0000 Subject: [PATCH 2/3] [info=32f7b29edfe3f81874015833637bf66b39a8d1c02d6e0fa9b4312f731d163b0c] OBS-URL: https://build.opensuse.org/package/show/X11:Wayland/spirv-headers?expand=0&rev=101 --- _scmsync.obsinfo | 4 + build.specials.obscpio | 3 + spirv-headers.changes | 5 - spirv-headers.spec | 5 +- v283-to-2acb319.patch | 6739 ---------------------------------------- 5 files changed, 9 insertions(+), 6747 deletions(-) create mode 100644 _scmsync.obsinfo create mode 100644 build.specials.obscpio delete mode 100644 v283-to-2acb319.patch diff --git a/_scmsync.obsinfo b/_scmsync.obsinfo new file mode 100644 index 0000000..8250904 --- /dev/null +++ b/_scmsync.obsinfo @@ -0,0 +1,4 @@ +mtime: 1715969064 +commit: 32f7b29edfe3f81874015833637bf66b39a8d1c02d6e0fa9b4312f731d163b0c +url: https://src.opensuse.org/jengelh/spirv-headers +revision: master diff --git a/build.specials.obscpio b/build.specials.obscpio new file mode 100644 index 0000000..55e85be --- /dev/null +++ b/build.specials.obscpio @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9551e8ba49de942a6116e50c53b000d639da665de8fc093765211b9b7dedc655 +size 256 diff --git a/spirv-headers.changes b/spirv-headers.changes index dfd78f8..ae02a15 100644 --- a/spirv-headers.changes +++ b/spirv-headers.changes @@ -1,8 +1,3 @@ -------------------------------------------------------------------- -Tue Jun 25 23:56:15 UTC 2024 - Jan Engelhardt - -- Add v283-to-2acb319.patch - ------------------------------------------------------------------- Thu May 16 11:38:08 UTC 2024 - Jan Engelhardt diff --git a/spirv-headers.spec b/spirv-headers.spec index 8beb511..6e6cf31 100644 --- a/spirv-headers.spec +++ b/spirv-headers.spec @@ -24,7 +24,7 @@ # and the independently increasing toolchain release number (283). Name: spirv-headers -Version: 1.6.1+sdk283+g8 +Version: 1.6.1+sdk283 %define innerver 1.3.283 Release: 0 Summary: Machine-readable files from the SPIR-V registry @@ -32,7 +32,6 @@ License: MIT Group: Development/Libraries/C and C++ URL: https://github.com/KhronosGroup/SPIRV-Headers Source: https://github.com/KhronosGroup/SPIRV-Headers/archive/vulkan-sdk-%innerver.tar.gz -Patch1: v283-to-2acb319.patch BuildArch: noarch BuildRequires: cmake >= 2.8 BuildRequires: fdupes @@ -49,7 +48,7 @@ registry. This includes: * The XML registry file. %prep -%autosetup -n SPIRV-Headers-vulkan-sdk-%innerver -p0 +%autosetup -n SPIRV-Headers-vulkan-sdk-%innerver -p1 %build %cmake diff --git a/v283-to-2acb319.patch b/v283-to-2acb319.patch deleted file mode 100644 index bc3b881..0000000 --- a/v283-to-2acb319.patch +++ /dev/null @@ -1,6739 +0,0 @@ -Update to commit vulkan-sdk-1.3.283.0-8-g2acb319. -#git diff vulkan-sdk-1.3.283.0..2acb319 >../update.patch -Needed for building contemporary spirv-tools versions. -diff --git include/spirv/spir-v.xml include/spirv/spir-v.xml -index 52de097..f9b23ac 100644 ---- include/spirv/spir-v.xml -+++ include/spirv/spir-v.xml -@@ -157,7 +157,7 @@ - sure to fill in the vendor attribute, and preferably add a contact - person/address in a comment attribute. --> - -- -+ - - - -@@ -190,7 +190,7 @@ - sure to fill in the vendor attribute, and preferably add a contact - person/address in a comment attribute. --> - -- -+ - - - -diff --git include/spirv/unified1/NonSemanticVkspReflection.h include/spirv/unified1/NonSemanticVkspReflection.h -index 0ef478a..331a3d9 100644 ---- include/spirv/unified1/NonSemanticVkspReflection.h -+++ include/spirv/unified1/NonSemanticVkspReflection.h -@@ -33,7 +33,7 @@ extern "C" { - #endif - - enum { -- NonSemanticVkspReflectionRevision = 1, -+ NonSemanticVkspReflectionRevision = 2, - NonSemanticVkspReflectionRevision_BitWidthPadding = 0x7fffffff - }; - -diff --git include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json -index bee1bea..379457b 100644 ---- include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json -+++ include/spirv/unified1/extinst.nonsemantic.vkspreflection.grammar.json -@@ -1,5 +1,5 @@ - { -- "revision" : 1, -+ "revision" : 2, - "instructions" : [ - { - "opname" : "Configuration", -@@ -12,7 +12,8 @@ - {"kind" : "LiteralString", "name" : "EntryPoint" }, - {"kind" : "LiteralInteger", "name" : "groupCountX" }, - {"kind" : "LiteralInteger", "name" : "groupCountY" }, -- {"kind" : "LiteralInteger", "name" : "groupCountZ" } -+ {"kind" : "LiteralInteger", "name" : "groupCountZ" }, -+ {"kind" : "LiteralInteger", "name" : "dispatchId" } - ] - }, - { -diff --git include/spirv/unified1/spirv.bf include/spirv/unified1/spirv.bf -index 92b95c8..d14f43f 100644 ---- include/spirv/unified1/spirv.bf -+++ include/spirv/unified1/spirv.bf -@@ -1050,6 +1050,7 @@ namespace Spv - TileImageColorReadAccessEXT = 4166, - TileImageDepthReadAccessEXT = 4167, - TileImageStencilReadAccessEXT = 4168, -+ CooperativeMatrixLayoutsARM = 4201, - FragmentShadingRateKHR = 4422, - SubgroupBallotKHR = 4423, - DrawParameters = 4427, -@@ -1213,6 +1214,7 @@ namespace Spv - DotProductKHR = 6019, - RayCullMaskKHR = 6020, - CooperativeMatrixKHR = 6022, -+ ReplicatedCompositesEXT = 6024, - BitInstructions = 6025, - GroupNonUniformRotateKHR = 6026, - FloatControls2 = 6029, -@@ -1365,6 +1367,8 @@ namespace Spv - { - RowMajorKHR = 0, - ColumnMajorKHR = 1, -+ RowBlockedInterleavedARM = 4202, -+ ColumnBlockedInterleavedARM = 4203, - } - - [AllowDuplicates, CRepr] public enum CooperativeMatrixUse -@@ -1780,6 +1784,7 @@ namespace Spv - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1802,6 +1807,9 @@ namespace Spv - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -diff --git include/spirv/unified1/spirv.core.grammar.json include/spirv/unified1/spirv.core.grammar.json -index 5d904ca..980b5dc 100644 ---- include/spirv/unified1/spirv.core.grammar.json -+++ include/spirv/unified1/spirv.core.grammar.json -@@ -4539,6 +4539,20 @@ - "extensions" : [ "SPV_KHR_shader_ballot" ], - "version" : "None" - }, -+ { -+ "opname" : "OpExtInstWithForwardRefsKHR", -+ "class" : "Extension", -+ "opcode" : 4433, -+ "operands" : [ -+ { "kind" : "IdResultType" }, -+ { "kind" : "IdResult" }, -+ { "kind" : "IdRef", "name" : "'Set'" }, -+ { "kind" : "LiteralExtInstInteger", "name" : "'Instruction'" }, -+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Operand 1', +\n'Operand 2', +\n..." } -+ ], -+ "extensions" : [ "SPV_KHR_relaxed_extended_instruction" ], -+ "version": "None" -+ }, - { - "opname" : "OpTraceRayKHR", - "class" : "Reserved", -@@ -4854,6 +4868,42 @@ - "capabilities" : [ "CooperativeMatrixKHR" ], - "version" : "None" - }, -+ { -+ "opname" : "OpConstantCompositeReplicateEXT", -+ "class" : "Constant-Creation", -+ "opcode" : 4461, -+ "operands" : [ -+ { "kind" : "IdResultType" }, -+ { "kind" : "IdResult" }, -+ { "kind" : "IdRef", "name" : "'Value'" } -+ ], -+ "capabilities" : [ "ReplicatedCompositesEXT" ], -+ "version" : "None" -+ }, -+ { -+ "opname" : "OpSpecConstantCompositeReplicateEXT", -+ "class" : "Constant-Creation", -+ "opcode" : 4462, -+ "operands" : [ -+ { "kind" : "IdResultType" }, -+ { "kind" : "IdResult" }, -+ { "kind" : "IdRef", "name" : "'Value'" } -+ ], -+ "capabilities" : [ "ReplicatedCompositesEXT" ], -+ "version" : "None" -+ }, -+ { -+ "opname" : "OpCompositeConstructReplicateEXT", -+ "class" : "Composite", -+ "opcode" : 4463, -+ "operands" : [ -+ { "kind" : "IdResultType" }, -+ { "kind" : "IdResult" }, -+ { "kind" : "IdRef", "name" : "'Value'" } -+ ], -+ "capabilities" : [ "ReplicatedCompositesEXT" ], -+ "version" : "None" -+ }, - { - "opname" : "OpTypeRayQueryKHR", - "class" : "Type-Declaration", -@@ -5888,7 +5938,7 @@ - "version" : "None" - }, - { -- "opname" : "OpReportIntersectionNV", -+ "opname" : "OpReportIntersectionKHR", - "class" : "Reserved", - "opcode" : 5334, - "operands" : [ -@@ -5902,7 +5952,7 @@ - "version" : "None" - }, - { -- "opname" : "OpReportIntersectionKHR", -+ "opname" : "OpReportIntersectionNV", - "class" : "Reserved", - "opcode" : 5334, - "operands" : [ -@@ -6019,7 +6069,7 @@ - "version" : "None" - }, - { -- "opname" : "OpTypeAccelerationStructureNV", -+ "opname" : "OpTypeAccelerationStructureKHR", - "class" : "Type-Declaration", - "opcode" : 5341, - "operands" : [ -@@ -6030,7 +6080,7 @@ - "version" : "None" - }, - { -- "opname" : "OpTypeAccelerationStructureKHR", -+ "opname" : "OpTypeAccelerationStructureNV", - "class" : "Type-Declaration", - "opcode" : 5341, - "operands" : [ -@@ -10836,12 +10886,6 @@ - "capabilities" : [ "MeshShadingNV" ], - "version" : "None" - }, -- { -- "enumerant" : "RayGenerationNV", -- "value" : 5313, -- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -- "version" : "None" -- }, - { - "enumerant" : "RayGenerationKHR", - "value" : 5313, -@@ -10849,8 +10893,8 @@ - "version" : "None" - }, - { -- "enumerant" : "IntersectionNV", -- "value" : 5314, -+ "enumerant" : "RayGenerationNV", -+ "value" : 5313, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -@@ -10861,8 +10905,8 @@ - "version" : "None" - }, - { -- "enumerant" : "AnyHitNV", -- "value" : 5315, -+ "enumerant" : "IntersectionNV", -+ "value" : 5314, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -@@ -10873,8 +10917,8 @@ - "version" : "None" - }, - { -- "enumerant" : "ClosestHitNV", -- "value" : 5316, -+ "enumerant" : "AnyHitNV", -+ "value" : 5315, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -@@ -10885,8 +10929,8 @@ - "version" : "None" - }, - { -- "enumerant" : "MissNV", -- "value" : 5317, -+ "enumerant" : "ClosestHitNV", -+ "value" : 5316, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -@@ -10897,8 +10941,8 @@ - "version" : "None" - }, - { -- "enumerant" : "CallableNV", -- "value" : 5318, -+ "enumerant" : "MissNV", -+ "value" : 5317, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -@@ -10908,6 +10952,12 @@ - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -+ { -+ "enumerant" : "CallableNV", -+ "value" : 5318, -+ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -+ "version" : "None" -+ }, - { - "enumerant" : "TaskEXT", - "value" : 5364, -@@ -11460,13 +11510,6 @@ - "capabilities" : [ "QuadControlKHR" ], - "version" : "None" - }, -- { -- "enumerant" : "OutputLinesNV", -- "value" : 5269, -- "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], -- "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], -- "version" : "None" -- }, - { - "enumerant" : "OutputLinesEXT", - "value" : 5269, -@@ -11475,7 +11518,14 @@ - "version" : "None" - }, - { -- "enumerant" : "OutputPrimitivesNV", -+ "enumerant" : "OutputLinesNV", -+ "value" : 5269, -+ "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], -+ "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], -+ "version" : "None" -+ }, -+ { -+ "enumerant" : "OutputPrimitivesEXT", - "value" : 5270, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "parameters" : [ -@@ -11485,7 +11535,7 @@ - "version" : "None" - }, - { -- "enumerant" : "OutputPrimitivesEXT", -+ "enumerant" : "OutputPrimitivesNV", - "value" : 5270, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "parameters" : [ -@@ -11509,14 +11559,14 @@ - "version" : "None" - }, - { -- "enumerant" : "OutputTrianglesNV", -+ "enumerant" : "OutputTrianglesEXT", - "value" : 5298, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], - "version" : "None" - }, - { -- "enumerant" : "OutputTrianglesEXT", -+ "enumerant" : "OutputTrianglesNV", - "value" : 5298, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], -@@ -11828,13 +11878,6 @@ - "capabilities" : [ "ShaderEnqueueAMDX" ], - "version" : "None" - }, -- { -- "enumerant" : "CallableDataNV", -- "value" : 5328, -- "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -- "version" : "None" -- }, - { - "enumerant" : "CallableDataKHR", - "value" : 5328, -@@ -11843,8 +11886,8 @@ - "version" : "None" - }, - { -- "enumerant" : "IncomingCallableDataNV", -- "value" : 5329, -+ "enumerant" : "CallableDataNV", -+ "value" : 5328, - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" -@@ -11857,8 +11900,8 @@ - "version" : "None" - }, - { -- "enumerant" : "RayPayloadNV", -- "value" : 5338, -+ "enumerant" : "IncomingCallableDataNV", -+ "value" : 5329, - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" -@@ -11871,8 +11914,8 @@ - "version" : "None" - }, - { -- "enumerant" : "HitAttributeNV", -- "value" : 5339, -+ "enumerant" : "RayPayloadNV", -+ "value" : 5338, - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" -@@ -11885,8 +11928,8 @@ - "version" : "None" - }, - { -- "enumerant" : "IncomingRayPayloadNV", -- "value" : 5342, -+ "enumerant" : "HitAttributeNV", -+ "value" : 5339, - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" -@@ -11899,8 +11942,8 @@ - "version" : "None" - }, - { -- "enumerant" : "ShaderRecordBufferNV", -- "value" : 5343, -+ "enumerant" : "IncomingRayPayloadNV", -+ "value" : 5342, - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" -@@ -11912,6 +11955,13 @@ - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "version" : "None" - }, -+ { -+ "enumerant" : "ShaderRecordBufferNV", -+ "value" : 5343, -+ "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -+ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -+ "version" : "None" -+ }, - { - "enumerant" : "PhysicalStorageBuffer", - "value" : 5349, -@@ -13263,14 +13313,14 @@ - ] - }, - { -- "enumerant" : "PerPrimitiveNV", -+ "enumerant" : "PerPrimitiveEXT", - "value" : 5271, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], - "version" : "None" - }, - { -- "enumerant" : "PerPrimitiveEXT", -+ "enumerant" : "PerPrimitiveNV", - "value" : 5271, - "capabilities" : [ "MeshShadingNV", "MeshShadingEXT" ], - "extensions" : [ "SPV_NV_mesh_shader", "SPV_EXT_mesh_shader" ], -@@ -14569,13 +14619,6 @@ - "extensions" : [ "SPV_EXT_mesh_shader" ], - "version" : "None" - }, -- { -- "enumerant" : "LaunchIdNV", -- "value" : 5319, -- "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -- "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -- "version" : "None" -- }, - { - "enumerant" : "LaunchIdKHR", - "value" : 5319, -@@ -14584,8 +14627,8 @@ - "version" : "None" - }, - { -- "enumerant" : "LaunchSizeNV", -- "value" : 5320, -+ "enumerant" : "LaunchIdNV", -+ "value" : 5319, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14598,8 +14641,8 @@ - "version" : "None" - }, - { -- "enumerant" : "WorldRayOriginNV", -- "value" : 5321, -+ "enumerant" : "LaunchSizeNV", -+ "value" : 5320, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14612,8 +14655,8 @@ - "version" : "None" - }, - { -- "enumerant" : "WorldRayDirectionNV", -- "value" : 5322, -+ "enumerant" : "WorldRayOriginNV", -+ "value" : 5321, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14626,8 +14669,8 @@ - "version" : "None" - }, - { -- "enumerant" : "ObjectRayOriginNV", -- "value" : 5323, -+ "enumerant" : "WorldRayDirectionNV", -+ "value" : 5322, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14640,8 +14683,8 @@ - "version" : "None" - }, - { -- "enumerant" : "ObjectRayDirectionNV", -- "value" : 5324, -+ "enumerant" : "ObjectRayOriginNV", -+ "value" : 5323, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14654,8 +14697,8 @@ - "version" : "None" - }, - { -- "enumerant" : "RayTminNV", -- "value" : 5325, -+ "enumerant" : "ObjectRayDirectionNV", -+ "value" : 5324, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14668,8 +14711,8 @@ - "version" : "None" - }, - { -- "enumerant" : "RayTmaxNV", -- "value" : 5326, -+ "enumerant" : "RayTminNV", -+ "value" : 5325, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14682,8 +14725,8 @@ - "version" : "None" - }, - { -- "enumerant" : "InstanceCustomIndexNV", -- "value" : 5327, -+ "enumerant" : "RayTmaxNV", -+ "value" : 5326, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14696,8 +14739,8 @@ - "version" : "None" - }, - { -- "enumerant" : "ObjectToWorldNV", -- "value" : 5330, -+ "enumerant" : "InstanceCustomIndexNV", -+ "value" : 5327, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14710,8 +14753,8 @@ - "version" : "None" - }, - { -- "enumerant" : "WorldToObjectNV", -- "value" : 5331, -+ "enumerant" : "ObjectToWorldNV", -+ "value" : 5330, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" -@@ -14723,6 +14766,13 @@ - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" - }, -+ { -+ "enumerant" : "WorldToObjectNV", -+ "value" : 5331, -+ "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], -+ "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -+ "version" : "None" -+ }, - { - "enumerant" : "HitTNV", - "value" : 5332, -@@ -14731,14 +14781,14 @@ - "version" : "None" - }, - { -- "enumerant" : "HitKindNV", -+ "enumerant" : "HitKindKHR", - "value" : 5333, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" - }, - { -- "enumerant" : "HitKindKHR", -+ "enumerant" : "HitKindNV", - "value" : 5333, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -@@ -14770,14 +14820,14 @@ - "version" : "None" - }, - { -- "enumerant" : "IncomingRayFlagsNV", -+ "enumerant" : "IncomingRayFlagsKHR", - "value" : 5351, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], - "version" : "None" - }, - { -- "enumerant" : "IncomingRayFlagsKHR", -+ "enumerant" : "IncomingRayFlagsNV", - "value" : 5351, - "capabilities" : [ "RayTracingNV" , "RayTracingKHR" ], - "extensions" : [ "SPV_NV_ray_tracing" , "SPV_KHR_ray_tracing" ], -@@ -15396,6 +15446,12 @@ - "extensions" : [ "SPV_EXT_shader_tile_image" ], - "version" : "None" - }, -+ { -+ "enumerant" : "CooperativeMatrixLayoutsARM", -+ "value" : 4201, -+ "extensions" : [ "SPV_ARM_cooperative_matrix_layouts" ], -+ "version" : "None" -+ }, - { - "enumerant" : "FragmentShadingRateKHR", - "value" : 4422, -@@ -16442,6 +16498,12 @@ - "extensions" : [ "SPV_KHR_cooperative_matrix" ], - "version" : "None" - }, -+ { -+ "enumerant" : "ReplicatedCompositesEXT", -+ "value" : 6024, -+ "extensions" : [ "SPV_EXT_replicated_composites" ], -+ "version" : "None" -+ }, - { - "enumerant" : "BitInstructions", - "value" : 6025, -@@ -16705,6 +16767,16 @@ - "enumerant" : "ColumnMajorKHR", - "value" : 1, - "version" : "None" -+ }, -+ { -+ "enumerant" : "RowBlockedInterleavedARM", -+ "value" : 4202, -+ "version" : "None" -+ }, -+ { -+ "enumerant" : "ColumnBlockedInterleavedARM", -+ "value" : 4203, -+ "version" : "None" - } - ] - }, -diff --git include/spirv/unified1/spirv.cs include/spirv/unified1/spirv.cs -index 8d85cce..aaba96f 100644 ---- include/spirv/unified1/spirv.cs -+++ include/spirv/unified1/spirv.cs -@@ -1049,6 +1049,7 @@ namespace Spv - TileImageColorReadAccessEXT = 4166, - TileImageDepthReadAccessEXT = 4167, - TileImageStencilReadAccessEXT = 4168, -+ CooperativeMatrixLayoutsARM = 4201, - FragmentShadingRateKHR = 4422, - SubgroupBallotKHR = 4423, - DrawParameters = 4427, -@@ -1212,6 +1213,7 @@ namespace Spv - DotProductKHR = 6019, - RayCullMaskKHR = 6020, - CooperativeMatrixKHR = 6022, -+ ReplicatedCompositesEXT = 6024, - BitInstructions = 6025, - GroupNonUniformRotateKHR = 6026, - FloatControls2 = 6029, -@@ -1364,6 +1366,8 @@ namespace Spv - { - RowMajorKHR = 0, - ColumnMajorKHR = 1, -+ RowBlockedInterleavedARM = 4202, -+ ColumnBlockedInterleavedARM = 4203, - } - - public enum CooperativeMatrixUse -@@ -1779,6 +1783,7 @@ namespace Spv - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1801,6 +1806,9 @@ namespace Spv - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -diff --git include/spirv/unified1/spirv.h include/spirv/unified1/spirv.h -index e544a85..42790e0 100644 ---- include/spirv/unified1/spirv.h -+++ include/spirv/unified1/spirv.h -@@ -1049,6 +1049,7 @@ typedef enum SpvCapability_ { - SpvCapabilityTileImageColorReadAccessEXT = 4166, - SpvCapabilityTileImageDepthReadAccessEXT = 4167, - SpvCapabilityTileImageStencilReadAccessEXT = 4168, -+ SpvCapabilityCooperativeMatrixLayoutsARM = 4201, - SpvCapabilityFragmentShadingRateKHR = 4422, - SpvCapabilitySubgroupBallotKHR = 4423, - SpvCapabilityDrawParameters = 4427, -@@ -1212,6 +1213,7 @@ typedef enum SpvCapability_ { - SpvCapabilityDotProductKHR = 6019, - SpvCapabilityRayCullMaskKHR = 6020, - SpvCapabilityCooperativeMatrixKHR = 6022, -+ SpvCapabilityReplicatedCompositesEXT = 6024, - SpvCapabilityBitInstructions = 6025, - SpvCapabilityGroupNonUniformRotateKHR = 6026, - SpvCapabilityFloatControls2 = 6029, -@@ -1361,6 +1363,8 @@ typedef enum SpvCooperativeMatrixOperandsMask_ { - typedef enum SpvCooperativeMatrixLayout_ { - SpvCooperativeMatrixLayoutRowMajorKHR = 0, - SpvCooperativeMatrixLayoutColumnMajorKHR = 1, -+ SpvCooperativeMatrixLayoutRowBlockedInterleavedARM = 4202, -+ SpvCooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203, - SpvCooperativeMatrixLayoutMax = 0x7fffffff, - } SpvCooperativeMatrixLayout; - -@@ -1775,6 +1779,7 @@ typedef enum SpvOp_ { - SpvOpSubgroupAllEqualKHR = 4430, - SpvOpGroupNonUniformRotateKHR = 4431, - SpvOpSubgroupReadInvocationKHR = 4432, -+ SpvOpExtInstWithForwardRefsKHR = 4433, - SpvOpTraceRayKHR = 4445, - SpvOpExecuteCallableKHR = 4446, - SpvOpConvertUToAccelerationStructureKHR = 4447, -@@ -1797,6 +1802,9 @@ typedef enum SpvOp_ { - SpvOpCooperativeMatrixStoreKHR = 4458, - SpvOpCooperativeMatrixMulAddKHR = 4459, - SpvOpCooperativeMatrixLengthKHR = 4460, -+ SpvOpConstantCompositeReplicateEXT = 4461, -+ SpvOpSpecConstantCompositeReplicateEXT = 4462, -+ SpvOpCompositeConstructReplicateEXT = 4463, - SpvOpTypeRayQueryKHR = 4472, - SpvOpRayQueryInitializeKHR = 4473, - SpvOpRayQueryTerminateKHR = 4474, -@@ -2519,6 +2527,7 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy - case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; - case SpvOpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; - case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; -+ case SpvOpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; - case SpvOpTraceRayKHR: *hasResult = false; *hasResultType = false; break; - case SpvOpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; - case SpvOpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; -@@ -2535,6 +2544,9 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy - case SpvOpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; - case SpvOpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; - case SpvOpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; -+ case SpvOpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case SpvOpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case SpvOpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; - case SpvOpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; - case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; - case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; -@@ -2606,14 +2618,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy - case SpvOpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; - case SpvOpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; - case SpvOpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; -- case SpvOpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; -+ case SpvOpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; - case SpvOpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; - case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break; - case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break; - case SpvOpTraceMotionNV: *hasResult = false; *hasResultType = false; break; - case SpvOpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; - case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; -- case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; -+ case SpvOpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; - case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; - case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; -@@ -2888,6 +2900,1787 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy - case SpvOpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; - } - } -+inline const char* SpvSourceLanguageToString(SpvSourceLanguage value) { -+ switch (value) { -+ case SpvSourceLanguageUnknown: return "Unknown"; -+ case SpvSourceLanguageESSL: return "ESSL"; -+ case SpvSourceLanguageGLSL: return "GLSL"; -+ case SpvSourceLanguageOpenCL_C: return "OpenCL_C"; -+ case SpvSourceLanguageOpenCL_CPP: return "OpenCL_CPP"; -+ case SpvSourceLanguageHLSL: return "HLSL"; -+ case SpvSourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; -+ case SpvSourceLanguageSYCL: return "SYCL"; -+ case SpvSourceLanguageHERO_C: return "HERO_C"; -+ case SpvSourceLanguageNZSL: return "NZSL"; -+ case SpvSourceLanguageWGSL: return "WGSL"; -+ case SpvSourceLanguageSlang: return "Slang"; -+ case SpvSourceLanguageZig: return "Zig"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvExecutionModelToString(SpvExecutionModel value) { -+ switch (value) { -+ case SpvExecutionModelVertex: return "Vertex"; -+ case SpvExecutionModelTessellationControl: return "TessellationControl"; -+ case SpvExecutionModelTessellationEvaluation: return "TessellationEvaluation"; -+ case SpvExecutionModelGeometry: return "Geometry"; -+ case SpvExecutionModelFragment: return "Fragment"; -+ case SpvExecutionModelGLCompute: return "GLCompute"; -+ case SpvExecutionModelKernel: return "Kernel"; -+ case SpvExecutionModelTaskNV: return "TaskNV"; -+ case SpvExecutionModelMeshNV: return "MeshNV"; -+ case SpvExecutionModelRayGenerationKHR: return "RayGenerationKHR"; -+ case SpvExecutionModelIntersectionKHR: return "IntersectionKHR"; -+ case SpvExecutionModelAnyHitKHR: return "AnyHitKHR"; -+ case SpvExecutionModelClosestHitKHR: return "ClosestHitKHR"; -+ case SpvExecutionModelMissKHR: return "MissKHR"; -+ case SpvExecutionModelCallableKHR: return "CallableKHR"; -+ case SpvExecutionModelTaskEXT: return "TaskEXT"; -+ case SpvExecutionModelMeshEXT: return "MeshEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvAddressingModelToString(SpvAddressingModel value) { -+ switch (value) { -+ case SpvAddressingModelLogical: return "Logical"; -+ case SpvAddressingModelPhysical32: return "Physical32"; -+ case SpvAddressingModelPhysical64: return "Physical64"; -+ case SpvAddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvMemoryModelToString(SpvMemoryModel value) { -+ switch (value) { -+ case SpvMemoryModelSimple: return "Simple"; -+ case SpvMemoryModelGLSL450: return "GLSL450"; -+ case SpvMemoryModelOpenCL: return "OpenCL"; -+ case SpvMemoryModelVulkan: return "Vulkan"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvExecutionModeToString(SpvExecutionMode value) { -+ switch (value) { -+ case SpvExecutionModeInvocations: return "Invocations"; -+ case SpvExecutionModeSpacingEqual: return "SpacingEqual"; -+ case SpvExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; -+ case SpvExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; -+ case SpvExecutionModeVertexOrderCw: return "VertexOrderCw"; -+ case SpvExecutionModeVertexOrderCcw: return "VertexOrderCcw"; -+ case SpvExecutionModePixelCenterInteger: return "PixelCenterInteger"; -+ case SpvExecutionModeOriginUpperLeft: return "OriginUpperLeft"; -+ case SpvExecutionModeOriginLowerLeft: return "OriginLowerLeft"; -+ case SpvExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; -+ case SpvExecutionModePointMode: return "PointMode"; -+ case SpvExecutionModeXfb: return "Xfb"; -+ case SpvExecutionModeDepthReplacing: return "DepthReplacing"; -+ case SpvExecutionModeDepthGreater: return "DepthGreater"; -+ case SpvExecutionModeDepthLess: return "DepthLess"; -+ case SpvExecutionModeDepthUnchanged: return "DepthUnchanged"; -+ case SpvExecutionModeLocalSize: return "LocalSize"; -+ case SpvExecutionModeLocalSizeHint: return "LocalSizeHint"; -+ case SpvExecutionModeInputPoints: return "InputPoints"; -+ case SpvExecutionModeInputLines: return "InputLines"; -+ case SpvExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; -+ case SpvExecutionModeTriangles: return "Triangles"; -+ case SpvExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; -+ case SpvExecutionModeQuads: return "Quads"; -+ case SpvExecutionModeIsolines: return "Isolines"; -+ case SpvExecutionModeOutputVertices: return "OutputVertices"; -+ case SpvExecutionModeOutputPoints: return "OutputPoints"; -+ case SpvExecutionModeOutputLineStrip: return "OutputLineStrip"; -+ case SpvExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; -+ case SpvExecutionModeVecTypeHint: return "VecTypeHint"; -+ case SpvExecutionModeContractionOff: return "ContractionOff"; -+ case SpvExecutionModeInitializer: return "Initializer"; -+ case SpvExecutionModeFinalizer: return "Finalizer"; -+ case SpvExecutionModeSubgroupSize: return "SubgroupSize"; -+ case SpvExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; -+ case SpvExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; -+ case SpvExecutionModeLocalSizeId: return "LocalSizeId"; -+ case SpvExecutionModeLocalSizeHintId: return "LocalSizeHintId"; -+ case SpvExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; -+ case SpvExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; -+ case SpvExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; -+ case SpvExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; -+ case SpvExecutionModePostDepthCoverage: return "PostDepthCoverage"; -+ case SpvExecutionModeDenormPreserve: return "DenormPreserve"; -+ case SpvExecutionModeDenormFlushToZero: return "DenormFlushToZero"; -+ case SpvExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case SpvExecutionModeRoundingModeRTE: return "RoundingModeRTE"; -+ case SpvExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; -+ case SpvExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; -+ case SpvExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; -+ case SpvExecutionModeCoalescingAMDX: return "CoalescingAMDX"; -+ case SpvExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; -+ case SpvExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; -+ case SpvExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case SpvExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; -+ case SpvExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; -+ case SpvExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; -+ case SpvExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; -+ case SpvExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; -+ case SpvExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; -+ case SpvExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; -+ case SpvExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; -+ case SpvExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; -+ case SpvExecutionModeOutputLinesEXT: return "OutputLinesEXT"; -+ case SpvExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; -+ case SpvExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; -+ case SpvExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; -+ case SpvExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; -+ case SpvExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; -+ case SpvExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; -+ case SpvExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; -+ case SpvExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; -+ case SpvExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; -+ case SpvExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; -+ case SpvExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; -+ case SpvExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; -+ case SpvExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; -+ case SpvExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; -+ case SpvExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; -+ case SpvExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; -+ case SpvExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; -+ case SpvExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; -+ case SpvExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; -+ case SpvExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; -+ case SpvExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; -+ case SpvExecutionModeFPFastMathDefault: return "FPFastMathDefault"; -+ case SpvExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; -+ case SpvExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; -+ case SpvExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; -+ case SpvExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; -+ case SpvExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; -+ case SpvExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvStorageClassToString(SpvStorageClass value) { -+ switch (value) { -+ case SpvStorageClassUniformConstant: return "UniformConstant"; -+ case SpvStorageClassInput: return "Input"; -+ case SpvStorageClassUniform: return "Uniform"; -+ case SpvStorageClassOutput: return "Output"; -+ case SpvStorageClassWorkgroup: return "Workgroup"; -+ case SpvStorageClassCrossWorkgroup: return "CrossWorkgroup"; -+ case SpvStorageClassPrivate: return "Private"; -+ case SpvStorageClassFunction: return "Function"; -+ case SpvStorageClassGeneric: return "Generic"; -+ case SpvStorageClassPushConstant: return "PushConstant"; -+ case SpvStorageClassAtomicCounter: return "AtomicCounter"; -+ case SpvStorageClassImage: return "Image"; -+ case SpvStorageClassStorageBuffer: return "StorageBuffer"; -+ case SpvStorageClassTileImageEXT: return "TileImageEXT"; -+ case SpvStorageClassNodePayloadAMDX: return "NodePayloadAMDX"; -+ case SpvStorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; -+ case SpvStorageClassCallableDataKHR: return "CallableDataKHR"; -+ case SpvStorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; -+ case SpvStorageClassRayPayloadKHR: return "RayPayloadKHR"; -+ case SpvStorageClassHitAttributeKHR: return "HitAttributeKHR"; -+ case SpvStorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; -+ case SpvStorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; -+ case SpvStorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; -+ case SpvStorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; -+ case SpvStorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; -+ case SpvStorageClassCodeSectionINTEL: return "CodeSectionINTEL"; -+ case SpvStorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; -+ case SpvStorageClassHostOnlyINTEL: return "HostOnlyINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvDimToString(SpvDim value) { -+ switch (value) { -+ case SpvDim1D: return "1D"; -+ case SpvDim2D: return "2D"; -+ case SpvDim3D: return "3D"; -+ case SpvDimCube: return "Cube"; -+ case SpvDimRect: return "Rect"; -+ case SpvDimBuffer: return "Buffer"; -+ case SpvDimSubpassData: return "SubpassData"; -+ case SpvDimTileImageDataEXT: return "TileImageDataEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvSamplerAddressingModeToString(SpvSamplerAddressingMode value) { -+ switch (value) { -+ case SpvSamplerAddressingModeNone: return "None"; -+ case SpvSamplerAddressingModeClampToEdge: return "ClampToEdge"; -+ case SpvSamplerAddressingModeClamp: return "Clamp"; -+ case SpvSamplerAddressingModeRepeat: return "Repeat"; -+ case SpvSamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvSamplerFilterModeToString(SpvSamplerFilterMode value) { -+ switch (value) { -+ case SpvSamplerFilterModeNearest: return "Nearest"; -+ case SpvSamplerFilterModeLinear: return "Linear"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvImageFormatToString(SpvImageFormat value) { -+ switch (value) { -+ case SpvImageFormatUnknown: return "Unknown"; -+ case SpvImageFormatRgba32f: return "Rgba32f"; -+ case SpvImageFormatRgba16f: return "Rgba16f"; -+ case SpvImageFormatR32f: return "R32f"; -+ case SpvImageFormatRgba8: return "Rgba8"; -+ case SpvImageFormatRgba8Snorm: return "Rgba8Snorm"; -+ case SpvImageFormatRg32f: return "Rg32f"; -+ case SpvImageFormatRg16f: return "Rg16f"; -+ case SpvImageFormatR11fG11fB10f: return "R11fG11fB10f"; -+ case SpvImageFormatR16f: return "R16f"; -+ case SpvImageFormatRgba16: return "Rgba16"; -+ case SpvImageFormatRgb10A2: return "Rgb10A2"; -+ case SpvImageFormatRg16: return "Rg16"; -+ case SpvImageFormatRg8: return "Rg8"; -+ case SpvImageFormatR16: return "R16"; -+ case SpvImageFormatR8: return "R8"; -+ case SpvImageFormatRgba16Snorm: return "Rgba16Snorm"; -+ case SpvImageFormatRg16Snorm: return "Rg16Snorm"; -+ case SpvImageFormatRg8Snorm: return "Rg8Snorm"; -+ case SpvImageFormatR16Snorm: return "R16Snorm"; -+ case SpvImageFormatR8Snorm: return "R8Snorm"; -+ case SpvImageFormatRgba32i: return "Rgba32i"; -+ case SpvImageFormatRgba16i: return "Rgba16i"; -+ case SpvImageFormatRgba8i: return "Rgba8i"; -+ case SpvImageFormatR32i: return "R32i"; -+ case SpvImageFormatRg32i: return "Rg32i"; -+ case SpvImageFormatRg16i: return "Rg16i"; -+ case SpvImageFormatRg8i: return "Rg8i"; -+ case SpvImageFormatR16i: return "R16i"; -+ case SpvImageFormatR8i: return "R8i"; -+ case SpvImageFormatRgba32ui: return "Rgba32ui"; -+ case SpvImageFormatRgba16ui: return "Rgba16ui"; -+ case SpvImageFormatRgba8ui: return "Rgba8ui"; -+ case SpvImageFormatR32ui: return "R32ui"; -+ case SpvImageFormatRgb10a2ui: return "Rgb10a2ui"; -+ case SpvImageFormatRg32ui: return "Rg32ui"; -+ case SpvImageFormatRg16ui: return "Rg16ui"; -+ case SpvImageFormatRg8ui: return "Rg8ui"; -+ case SpvImageFormatR16ui: return "R16ui"; -+ case SpvImageFormatR8ui: return "R8ui"; -+ case SpvImageFormatR64ui: return "R64ui"; -+ case SpvImageFormatR64i: return "R64i"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvImageChannelOrderToString(SpvImageChannelOrder value) { -+ switch (value) { -+ case SpvImageChannelOrderR: return "R"; -+ case SpvImageChannelOrderA: return "A"; -+ case SpvImageChannelOrderRG: return "RG"; -+ case SpvImageChannelOrderRA: return "RA"; -+ case SpvImageChannelOrderRGB: return "RGB"; -+ case SpvImageChannelOrderRGBA: return "RGBA"; -+ case SpvImageChannelOrderBGRA: return "BGRA"; -+ case SpvImageChannelOrderARGB: return "ARGB"; -+ case SpvImageChannelOrderIntensity: return "Intensity"; -+ case SpvImageChannelOrderLuminance: return "Luminance"; -+ case SpvImageChannelOrderRx: return "Rx"; -+ case SpvImageChannelOrderRGx: return "RGx"; -+ case SpvImageChannelOrderRGBx: return "RGBx"; -+ case SpvImageChannelOrderDepth: return "Depth"; -+ case SpvImageChannelOrderDepthStencil: return "DepthStencil"; -+ case SpvImageChannelOrdersRGB: return "sRGB"; -+ case SpvImageChannelOrdersRGBx: return "sRGBx"; -+ case SpvImageChannelOrdersRGBA: return "sRGBA"; -+ case SpvImageChannelOrdersBGRA: return "sBGRA"; -+ case SpvImageChannelOrderABGR: return "ABGR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvImageChannelDataTypeToString(SpvImageChannelDataType value) { -+ switch (value) { -+ case SpvImageChannelDataTypeSnormInt8: return "SnormInt8"; -+ case SpvImageChannelDataTypeSnormInt16: return "SnormInt16"; -+ case SpvImageChannelDataTypeUnormInt8: return "UnormInt8"; -+ case SpvImageChannelDataTypeUnormInt16: return "UnormInt16"; -+ case SpvImageChannelDataTypeUnormShort565: return "UnormShort565"; -+ case SpvImageChannelDataTypeUnormShort555: return "UnormShort555"; -+ case SpvImageChannelDataTypeUnormInt101010: return "UnormInt101010"; -+ case SpvImageChannelDataTypeSignedInt8: return "SignedInt8"; -+ case SpvImageChannelDataTypeSignedInt16: return "SignedInt16"; -+ case SpvImageChannelDataTypeSignedInt32: return "SignedInt32"; -+ case SpvImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; -+ case SpvImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; -+ case SpvImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; -+ case SpvImageChannelDataTypeHalfFloat: return "HalfFloat"; -+ case SpvImageChannelDataTypeFloat: return "Float"; -+ case SpvImageChannelDataTypeUnormInt24: return "UnormInt24"; -+ case SpvImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; -+ case SpvImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; -+ case SpvImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvFPRoundingModeToString(SpvFPRoundingMode value) { -+ switch (value) { -+ case SpvFPRoundingModeRTE: return "RTE"; -+ case SpvFPRoundingModeRTZ: return "RTZ"; -+ case SpvFPRoundingModeRTP: return "RTP"; -+ case SpvFPRoundingModeRTN: return "RTN"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvLinkageTypeToString(SpvLinkageType value) { -+ switch (value) { -+ case SpvLinkageTypeExport: return "Export"; -+ case SpvLinkageTypeImport: return "Import"; -+ case SpvLinkageTypeLinkOnceODR: return "LinkOnceODR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvAccessQualifierToString(SpvAccessQualifier value) { -+ switch (value) { -+ case SpvAccessQualifierReadOnly: return "ReadOnly"; -+ case SpvAccessQualifierWriteOnly: return "WriteOnly"; -+ case SpvAccessQualifierReadWrite: return "ReadWrite"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvFunctionParameterAttributeToString(SpvFunctionParameterAttribute value) { -+ switch (value) { -+ case SpvFunctionParameterAttributeZext: return "Zext"; -+ case SpvFunctionParameterAttributeSext: return "Sext"; -+ case SpvFunctionParameterAttributeByVal: return "ByVal"; -+ case SpvFunctionParameterAttributeSret: return "Sret"; -+ case SpvFunctionParameterAttributeNoAlias: return "NoAlias"; -+ case SpvFunctionParameterAttributeNoCapture: return "NoCapture"; -+ case SpvFunctionParameterAttributeNoWrite: return "NoWrite"; -+ case SpvFunctionParameterAttributeNoReadWrite: return "NoReadWrite"; -+ case SpvFunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvDecorationToString(SpvDecoration value) { -+ switch (value) { -+ case SpvDecorationRelaxedPrecision: return "RelaxedPrecision"; -+ case SpvDecorationSpecId: return "SpecId"; -+ case SpvDecorationBlock: return "Block"; -+ case SpvDecorationBufferBlock: return "BufferBlock"; -+ case SpvDecorationRowMajor: return "RowMajor"; -+ case SpvDecorationColMajor: return "ColMajor"; -+ case SpvDecorationArrayStride: return "ArrayStride"; -+ case SpvDecorationMatrixStride: return "MatrixStride"; -+ case SpvDecorationGLSLShared: return "GLSLShared"; -+ case SpvDecorationGLSLPacked: return "GLSLPacked"; -+ case SpvDecorationCPacked: return "CPacked"; -+ case SpvDecorationBuiltIn: return "BuiltIn"; -+ case SpvDecorationNoPerspective: return "NoPerspective"; -+ case SpvDecorationFlat: return "Flat"; -+ case SpvDecorationPatch: return "Patch"; -+ case SpvDecorationCentroid: return "Centroid"; -+ case SpvDecorationSample: return "Sample"; -+ case SpvDecorationInvariant: return "Invariant"; -+ case SpvDecorationRestrict: return "Restrict"; -+ case SpvDecorationAliased: return "Aliased"; -+ case SpvDecorationVolatile: return "Volatile"; -+ case SpvDecorationConstant: return "Constant"; -+ case SpvDecorationCoherent: return "Coherent"; -+ case SpvDecorationNonWritable: return "NonWritable"; -+ case SpvDecorationNonReadable: return "NonReadable"; -+ case SpvDecorationUniform: return "Uniform"; -+ case SpvDecorationUniformId: return "UniformId"; -+ case SpvDecorationSaturatedConversion: return "SaturatedConversion"; -+ case SpvDecorationStream: return "Stream"; -+ case SpvDecorationLocation: return "Location"; -+ case SpvDecorationComponent: return "Component"; -+ case SpvDecorationIndex: return "Index"; -+ case SpvDecorationBinding: return "Binding"; -+ case SpvDecorationDescriptorSet: return "DescriptorSet"; -+ case SpvDecorationOffset: return "Offset"; -+ case SpvDecorationXfbBuffer: return "XfbBuffer"; -+ case SpvDecorationXfbStride: return "XfbStride"; -+ case SpvDecorationFuncParamAttr: return "FuncParamAttr"; -+ case SpvDecorationFPRoundingMode: return "FPRoundingMode"; -+ case SpvDecorationFPFastMathMode: return "FPFastMathMode"; -+ case SpvDecorationLinkageAttributes: return "LinkageAttributes"; -+ case SpvDecorationNoContraction: return "NoContraction"; -+ case SpvDecorationInputAttachmentIndex: return "InputAttachmentIndex"; -+ case SpvDecorationAlignment: return "Alignment"; -+ case SpvDecorationMaxByteOffset: return "MaxByteOffset"; -+ case SpvDecorationAlignmentId: return "AlignmentId"; -+ case SpvDecorationMaxByteOffsetId: return "MaxByteOffsetId"; -+ case SpvDecorationNoSignedWrap: return "NoSignedWrap"; -+ case SpvDecorationNoUnsignedWrap: return "NoUnsignedWrap"; -+ case SpvDecorationWeightTextureQCOM: return "WeightTextureQCOM"; -+ case SpvDecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; -+ case SpvDecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; -+ case SpvDecorationExplicitInterpAMD: return "ExplicitInterpAMD"; -+ case SpvDecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; -+ case SpvDecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; -+ case SpvDecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; -+ case SpvDecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; -+ case SpvDecorationOverrideCoverageNV: return "OverrideCoverageNV"; -+ case SpvDecorationPassthroughNV: return "PassthroughNV"; -+ case SpvDecorationViewportRelativeNV: return "ViewportRelativeNV"; -+ case SpvDecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; -+ case SpvDecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; -+ case SpvDecorationPerViewNV: return "PerViewNV"; -+ case SpvDecorationPerTaskNV: return "PerTaskNV"; -+ case SpvDecorationPerVertexKHR: return "PerVertexKHR"; -+ case SpvDecorationNonUniform: return "NonUniform"; -+ case SpvDecorationRestrictPointer: return "RestrictPointer"; -+ case SpvDecorationAliasedPointer: return "AliasedPointer"; -+ case SpvDecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; -+ case SpvDecorationBindlessSamplerNV: return "BindlessSamplerNV"; -+ case SpvDecorationBindlessImageNV: return "BindlessImageNV"; -+ case SpvDecorationBoundSamplerNV: return "BoundSamplerNV"; -+ case SpvDecorationBoundImageNV: return "BoundImageNV"; -+ case SpvDecorationSIMTCallINTEL: return "SIMTCallINTEL"; -+ case SpvDecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; -+ case SpvDecorationClobberINTEL: return "ClobberINTEL"; -+ case SpvDecorationSideEffectsINTEL: return "SideEffectsINTEL"; -+ case SpvDecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; -+ case SpvDecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; -+ case SpvDecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; -+ case SpvDecorationStackCallINTEL: return "StackCallINTEL"; -+ case SpvDecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; -+ case SpvDecorationCounterBuffer: return "CounterBuffer"; -+ case SpvDecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; -+ case SpvDecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; -+ case SpvDecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; -+ case SpvDecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; -+ case SpvDecorationRegisterINTEL: return "RegisterINTEL"; -+ case SpvDecorationMemoryINTEL: return "MemoryINTEL"; -+ case SpvDecorationNumbanksINTEL: return "NumbanksINTEL"; -+ case SpvDecorationBankwidthINTEL: return "BankwidthINTEL"; -+ case SpvDecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; -+ case SpvDecorationSinglepumpINTEL: return "SinglepumpINTEL"; -+ case SpvDecorationDoublepumpINTEL: return "DoublepumpINTEL"; -+ case SpvDecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; -+ case SpvDecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; -+ case SpvDecorationMergeINTEL: return "MergeINTEL"; -+ case SpvDecorationBankBitsINTEL: return "BankBitsINTEL"; -+ case SpvDecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; -+ case SpvDecorationStridesizeINTEL: return "StridesizeINTEL"; -+ case SpvDecorationWordsizeINTEL: return "WordsizeINTEL"; -+ case SpvDecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; -+ case SpvDecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; -+ case SpvDecorationCacheSizeINTEL: return "CacheSizeINTEL"; -+ case SpvDecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; -+ case SpvDecorationPrefetchINTEL: return "PrefetchINTEL"; -+ case SpvDecorationStallEnableINTEL: return "StallEnableINTEL"; -+ case SpvDecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; -+ case SpvDecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; -+ case SpvDecorationAliasScopeINTEL: return "AliasScopeINTEL"; -+ case SpvDecorationNoAliasINTEL: return "NoAliasINTEL"; -+ case SpvDecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; -+ case SpvDecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; -+ case SpvDecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; -+ case SpvDecorationBufferLocationINTEL: return "BufferLocationINTEL"; -+ case SpvDecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; -+ case SpvDecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; -+ case SpvDecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; -+ case SpvDecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; -+ case SpvDecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; -+ case SpvDecorationStallFreeINTEL: return "StallFreeINTEL"; -+ case SpvDecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; -+ case SpvDecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; -+ case SpvDecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; -+ case SpvDecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; -+ case SpvDecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; -+ case SpvDecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; -+ case SpvDecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; -+ case SpvDecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; -+ case SpvDecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; -+ case SpvDecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; -+ case SpvDecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; -+ case SpvDecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; -+ case SpvDecorationHostAccessINTEL: return "HostAccessINTEL"; -+ case SpvDecorationInitModeINTEL: return "InitModeINTEL"; -+ case SpvDecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; -+ case SpvDecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; -+ case SpvDecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvBuiltInToString(SpvBuiltIn value) { -+ switch (value) { -+ case SpvBuiltInPosition: return "Position"; -+ case SpvBuiltInPointSize: return "PointSize"; -+ case SpvBuiltInClipDistance: return "ClipDistance"; -+ case SpvBuiltInCullDistance: return "CullDistance"; -+ case SpvBuiltInVertexId: return "VertexId"; -+ case SpvBuiltInInstanceId: return "InstanceId"; -+ case SpvBuiltInPrimitiveId: return "PrimitiveId"; -+ case SpvBuiltInInvocationId: return "InvocationId"; -+ case SpvBuiltInLayer: return "Layer"; -+ case SpvBuiltInViewportIndex: return "ViewportIndex"; -+ case SpvBuiltInTessLevelOuter: return "TessLevelOuter"; -+ case SpvBuiltInTessLevelInner: return "TessLevelInner"; -+ case SpvBuiltInTessCoord: return "TessCoord"; -+ case SpvBuiltInPatchVertices: return "PatchVertices"; -+ case SpvBuiltInFragCoord: return "FragCoord"; -+ case SpvBuiltInPointCoord: return "PointCoord"; -+ case SpvBuiltInFrontFacing: return "FrontFacing"; -+ case SpvBuiltInSampleId: return "SampleId"; -+ case SpvBuiltInSamplePosition: return "SamplePosition"; -+ case SpvBuiltInSampleMask: return "SampleMask"; -+ case SpvBuiltInFragDepth: return "FragDepth"; -+ case SpvBuiltInHelperInvocation: return "HelperInvocation"; -+ case SpvBuiltInNumWorkgroups: return "NumWorkgroups"; -+ case SpvBuiltInWorkgroupSize: return "WorkgroupSize"; -+ case SpvBuiltInWorkgroupId: return "WorkgroupId"; -+ case SpvBuiltInLocalInvocationId: return "LocalInvocationId"; -+ case SpvBuiltInGlobalInvocationId: return "GlobalInvocationId"; -+ case SpvBuiltInLocalInvocationIndex: return "LocalInvocationIndex"; -+ case SpvBuiltInWorkDim: return "WorkDim"; -+ case SpvBuiltInGlobalSize: return "GlobalSize"; -+ case SpvBuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; -+ case SpvBuiltInGlobalOffset: return "GlobalOffset"; -+ case SpvBuiltInGlobalLinearId: return "GlobalLinearId"; -+ case SpvBuiltInSubgroupSize: return "SubgroupSize"; -+ case SpvBuiltInSubgroupMaxSize: return "SubgroupMaxSize"; -+ case SpvBuiltInNumSubgroups: return "NumSubgroups"; -+ case SpvBuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; -+ case SpvBuiltInSubgroupId: return "SubgroupId"; -+ case SpvBuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; -+ case SpvBuiltInVertexIndex: return "VertexIndex"; -+ case SpvBuiltInInstanceIndex: return "InstanceIndex"; -+ case SpvBuiltInCoreIDARM: return "CoreIDARM"; -+ case SpvBuiltInCoreCountARM: return "CoreCountARM"; -+ case SpvBuiltInCoreMaxIDARM: return "CoreMaxIDARM"; -+ case SpvBuiltInWarpIDARM: return "WarpIDARM"; -+ case SpvBuiltInWarpMaxIDARM: return "WarpMaxIDARM"; -+ case SpvBuiltInSubgroupEqMask: return "SubgroupEqMask"; -+ case SpvBuiltInSubgroupGeMask: return "SubgroupGeMask"; -+ case SpvBuiltInSubgroupGtMask: return "SubgroupGtMask"; -+ case SpvBuiltInSubgroupLeMask: return "SubgroupLeMask"; -+ case SpvBuiltInSubgroupLtMask: return "SubgroupLtMask"; -+ case SpvBuiltInBaseVertex: return "BaseVertex"; -+ case SpvBuiltInBaseInstance: return "BaseInstance"; -+ case SpvBuiltInDrawIndex: return "DrawIndex"; -+ case SpvBuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; -+ case SpvBuiltInDeviceIndex: return "DeviceIndex"; -+ case SpvBuiltInViewIndex: return "ViewIndex"; -+ case SpvBuiltInShadingRateKHR: return "ShadingRateKHR"; -+ case SpvBuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; -+ case SpvBuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; -+ case SpvBuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; -+ case SpvBuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; -+ case SpvBuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; -+ case SpvBuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; -+ case SpvBuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; -+ case SpvBuiltInFragStencilRefEXT: return "FragStencilRefEXT"; -+ case SpvBuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; -+ case SpvBuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case SpvBuiltInViewportMaskNV: return "ViewportMaskNV"; -+ case SpvBuiltInSecondaryPositionNV: return "SecondaryPositionNV"; -+ case SpvBuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; -+ case SpvBuiltInPositionPerViewNV: return "PositionPerViewNV"; -+ case SpvBuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; -+ case SpvBuiltInFullyCoveredEXT: return "FullyCoveredEXT"; -+ case SpvBuiltInTaskCountNV: return "TaskCountNV"; -+ case SpvBuiltInPrimitiveCountNV: return "PrimitiveCountNV"; -+ case SpvBuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; -+ case SpvBuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; -+ case SpvBuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; -+ case SpvBuiltInLayerPerViewNV: return "LayerPerViewNV"; -+ case SpvBuiltInMeshViewCountNV: return "MeshViewCountNV"; -+ case SpvBuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; -+ case SpvBuiltInBaryCoordKHR: return "BaryCoordKHR"; -+ case SpvBuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; -+ case SpvBuiltInFragSizeEXT: return "FragSizeEXT"; -+ case SpvBuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; -+ case SpvBuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; -+ case SpvBuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; -+ case SpvBuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; -+ case SpvBuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; -+ case SpvBuiltInLaunchIdKHR: return "LaunchIdKHR"; -+ case SpvBuiltInLaunchSizeKHR: return "LaunchSizeKHR"; -+ case SpvBuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; -+ case SpvBuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; -+ case SpvBuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; -+ case SpvBuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; -+ case SpvBuiltInRayTminKHR: return "RayTminKHR"; -+ case SpvBuiltInRayTmaxKHR: return "RayTmaxKHR"; -+ case SpvBuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; -+ case SpvBuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; -+ case SpvBuiltInWorldToObjectKHR: return "WorldToObjectKHR"; -+ case SpvBuiltInHitTNV: return "HitTNV"; -+ case SpvBuiltInHitKindKHR: return "HitKindKHR"; -+ case SpvBuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; -+ case SpvBuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; -+ case SpvBuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; -+ case SpvBuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; -+ case SpvBuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; -+ case SpvBuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; -+ case SpvBuiltInWarpsPerSMNV: return "WarpsPerSMNV"; -+ case SpvBuiltInSMCountNV: return "SMCountNV"; -+ case SpvBuiltInWarpIDNV: return "WarpIDNV"; -+ case SpvBuiltInSMIDNV: return "SMIDNV"; -+ case SpvBuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; -+ case SpvBuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; -+ case SpvBuiltInCullMaskKHR: return "CullMaskKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvScopeToString(SpvScope value) { -+ switch (value) { -+ case SpvScopeCrossDevice: return "CrossDevice"; -+ case SpvScopeDevice: return "Device"; -+ case SpvScopeWorkgroup: return "Workgroup"; -+ case SpvScopeSubgroup: return "Subgroup"; -+ case SpvScopeInvocation: return "Invocation"; -+ case SpvScopeQueueFamily: return "QueueFamily"; -+ case SpvScopeShaderCallKHR: return "ShaderCallKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvGroupOperationToString(SpvGroupOperation value) { -+ switch (value) { -+ case SpvGroupOperationReduce: return "Reduce"; -+ case SpvGroupOperationInclusiveScan: return "InclusiveScan"; -+ case SpvGroupOperationExclusiveScan: return "ExclusiveScan"; -+ case SpvGroupOperationClusteredReduce: return "ClusteredReduce"; -+ case SpvGroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; -+ case SpvGroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; -+ case SpvGroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvKernelEnqueueFlagsToString(SpvKernelEnqueueFlags value) { -+ switch (value) { -+ case SpvKernelEnqueueFlagsNoWait: return "NoWait"; -+ case SpvKernelEnqueueFlagsWaitKernel: return "WaitKernel"; -+ case SpvKernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvCapabilityToString(SpvCapability value) { -+ switch (value) { -+ case SpvCapabilityMatrix: return "Matrix"; -+ case SpvCapabilityShader: return "Shader"; -+ case SpvCapabilityGeometry: return "Geometry"; -+ case SpvCapabilityTessellation: return "Tessellation"; -+ case SpvCapabilityAddresses: return "Addresses"; -+ case SpvCapabilityLinkage: return "Linkage"; -+ case SpvCapabilityKernel: return "Kernel"; -+ case SpvCapabilityVector16: return "Vector16"; -+ case SpvCapabilityFloat16Buffer: return "Float16Buffer"; -+ case SpvCapabilityFloat16: return "Float16"; -+ case SpvCapabilityFloat64: return "Float64"; -+ case SpvCapabilityInt64: return "Int64"; -+ case SpvCapabilityInt64Atomics: return "Int64Atomics"; -+ case SpvCapabilityImageBasic: return "ImageBasic"; -+ case SpvCapabilityImageReadWrite: return "ImageReadWrite"; -+ case SpvCapabilityImageMipmap: return "ImageMipmap"; -+ case SpvCapabilityPipes: return "Pipes"; -+ case SpvCapabilityGroups: return "Groups"; -+ case SpvCapabilityDeviceEnqueue: return "DeviceEnqueue"; -+ case SpvCapabilityLiteralSampler: return "LiteralSampler"; -+ case SpvCapabilityAtomicStorage: return "AtomicStorage"; -+ case SpvCapabilityInt16: return "Int16"; -+ case SpvCapabilityTessellationPointSize: return "TessellationPointSize"; -+ case SpvCapabilityGeometryPointSize: return "GeometryPointSize"; -+ case SpvCapabilityImageGatherExtended: return "ImageGatherExtended"; -+ case SpvCapabilityStorageImageMultisample: return "StorageImageMultisample"; -+ case SpvCapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; -+ case SpvCapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; -+ case SpvCapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; -+ case SpvCapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; -+ case SpvCapabilityClipDistance: return "ClipDistance"; -+ case SpvCapabilityCullDistance: return "CullDistance"; -+ case SpvCapabilityImageCubeArray: return "ImageCubeArray"; -+ case SpvCapabilitySampleRateShading: return "SampleRateShading"; -+ case SpvCapabilityImageRect: return "ImageRect"; -+ case SpvCapabilitySampledRect: return "SampledRect"; -+ case SpvCapabilityGenericPointer: return "GenericPointer"; -+ case SpvCapabilityInt8: return "Int8"; -+ case SpvCapabilityInputAttachment: return "InputAttachment"; -+ case SpvCapabilitySparseResidency: return "SparseResidency"; -+ case SpvCapabilityMinLod: return "MinLod"; -+ case SpvCapabilitySampled1D: return "Sampled1D"; -+ case SpvCapabilityImage1D: return "Image1D"; -+ case SpvCapabilitySampledCubeArray: return "SampledCubeArray"; -+ case SpvCapabilitySampledBuffer: return "SampledBuffer"; -+ case SpvCapabilityImageBuffer: return "ImageBuffer"; -+ case SpvCapabilityImageMSArray: return "ImageMSArray"; -+ case SpvCapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; -+ case SpvCapabilityImageQuery: return "ImageQuery"; -+ case SpvCapabilityDerivativeControl: return "DerivativeControl"; -+ case SpvCapabilityInterpolationFunction: return "InterpolationFunction"; -+ case SpvCapabilityTransformFeedback: return "TransformFeedback"; -+ case SpvCapabilityGeometryStreams: return "GeometryStreams"; -+ case SpvCapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; -+ case SpvCapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; -+ case SpvCapabilityMultiViewport: return "MultiViewport"; -+ case SpvCapabilitySubgroupDispatch: return "SubgroupDispatch"; -+ case SpvCapabilityNamedBarrier: return "NamedBarrier"; -+ case SpvCapabilityPipeStorage: return "PipeStorage"; -+ case SpvCapabilityGroupNonUniform: return "GroupNonUniform"; -+ case SpvCapabilityGroupNonUniformVote: return "GroupNonUniformVote"; -+ case SpvCapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; -+ case SpvCapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; -+ case SpvCapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; -+ case SpvCapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; -+ case SpvCapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; -+ case SpvCapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; -+ case SpvCapabilityShaderLayer: return "ShaderLayer"; -+ case SpvCapabilityShaderViewportIndex: return "ShaderViewportIndex"; -+ case SpvCapabilityUniformDecoration: return "UniformDecoration"; -+ case SpvCapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; -+ case SpvCapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; -+ case SpvCapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; -+ case SpvCapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; -+ case SpvCapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; -+ case SpvCapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; -+ case SpvCapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; -+ case SpvCapabilityDrawParameters: return "DrawParameters"; -+ case SpvCapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; -+ case SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; -+ case SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; -+ case SpvCapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; -+ case SpvCapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; -+ case SpvCapabilityStorageUniform16: return "StorageUniform16"; -+ case SpvCapabilityStoragePushConstant16: return "StoragePushConstant16"; -+ case SpvCapabilityStorageInputOutput16: return "StorageInputOutput16"; -+ case SpvCapabilityDeviceGroup: return "DeviceGroup"; -+ case SpvCapabilityMultiView: return "MultiView"; -+ case SpvCapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; -+ case SpvCapabilityVariablePointers: return "VariablePointers"; -+ case SpvCapabilityAtomicStorageOps: return "AtomicStorageOps"; -+ case SpvCapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; -+ case SpvCapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; -+ case SpvCapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; -+ case SpvCapabilityStoragePushConstant8: return "StoragePushConstant8"; -+ case SpvCapabilityDenormPreserve: return "DenormPreserve"; -+ case SpvCapabilityDenormFlushToZero: return "DenormFlushToZero"; -+ case SpvCapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case SpvCapabilityRoundingModeRTE: return "RoundingModeRTE"; -+ case SpvCapabilityRoundingModeRTZ: return "RoundingModeRTZ"; -+ case SpvCapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; -+ case SpvCapabilityRayQueryKHR: return "RayQueryKHR"; -+ case SpvCapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; -+ case SpvCapabilityRayTracingKHR: return "RayTracingKHR"; -+ case SpvCapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; -+ case SpvCapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; -+ case SpvCapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; -+ case SpvCapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; -+ case SpvCapabilityFloat16ImageAMD: return "Float16ImageAMD"; -+ case SpvCapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; -+ case SpvCapabilityFragmentMaskAMD: return "FragmentMaskAMD"; -+ case SpvCapabilityStencilExportEXT: return "StencilExportEXT"; -+ case SpvCapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; -+ case SpvCapabilityInt64ImageEXT: return "Int64ImageEXT"; -+ case SpvCapabilityShaderClockKHR: return "ShaderClockKHR"; -+ case SpvCapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; -+ case SpvCapabilityQuadControlKHR: return "QuadControlKHR"; -+ case SpvCapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; -+ case SpvCapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; -+ case SpvCapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; -+ case SpvCapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; -+ case SpvCapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; -+ case SpvCapabilityPerViewAttributesNV: return "PerViewAttributesNV"; -+ case SpvCapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; -+ case SpvCapabilityMeshShadingNV: return "MeshShadingNV"; -+ case SpvCapabilityImageFootprintNV: return "ImageFootprintNV"; -+ case SpvCapabilityMeshShadingEXT: return "MeshShadingEXT"; -+ case SpvCapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; -+ case SpvCapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; -+ case SpvCapabilityFragmentDensityEXT: return "FragmentDensityEXT"; -+ case SpvCapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; -+ case SpvCapabilityShaderNonUniform: return "ShaderNonUniform"; -+ case SpvCapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; -+ case SpvCapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; -+ case SpvCapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; -+ case SpvCapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; -+ case SpvCapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; -+ case SpvCapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; -+ case SpvCapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; -+ case SpvCapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; -+ case SpvCapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; -+ case SpvCapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; -+ case SpvCapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; -+ case SpvCapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; -+ case SpvCapabilityRayTracingNV: return "RayTracingNV"; -+ case SpvCapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; -+ case SpvCapabilityVulkanMemoryModel: return "VulkanMemoryModel"; -+ case SpvCapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; -+ case SpvCapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; -+ case SpvCapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; -+ case SpvCapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; -+ case SpvCapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; -+ case SpvCapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; -+ case SpvCapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; -+ case SpvCapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; -+ case SpvCapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; -+ case SpvCapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; -+ case SpvCapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; -+ case SpvCapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; -+ case SpvCapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; -+ case SpvCapabilityBindlessTextureNV: return "BindlessTextureNV"; -+ case SpvCapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; -+ case SpvCapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; -+ case SpvCapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; -+ case SpvCapabilityRawAccessChainsNV: return "RawAccessChainsNV"; -+ case SpvCapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; -+ case SpvCapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; -+ case SpvCapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; -+ case SpvCapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; -+ case SpvCapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; -+ case SpvCapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; -+ case SpvCapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; -+ case SpvCapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; -+ case SpvCapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; -+ case SpvCapabilityAsmINTEL: return "AsmINTEL"; -+ case SpvCapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; -+ case SpvCapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; -+ case SpvCapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; -+ case SpvCapabilityVectorComputeINTEL: return "VectorComputeINTEL"; -+ case SpvCapabilityVectorAnyINTEL: return "VectorAnyINTEL"; -+ case SpvCapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; -+ case SpvCapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; -+ case SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; -+ case SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; -+ case SpvCapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; -+ case SpvCapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; -+ case SpvCapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; -+ case SpvCapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; -+ case SpvCapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; -+ case SpvCapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; -+ case SpvCapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; -+ case SpvCapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; -+ case SpvCapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; -+ case SpvCapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; -+ case SpvCapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; -+ case SpvCapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; -+ case SpvCapabilityLoopFuseINTEL: return "LoopFuseINTEL"; -+ case SpvCapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; -+ case SpvCapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; -+ case SpvCapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; -+ case SpvCapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; -+ case SpvCapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; -+ case SpvCapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; -+ case SpvCapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; -+ case SpvCapabilityIOPipesINTEL: return "IOPipesINTEL"; -+ case SpvCapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; -+ case SpvCapabilityFPGARegINTEL: return "FPGARegINTEL"; -+ case SpvCapabilityDotProductInputAll: return "DotProductInputAll"; -+ case SpvCapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; -+ case SpvCapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; -+ case SpvCapabilityDotProduct: return "DotProduct"; -+ case SpvCapabilityRayCullMaskKHR: return "RayCullMaskKHR"; -+ case SpvCapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; -+ case SpvCapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; -+ case SpvCapabilityBitInstructions: return "BitInstructions"; -+ case SpvCapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; -+ case SpvCapabilityFloatControls2: return "FloatControls2"; -+ case SpvCapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; -+ case SpvCapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; -+ case SpvCapabilityLongCompositesINTEL: return "LongCompositesINTEL"; -+ case SpvCapabilityOptNoneINTEL: return "OptNoneINTEL"; -+ case SpvCapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; -+ case SpvCapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; -+ case SpvCapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; -+ case SpvCapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; -+ case SpvCapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; -+ case SpvCapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; -+ case SpvCapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; -+ case SpvCapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; -+ case SpvCapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; -+ case SpvCapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; -+ case SpvCapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; -+ case SpvCapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; -+ case SpvCapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; -+ case SpvCapabilityCacheControlsINTEL: return "CacheControlsINTEL"; -+ case SpvCapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvRayQueryIntersectionToString(SpvRayQueryIntersection value) { -+ switch (value) { -+ case SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; -+ case SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvRayQueryCommittedIntersectionTypeToString(SpvRayQueryCommittedIntersectionType value) { -+ switch (value) { -+ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; -+ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; -+ case SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvRayQueryCandidateIntersectionTypeToString(SpvRayQueryCandidateIntersectionType value) { -+ switch (value) { -+ case SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; -+ case SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvFPDenormModeToString(SpvFPDenormMode value) { -+ switch (value) { -+ case SpvFPDenormModePreserve: return "Preserve"; -+ case SpvFPDenormModeFlushToZero: return "FlushToZero"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvFPOperationModeToString(SpvFPOperationMode value) { -+ switch (value) { -+ case SpvFPOperationModeIEEE: return "IEEE"; -+ case SpvFPOperationModeALT: return "ALT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvQuantizationModesToString(SpvQuantizationModes value) { -+ switch (value) { -+ case SpvQuantizationModesTRN: return "TRN"; -+ case SpvQuantizationModesTRN_ZERO: return "TRN_ZERO"; -+ case SpvQuantizationModesRND: return "RND"; -+ case SpvQuantizationModesRND_ZERO: return "RND_ZERO"; -+ case SpvQuantizationModesRND_INF: return "RND_INF"; -+ case SpvQuantizationModesRND_MIN_INF: return "RND_MIN_INF"; -+ case SpvQuantizationModesRND_CONV: return "RND_CONV"; -+ case SpvQuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvOverflowModesToString(SpvOverflowModes value) { -+ switch (value) { -+ case SpvOverflowModesWRAP: return "WRAP"; -+ case SpvOverflowModesSAT: return "SAT"; -+ case SpvOverflowModesSAT_ZERO: return "SAT_ZERO"; -+ case SpvOverflowModesSAT_SYM: return "SAT_SYM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvPackedVectorFormatToString(SpvPackedVectorFormat value) { -+ switch (value) { -+ case SpvPackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvCooperativeMatrixLayoutToString(SpvCooperativeMatrixLayout value) { -+ switch (value) { -+ case SpvCooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; -+ case SpvCooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; -+ case SpvCooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; -+ case SpvCooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvCooperativeMatrixUseToString(SpvCooperativeMatrixUse value) { -+ switch (value) { -+ case SpvCooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; -+ case SpvCooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; -+ case SpvCooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvInitializationModeQualifierToString(SpvInitializationModeQualifier value) { -+ switch (value) { -+ case SpvInitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; -+ case SpvInitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvHostAccessQualifierToString(SpvHostAccessQualifier value) { -+ switch (value) { -+ case SpvHostAccessQualifierNoneINTEL: return "NoneINTEL"; -+ case SpvHostAccessQualifierReadINTEL: return "ReadINTEL"; -+ case SpvHostAccessQualifierWriteINTEL: return "WriteINTEL"; -+ case SpvHostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvLoadCacheControlToString(SpvLoadCacheControl value) { -+ switch (value) { -+ case SpvLoadCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case SpvLoadCacheControlCachedINTEL: return "CachedINTEL"; -+ case SpvLoadCacheControlStreamingINTEL: return "StreamingINTEL"; -+ case SpvLoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; -+ case SpvLoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvStoreCacheControlToString(SpvStoreCacheControl value) { -+ switch (value) { -+ case SpvStoreCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case SpvStoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; -+ case SpvStoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; -+ case SpvStoreCacheControlStreamingINTEL: return "StreamingINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvNamedMaximumNumberOfRegistersToString(SpvNamedMaximumNumberOfRegisters value) { -+ switch (value) { -+ case SpvNamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SpvOpToString(SpvOp value) { -+ switch (value) { -+ case SpvOpNop: return "OpNop"; -+ case SpvOpUndef: return "OpUndef"; -+ case SpvOpSourceContinued: return "OpSourceContinued"; -+ case SpvOpSource: return "OpSource"; -+ case SpvOpSourceExtension: return "OpSourceExtension"; -+ case SpvOpName: return "OpName"; -+ case SpvOpMemberName: return "OpMemberName"; -+ case SpvOpString: return "OpString"; -+ case SpvOpLine: return "OpLine"; -+ case SpvOpExtension: return "OpExtension"; -+ case SpvOpExtInstImport: return "OpExtInstImport"; -+ case SpvOpExtInst: return "OpExtInst"; -+ case SpvOpMemoryModel: return "OpMemoryModel"; -+ case SpvOpEntryPoint: return "OpEntryPoint"; -+ case SpvOpExecutionMode: return "OpExecutionMode"; -+ case SpvOpCapability: return "OpCapability"; -+ case SpvOpTypeVoid: return "OpTypeVoid"; -+ case SpvOpTypeBool: return "OpTypeBool"; -+ case SpvOpTypeInt: return "OpTypeInt"; -+ case SpvOpTypeFloat: return "OpTypeFloat"; -+ case SpvOpTypeVector: return "OpTypeVector"; -+ case SpvOpTypeMatrix: return "OpTypeMatrix"; -+ case SpvOpTypeImage: return "OpTypeImage"; -+ case SpvOpTypeSampler: return "OpTypeSampler"; -+ case SpvOpTypeSampledImage: return "OpTypeSampledImage"; -+ case SpvOpTypeArray: return "OpTypeArray"; -+ case SpvOpTypeRuntimeArray: return "OpTypeRuntimeArray"; -+ case SpvOpTypeStruct: return "OpTypeStruct"; -+ case SpvOpTypeOpaque: return "OpTypeOpaque"; -+ case SpvOpTypePointer: return "OpTypePointer"; -+ case SpvOpTypeFunction: return "OpTypeFunction"; -+ case SpvOpTypeEvent: return "OpTypeEvent"; -+ case SpvOpTypeDeviceEvent: return "OpTypeDeviceEvent"; -+ case SpvOpTypeReserveId: return "OpTypeReserveId"; -+ case SpvOpTypeQueue: return "OpTypeQueue"; -+ case SpvOpTypePipe: return "OpTypePipe"; -+ case SpvOpTypeForwardPointer: return "OpTypeForwardPointer"; -+ case SpvOpConstantTrue: return "OpConstantTrue"; -+ case SpvOpConstantFalse: return "OpConstantFalse"; -+ case SpvOpConstant: return "OpConstant"; -+ case SpvOpConstantComposite: return "OpConstantComposite"; -+ case SpvOpConstantSampler: return "OpConstantSampler"; -+ case SpvOpConstantNull: return "OpConstantNull"; -+ case SpvOpSpecConstantTrue: return "OpSpecConstantTrue"; -+ case SpvOpSpecConstantFalse: return "OpSpecConstantFalse"; -+ case SpvOpSpecConstant: return "OpSpecConstant"; -+ case SpvOpSpecConstantComposite: return "OpSpecConstantComposite"; -+ case SpvOpSpecConstantOp: return "OpSpecConstantOp"; -+ case SpvOpFunction: return "OpFunction"; -+ case SpvOpFunctionParameter: return "OpFunctionParameter"; -+ case SpvOpFunctionEnd: return "OpFunctionEnd"; -+ case SpvOpFunctionCall: return "OpFunctionCall"; -+ case SpvOpVariable: return "OpVariable"; -+ case SpvOpImageTexelPointer: return "OpImageTexelPointer"; -+ case SpvOpLoad: return "OpLoad"; -+ case SpvOpStore: return "OpStore"; -+ case SpvOpCopyMemory: return "OpCopyMemory"; -+ case SpvOpCopyMemorySized: return "OpCopyMemorySized"; -+ case SpvOpAccessChain: return "OpAccessChain"; -+ case SpvOpInBoundsAccessChain: return "OpInBoundsAccessChain"; -+ case SpvOpPtrAccessChain: return "OpPtrAccessChain"; -+ case SpvOpArrayLength: return "OpArrayLength"; -+ case SpvOpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; -+ case SpvOpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; -+ case SpvOpDecorate: return "OpDecorate"; -+ case SpvOpMemberDecorate: return "OpMemberDecorate"; -+ case SpvOpDecorationGroup: return "OpDecorationGroup"; -+ case SpvOpGroupDecorate: return "OpGroupDecorate"; -+ case SpvOpGroupMemberDecorate: return "OpGroupMemberDecorate"; -+ case SpvOpVectorExtractDynamic: return "OpVectorExtractDynamic"; -+ case SpvOpVectorInsertDynamic: return "OpVectorInsertDynamic"; -+ case SpvOpVectorShuffle: return "OpVectorShuffle"; -+ case SpvOpCompositeConstruct: return "OpCompositeConstruct"; -+ case SpvOpCompositeExtract: return "OpCompositeExtract"; -+ case SpvOpCompositeInsert: return "OpCompositeInsert"; -+ case SpvOpCopyObject: return "OpCopyObject"; -+ case SpvOpTranspose: return "OpTranspose"; -+ case SpvOpSampledImage: return "OpSampledImage"; -+ case SpvOpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; -+ case SpvOpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; -+ case SpvOpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; -+ case SpvOpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; -+ case SpvOpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; -+ case SpvOpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; -+ case SpvOpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; -+ case SpvOpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; -+ case SpvOpImageFetch: return "OpImageFetch"; -+ case SpvOpImageGather: return "OpImageGather"; -+ case SpvOpImageDrefGather: return "OpImageDrefGather"; -+ case SpvOpImageRead: return "OpImageRead"; -+ case SpvOpImageWrite: return "OpImageWrite"; -+ case SpvOpImage: return "OpImage"; -+ case SpvOpImageQueryFormat: return "OpImageQueryFormat"; -+ case SpvOpImageQueryOrder: return "OpImageQueryOrder"; -+ case SpvOpImageQuerySizeLod: return "OpImageQuerySizeLod"; -+ case SpvOpImageQuerySize: return "OpImageQuerySize"; -+ case SpvOpImageQueryLod: return "OpImageQueryLod"; -+ case SpvOpImageQueryLevels: return "OpImageQueryLevels"; -+ case SpvOpImageQuerySamples: return "OpImageQuerySamples"; -+ case SpvOpConvertFToU: return "OpConvertFToU"; -+ case SpvOpConvertFToS: return "OpConvertFToS"; -+ case SpvOpConvertSToF: return "OpConvertSToF"; -+ case SpvOpConvertUToF: return "OpConvertUToF"; -+ case SpvOpUConvert: return "OpUConvert"; -+ case SpvOpSConvert: return "OpSConvert"; -+ case SpvOpFConvert: return "OpFConvert"; -+ case SpvOpQuantizeToF16: return "OpQuantizeToF16"; -+ case SpvOpConvertPtrToU: return "OpConvertPtrToU"; -+ case SpvOpSatConvertSToU: return "OpSatConvertSToU"; -+ case SpvOpSatConvertUToS: return "OpSatConvertUToS"; -+ case SpvOpConvertUToPtr: return "OpConvertUToPtr"; -+ case SpvOpPtrCastToGeneric: return "OpPtrCastToGeneric"; -+ case SpvOpGenericCastToPtr: return "OpGenericCastToPtr"; -+ case SpvOpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; -+ case SpvOpBitcast: return "OpBitcast"; -+ case SpvOpSNegate: return "OpSNegate"; -+ case SpvOpFNegate: return "OpFNegate"; -+ case SpvOpIAdd: return "OpIAdd"; -+ case SpvOpFAdd: return "OpFAdd"; -+ case SpvOpISub: return "OpISub"; -+ case SpvOpFSub: return "OpFSub"; -+ case SpvOpIMul: return "OpIMul"; -+ case SpvOpFMul: return "OpFMul"; -+ case SpvOpUDiv: return "OpUDiv"; -+ case SpvOpSDiv: return "OpSDiv"; -+ case SpvOpFDiv: return "OpFDiv"; -+ case SpvOpUMod: return "OpUMod"; -+ case SpvOpSRem: return "OpSRem"; -+ case SpvOpSMod: return "OpSMod"; -+ case SpvOpFRem: return "OpFRem"; -+ case SpvOpFMod: return "OpFMod"; -+ case SpvOpVectorTimesScalar: return "OpVectorTimesScalar"; -+ case SpvOpMatrixTimesScalar: return "OpMatrixTimesScalar"; -+ case SpvOpVectorTimesMatrix: return "OpVectorTimesMatrix"; -+ case SpvOpMatrixTimesVector: return "OpMatrixTimesVector"; -+ case SpvOpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; -+ case SpvOpOuterProduct: return "OpOuterProduct"; -+ case SpvOpDot: return "OpDot"; -+ case SpvOpIAddCarry: return "OpIAddCarry"; -+ case SpvOpISubBorrow: return "OpISubBorrow"; -+ case SpvOpUMulExtended: return "OpUMulExtended"; -+ case SpvOpSMulExtended: return "OpSMulExtended"; -+ case SpvOpAny: return "OpAny"; -+ case SpvOpAll: return "OpAll"; -+ case SpvOpIsNan: return "OpIsNan"; -+ case SpvOpIsInf: return "OpIsInf"; -+ case SpvOpIsFinite: return "OpIsFinite"; -+ case SpvOpIsNormal: return "OpIsNormal"; -+ case SpvOpSignBitSet: return "OpSignBitSet"; -+ case SpvOpLessOrGreater: return "OpLessOrGreater"; -+ case SpvOpOrdered: return "OpOrdered"; -+ case SpvOpUnordered: return "OpUnordered"; -+ case SpvOpLogicalEqual: return "OpLogicalEqual"; -+ case SpvOpLogicalNotEqual: return "OpLogicalNotEqual"; -+ case SpvOpLogicalOr: return "OpLogicalOr"; -+ case SpvOpLogicalAnd: return "OpLogicalAnd"; -+ case SpvOpLogicalNot: return "OpLogicalNot"; -+ case SpvOpSelect: return "OpSelect"; -+ case SpvOpIEqual: return "OpIEqual"; -+ case SpvOpINotEqual: return "OpINotEqual"; -+ case SpvOpUGreaterThan: return "OpUGreaterThan"; -+ case SpvOpSGreaterThan: return "OpSGreaterThan"; -+ case SpvOpUGreaterThanEqual: return "OpUGreaterThanEqual"; -+ case SpvOpSGreaterThanEqual: return "OpSGreaterThanEqual"; -+ case SpvOpULessThan: return "OpULessThan"; -+ case SpvOpSLessThan: return "OpSLessThan"; -+ case SpvOpULessThanEqual: return "OpULessThanEqual"; -+ case SpvOpSLessThanEqual: return "OpSLessThanEqual"; -+ case SpvOpFOrdEqual: return "OpFOrdEqual"; -+ case SpvOpFUnordEqual: return "OpFUnordEqual"; -+ case SpvOpFOrdNotEqual: return "OpFOrdNotEqual"; -+ case SpvOpFUnordNotEqual: return "OpFUnordNotEqual"; -+ case SpvOpFOrdLessThan: return "OpFOrdLessThan"; -+ case SpvOpFUnordLessThan: return "OpFUnordLessThan"; -+ case SpvOpFOrdGreaterThan: return "OpFOrdGreaterThan"; -+ case SpvOpFUnordGreaterThan: return "OpFUnordGreaterThan"; -+ case SpvOpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; -+ case SpvOpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; -+ case SpvOpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; -+ case SpvOpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; -+ case SpvOpShiftRightLogical: return "OpShiftRightLogical"; -+ case SpvOpShiftRightArithmetic: return "OpShiftRightArithmetic"; -+ case SpvOpShiftLeftLogical: return "OpShiftLeftLogical"; -+ case SpvOpBitwiseOr: return "OpBitwiseOr"; -+ case SpvOpBitwiseXor: return "OpBitwiseXor"; -+ case SpvOpBitwiseAnd: return "OpBitwiseAnd"; -+ case SpvOpNot: return "OpNot"; -+ case SpvOpBitFieldInsert: return "OpBitFieldInsert"; -+ case SpvOpBitFieldSExtract: return "OpBitFieldSExtract"; -+ case SpvOpBitFieldUExtract: return "OpBitFieldUExtract"; -+ case SpvOpBitReverse: return "OpBitReverse"; -+ case SpvOpBitCount: return "OpBitCount"; -+ case SpvOpDPdx: return "OpDPdx"; -+ case SpvOpDPdy: return "OpDPdy"; -+ case SpvOpFwidth: return "OpFwidth"; -+ case SpvOpDPdxFine: return "OpDPdxFine"; -+ case SpvOpDPdyFine: return "OpDPdyFine"; -+ case SpvOpFwidthFine: return "OpFwidthFine"; -+ case SpvOpDPdxCoarse: return "OpDPdxCoarse"; -+ case SpvOpDPdyCoarse: return "OpDPdyCoarse"; -+ case SpvOpFwidthCoarse: return "OpFwidthCoarse"; -+ case SpvOpEmitVertex: return "OpEmitVertex"; -+ case SpvOpEndPrimitive: return "OpEndPrimitive"; -+ case SpvOpEmitStreamVertex: return "OpEmitStreamVertex"; -+ case SpvOpEndStreamPrimitive: return "OpEndStreamPrimitive"; -+ case SpvOpControlBarrier: return "OpControlBarrier"; -+ case SpvOpMemoryBarrier: return "OpMemoryBarrier"; -+ case SpvOpAtomicLoad: return "OpAtomicLoad"; -+ case SpvOpAtomicStore: return "OpAtomicStore"; -+ case SpvOpAtomicExchange: return "OpAtomicExchange"; -+ case SpvOpAtomicCompareExchange: return "OpAtomicCompareExchange"; -+ case SpvOpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; -+ case SpvOpAtomicIIncrement: return "OpAtomicIIncrement"; -+ case SpvOpAtomicIDecrement: return "OpAtomicIDecrement"; -+ case SpvOpAtomicIAdd: return "OpAtomicIAdd"; -+ case SpvOpAtomicISub: return "OpAtomicISub"; -+ case SpvOpAtomicSMin: return "OpAtomicSMin"; -+ case SpvOpAtomicUMin: return "OpAtomicUMin"; -+ case SpvOpAtomicSMax: return "OpAtomicSMax"; -+ case SpvOpAtomicUMax: return "OpAtomicUMax"; -+ case SpvOpAtomicAnd: return "OpAtomicAnd"; -+ case SpvOpAtomicOr: return "OpAtomicOr"; -+ case SpvOpAtomicXor: return "OpAtomicXor"; -+ case SpvOpPhi: return "OpPhi"; -+ case SpvOpLoopMerge: return "OpLoopMerge"; -+ case SpvOpSelectionMerge: return "OpSelectionMerge"; -+ case SpvOpLabel: return "OpLabel"; -+ case SpvOpBranch: return "OpBranch"; -+ case SpvOpBranchConditional: return "OpBranchConditional"; -+ case SpvOpSwitch: return "OpSwitch"; -+ case SpvOpKill: return "OpKill"; -+ case SpvOpReturn: return "OpReturn"; -+ case SpvOpReturnValue: return "OpReturnValue"; -+ case SpvOpUnreachable: return "OpUnreachable"; -+ case SpvOpLifetimeStart: return "OpLifetimeStart"; -+ case SpvOpLifetimeStop: return "OpLifetimeStop"; -+ case SpvOpGroupAsyncCopy: return "OpGroupAsyncCopy"; -+ case SpvOpGroupWaitEvents: return "OpGroupWaitEvents"; -+ case SpvOpGroupAll: return "OpGroupAll"; -+ case SpvOpGroupAny: return "OpGroupAny"; -+ case SpvOpGroupBroadcast: return "OpGroupBroadcast"; -+ case SpvOpGroupIAdd: return "OpGroupIAdd"; -+ case SpvOpGroupFAdd: return "OpGroupFAdd"; -+ case SpvOpGroupFMin: return "OpGroupFMin"; -+ case SpvOpGroupUMin: return "OpGroupUMin"; -+ case SpvOpGroupSMin: return "OpGroupSMin"; -+ case SpvOpGroupFMax: return "OpGroupFMax"; -+ case SpvOpGroupUMax: return "OpGroupUMax"; -+ case SpvOpGroupSMax: return "OpGroupSMax"; -+ case SpvOpReadPipe: return "OpReadPipe"; -+ case SpvOpWritePipe: return "OpWritePipe"; -+ case SpvOpReservedReadPipe: return "OpReservedReadPipe"; -+ case SpvOpReservedWritePipe: return "OpReservedWritePipe"; -+ case SpvOpReserveReadPipePackets: return "OpReserveReadPipePackets"; -+ case SpvOpReserveWritePipePackets: return "OpReserveWritePipePackets"; -+ case SpvOpCommitReadPipe: return "OpCommitReadPipe"; -+ case SpvOpCommitWritePipe: return "OpCommitWritePipe"; -+ case SpvOpIsValidReserveId: return "OpIsValidReserveId"; -+ case SpvOpGetNumPipePackets: return "OpGetNumPipePackets"; -+ case SpvOpGetMaxPipePackets: return "OpGetMaxPipePackets"; -+ case SpvOpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; -+ case SpvOpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; -+ case SpvOpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; -+ case SpvOpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; -+ case SpvOpEnqueueMarker: return "OpEnqueueMarker"; -+ case SpvOpEnqueueKernel: return "OpEnqueueKernel"; -+ case SpvOpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; -+ case SpvOpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; -+ case SpvOpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; -+ case SpvOpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; -+ case SpvOpRetainEvent: return "OpRetainEvent"; -+ case SpvOpReleaseEvent: return "OpReleaseEvent"; -+ case SpvOpCreateUserEvent: return "OpCreateUserEvent"; -+ case SpvOpIsValidEvent: return "OpIsValidEvent"; -+ case SpvOpSetUserEventStatus: return "OpSetUserEventStatus"; -+ case SpvOpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; -+ case SpvOpGetDefaultQueue: return "OpGetDefaultQueue"; -+ case SpvOpBuildNDRange: return "OpBuildNDRange"; -+ case SpvOpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; -+ case SpvOpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; -+ case SpvOpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; -+ case SpvOpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; -+ case SpvOpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; -+ case SpvOpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; -+ case SpvOpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; -+ case SpvOpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; -+ case SpvOpImageSparseFetch: return "OpImageSparseFetch"; -+ case SpvOpImageSparseGather: return "OpImageSparseGather"; -+ case SpvOpImageSparseDrefGather: return "OpImageSparseDrefGather"; -+ case SpvOpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; -+ case SpvOpNoLine: return "OpNoLine"; -+ case SpvOpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; -+ case SpvOpAtomicFlagClear: return "OpAtomicFlagClear"; -+ case SpvOpImageSparseRead: return "OpImageSparseRead"; -+ case SpvOpSizeOf: return "OpSizeOf"; -+ case SpvOpTypePipeStorage: return "OpTypePipeStorage"; -+ case SpvOpConstantPipeStorage: return "OpConstantPipeStorage"; -+ case SpvOpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; -+ case SpvOpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; -+ case SpvOpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; -+ case SpvOpTypeNamedBarrier: return "OpTypeNamedBarrier"; -+ case SpvOpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; -+ case SpvOpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; -+ case SpvOpModuleProcessed: return "OpModuleProcessed"; -+ case SpvOpExecutionModeId: return "OpExecutionModeId"; -+ case SpvOpDecorateId: return "OpDecorateId"; -+ case SpvOpGroupNonUniformElect: return "OpGroupNonUniformElect"; -+ case SpvOpGroupNonUniformAll: return "OpGroupNonUniformAll"; -+ case SpvOpGroupNonUniformAny: return "OpGroupNonUniformAny"; -+ case SpvOpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; -+ case SpvOpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; -+ case SpvOpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; -+ case SpvOpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; -+ case SpvOpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; -+ case SpvOpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; -+ case SpvOpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; -+ case SpvOpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; -+ case SpvOpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; -+ case SpvOpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; -+ case SpvOpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; -+ case SpvOpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; -+ case SpvOpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; -+ case SpvOpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; -+ case SpvOpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; -+ case SpvOpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; -+ case SpvOpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; -+ case SpvOpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; -+ case SpvOpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; -+ case SpvOpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; -+ case SpvOpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; -+ case SpvOpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; -+ case SpvOpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; -+ case SpvOpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; -+ case SpvOpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; -+ case SpvOpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; -+ case SpvOpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; -+ case SpvOpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; -+ case SpvOpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; -+ case SpvOpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; -+ case SpvOpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; -+ case SpvOpCopyLogical: return "OpCopyLogical"; -+ case SpvOpPtrEqual: return "OpPtrEqual"; -+ case SpvOpPtrNotEqual: return "OpPtrNotEqual"; -+ case SpvOpPtrDiff: return "OpPtrDiff"; -+ case SpvOpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; -+ case SpvOpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; -+ case SpvOpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; -+ case SpvOpTerminateInvocation: return "OpTerminateInvocation"; -+ case SpvOpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; -+ case SpvOpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; -+ case SpvOpSubgroupAllKHR: return "OpSubgroupAllKHR"; -+ case SpvOpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; -+ case SpvOpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; -+ case SpvOpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; -+ case SpvOpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; -+ case SpvOpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; -+ case SpvOpTraceRayKHR: return "OpTraceRayKHR"; -+ case SpvOpExecuteCallableKHR: return "OpExecuteCallableKHR"; -+ case SpvOpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; -+ case SpvOpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; -+ case SpvOpTerminateRayKHR: return "OpTerminateRayKHR"; -+ case SpvOpSDot: return "OpSDot"; -+ case SpvOpUDot: return "OpUDot"; -+ case SpvOpSUDot: return "OpSUDot"; -+ case SpvOpSDotAccSat: return "OpSDotAccSat"; -+ case SpvOpUDotAccSat: return "OpUDotAccSat"; -+ case SpvOpSUDotAccSat: return "OpSUDotAccSat"; -+ case SpvOpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; -+ case SpvOpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; -+ case SpvOpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; -+ case SpvOpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; -+ case SpvOpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; -+ case SpvOpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; -+ case SpvOpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; -+ case SpvOpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; -+ case SpvOpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; -+ case SpvOpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; -+ case SpvOpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; -+ case SpvOpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; -+ case SpvOpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; -+ case SpvOpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; -+ case SpvOpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; -+ case SpvOpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; -+ case SpvOpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; -+ case SpvOpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; -+ case SpvOpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; -+ case SpvOpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; -+ case SpvOpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; -+ case SpvOpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; -+ case SpvOpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; -+ case SpvOpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; -+ case SpvOpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; -+ case SpvOpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; -+ case SpvOpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; -+ case SpvOpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; -+ case SpvOpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; -+ case SpvOpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; -+ case SpvOpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; -+ case SpvOpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; -+ case SpvOpFragmentFetchAMD: return "OpFragmentFetchAMD"; -+ case SpvOpReadClockKHR: return "OpReadClockKHR"; -+ case SpvOpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; -+ case SpvOpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; -+ case SpvOpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; -+ case SpvOpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; -+ case SpvOpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; -+ case SpvOpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; -+ case SpvOpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; -+ case SpvOpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; -+ case SpvOpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; -+ case SpvOpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; -+ case SpvOpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; -+ case SpvOpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; -+ case SpvOpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; -+ case SpvOpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; -+ case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; -+ case SpvOpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; -+ case SpvOpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; -+ case SpvOpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; -+ case SpvOpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; -+ case SpvOpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; -+ case SpvOpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; -+ case SpvOpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; -+ case SpvOpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; -+ case SpvOpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; -+ case SpvOpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; -+ case SpvOpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; -+ case SpvOpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; -+ case SpvOpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; -+ case SpvOpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; -+ case SpvOpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; -+ case SpvOpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; -+ case SpvOpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; -+ case SpvOpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; -+ case SpvOpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; -+ case SpvOpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; -+ case SpvOpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; -+ case SpvOpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; -+ case SpvOpTypeHitObjectNV: return "OpTypeHitObjectNV"; -+ case SpvOpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; -+ case SpvOpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; -+ case SpvOpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; -+ case SpvOpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; -+ case SpvOpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; -+ case SpvOpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; -+ case SpvOpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; -+ case SpvOpReportIntersectionKHR: return "OpReportIntersectionKHR"; -+ case SpvOpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; -+ case SpvOpTerminateRayNV: return "OpTerminateRayNV"; -+ case SpvOpTraceNV: return "OpTraceNV"; -+ case SpvOpTraceMotionNV: return "OpTraceMotionNV"; -+ case SpvOpTraceRayMotionNV: return "OpTraceRayMotionNV"; -+ case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; -+ case SpvOpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; -+ case SpvOpExecuteCallableNV: return "OpExecuteCallableNV"; -+ case SpvOpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; -+ case SpvOpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; -+ case SpvOpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; -+ case SpvOpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; -+ case SpvOpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; -+ case SpvOpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; -+ case SpvOpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; -+ case SpvOpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; -+ case SpvOpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; -+ case SpvOpConvertUToImageNV: return "OpConvertUToImageNV"; -+ case SpvOpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; -+ case SpvOpConvertImageToUNV: return "OpConvertImageToUNV"; -+ case SpvOpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; -+ case SpvOpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; -+ case SpvOpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; -+ case SpvOpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; -+ case SpvOpRawAccessChainNV: return "OpRawAccessChainNV"; -+ case SpvOpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; -+ case SpvOpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; -+ case SpvOpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; -+ case SpvOpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; -+ case SpvOpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; -+ case SpvOpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; -+ case SpvOpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; -+ case SpvOpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; -+ case SpvOpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; -+ case SpvOpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; -+ case SpvOpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; -+ case SpvOpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; -+ case SpvOpAbsISubINTEL: return "OpAbsISubINTEL"; -+ case SpvOpAbsUSubINTEL: return "OpAbsUSubINTEL"; -+ case SpvOpIAddSatINTEL: return "OpIAddSatINTEL"; -+ case SpvOpUAddSatINTEL: return "OpUAddSatINTEL"; -+ case SpvOpIAverageINTEL: return "OpIAverageINTEL"; -+ case SpvOpUAverageINTEL: return "OpUAverageINTEL"; -+ case SpvOpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; -+ case SpvOpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; -+ case SpvOpISubSatINTEL: return "OpISubSatINTEL"; -+ case SpvOpUSubSatINTEL: return "OpUSubSatINTEL"; -+ case SpvOpIMul32x16INTEL: return "OpIMul32x16INTEL"; -+ case SpvOpUMul32x16INTEL: return "OpUMul32x16INTEL"; -+ case SpvOpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; -+ case SpvOpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; -+ case SpvOpAsmTargetINTEL: return "OpAsmTargetINTEL"; -+ case SpvOpAsmINTEL: return "OpAsmINTEL"; -+ case SpvOpAsmCallINTEL: return "OpAsmCallINTEL"; -+ case SpvOpAtomicFMinEXT: return "OpAtomicFMinEXT"; -+ case SpvOpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; -+ case SpvOpAssumeTrueKHR: return "OpAssumeTrueKHR"; -+ case SpvOpExpectKHR: return "OpExpectKHR"; -+ case SpvOpDecorateString: return "OpDecorateString"; -+ case SpvOpMemberDecorateString: return "OpMemberDecorateString"; -+ case SpvOpVmeImageINTEL: return "OpVmeImageINTEL"; -+ case SpvOpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; -+ case SpvOpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; -+ case SpvOpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; -+ case SpvOpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; -+ case SpvOpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; -+ case SpvOpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; -+ case SpvOpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; -+ case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; -+ case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; -+ case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; -+ case SpvOpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; -+ case SpvOpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; -+ case SpvOpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; -+ case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; -+ case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; -+ case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; -+ case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; -+ case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; -+ case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; -+ case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; -+ case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; -+ case SpvOpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; -+ case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; -+ case SpvOpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; -+ case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; -+ case SpvOpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; -+ case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; -+ case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; -+ case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; -+ case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; -+ case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; -+ case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; -+ case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; -+ case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; -+ case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; -+ case SpvOpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; -+ case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; -+ case SpvOpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; -+ case SpvOpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; -+ case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; -+ case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; -+ case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; -+ case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; -+ case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; -+ case SpvOpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; -+ case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; -+ case SpvOpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; -+ case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; -+ case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; -+ case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; -+ case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; -+ case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; -+ case SpvOpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; -+ case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; -+ case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; -+ case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; -+ case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; -+ case SpvOpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; -+ case SpvOpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; -+ case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; -+ case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; -+ case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; -+ case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; -+ case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; -+ case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; -+ case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; -+ case SpvOpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; -+ case SpvOpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; -+ case SpvOpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; -+ case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; -+ case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; -+ case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; -+ case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; -+ case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; -+ case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; -+ case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; -+ case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; -+ case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; -+ case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; -+ case SpvOpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; -+ case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; -+ case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; -+ case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; -+ case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; -+ case SpvOpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; -+ case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; -+ case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; -+ case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; -+ case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; -+ case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; -+ case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; -+ case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; -+ case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; -+ case SpvOpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; -+ case SpvOpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; -+ case SpvOpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; -+ case SpvOpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; -+ case SpvOpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; -+ case SpvOpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; -+ case SpvOpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; -+ case SpvOpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; -+ case SpvOpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; -+ case SpvOpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; -+ case SpvOpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; -+ case SpvOpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; -+ case SpvOpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; -+ case SpvOpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; -+ case SpvOpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; -+ case SpvOpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; -+ case SpvOpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; -+ case SpvOpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; -+ case SpvOpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; -+ case SpvOpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; -+ case SpvOpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; -+ case SpvOpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; -+ case SpvOpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; -+ case SpvOpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; -+ case SpvOpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; -+ case SpvOpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; -+ case SpvOpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; -+ case SpvOpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; -+ case SpvOpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; -+ case SpvOpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; -+ case SpvOpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; -+ case SpvOpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; -+ case SpvOpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; -+ case SpvOpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; -+ case SpvOpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; -+ case SpvOpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; -+ case SpvOpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; -+ case SpvOpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; -+ case SpvOpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; -+ case SpvOpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; -+ case SpvOpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; -+ case SpvOpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; -+ case SpvOpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; -+ case SpvOpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; -+ case SpvOpLoopControlINTEL: return "OpLoopControlINTEL"; -+ case SpvOpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; -+ case SpvOpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; -+ case SpvOpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; -+ case SpvOpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; -+ case SpvOpFixedRecipINTEL: return "OpFixedRecipINTEL"; -+ case SpvOpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; -+ case SpvOpFixedSinINTEL: return "OpFixedSinINTEL"; -+ case SpvOpFixedCosINTEL: return "OpFixedCosINTEL"; -+ case SpvOpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; -+ case SpvOpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; -+ case SpvOpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; -+ case SpvOpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; -+ case SpvOpFixedLogINTEL: return "OpFixedLogINTEL"; -+ case SpvOpFixedExpINTEL: return "OpFixedExpINTEL"; -+ case SpvOpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; -+ case SpvOpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; -+ case SpvOpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; -+ case SpvOpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; -+ case SpvOpFPGARegINTEL: return "OpFPGARegINTEL"; -+ case SpvOpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; -+ case SpvOpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; -+ case SpvOpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; -+ case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; -+ case SpvOpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; -+ case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; -+ case SpvOpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; -+ case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; -+ case SpvOpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; -+ case SpvOpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; -+ case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; -+ case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; -+ case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; -+ case SpvOpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; -+ case SpvOpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; -+ case SpvOpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; -+ case SpvOpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; -+ case SpvOpAtomicFAddEXT: return "OpAtomicFAddEXT"; -+ case SpvOpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; -+ case SpvOpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; -+ case SpvOpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; -+ case SpvOpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; -+ case SpvOpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; -+ case SpvOpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; -+ case SpvOpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; -+ case SpvOpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; -+ case SpvOpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; -+ case SpvOpGroupIMulKHR: return "OpGroupIMulKHR"; -+ case SpvOpGroupFMulKHR: return "OpGroupFMulKHR"; -+ case SpvOpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; -+ case SpvOpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; -+ case SpvOpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; -+ case SpvOpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; -+ case SpvOpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; -+ case SpvOpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; -+ case SpvOpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; -+ case SpvOpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; -+ default: return "Unknown"; -+ } -+} -+ - #endif /* SPV_ENABLE_UTILITY_CODE */ - - #endif -diff --git include/spirv/unified1/spirv.hpp include/spirv/unified1/spirv.hpp -index a383739..2ebc387 100644 ---- include/spirv/unified1/spirv.hpp -+++ include/spirv/unified1/spirv.hpp -@@ -1045,6 +1045,7 @@ enum Capability { - CapabilityTileImageColorReadAccessEXT = 4166, - CapabilityTileImageDepthReadAccessEXT = 4167, - CapabilityTileImageStencilReadAccessEXT = 4168, -+ CapabilityCooperativeMatrixLayoutsARM = 4201, - CapabilityFragmentShadingRateKHR = 4422, - CapabilitySubgroupBallotKHR = 4423, - CapabilityDrawParameters = 4427, -@@ -1208,6 +1209,7 @@ enum Capability { - CapabilityDotProductKHR = 6019, - CapabilityRayCullMaskKHR = 6020, - CapabilityCooperativeMatrixKHR = 6022, -+ CapabilityReplicatedCompositesEXT = 6024, - CapabilityBitInstructions = 6025, - CapabilityGroupNonUniformRotateKHR = 6026, - CapabilityFloatControls2 = 6029, -@@ -1357,6 +1359,8 @@ enum CooperativeMatrixOperandsMask { - enum CooperativeMatrixLayout { - CooperativeMatrixLayoutRowMajorKHR = 0, - CooperativeMatrixLayoutColumnMajorKHR = 1, -+ CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202, -+ CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203, - CooperativeMatrixLayoutMax = 0x7fffffff, - }; - -@@ -1771,6 +1775,7 @@ enum Op { - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1793,6 +1798,9 @@ enum Op { - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -@@ -2515,6 +2523,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; -+ case OpExtInstWithForwardRefsKHR: *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; -@@ -2531,6 +2540,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; - case OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; - case OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; -+ case OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; - case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; - case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; - case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; -@@ -2602,14 +2614,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; - case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; - case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; -- case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; -+ case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; - case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; - case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; - case OpTraceNV: *hasResult = false; *hasResultType = false; break; - case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break; - case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; - case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; -- case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; -+ case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; - case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; - case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; -@@ -2884,6 +2896,1787 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; - } - } -+inline const char* SourceLanguageToString(SourceLanguage value) { -+ switch (value) { -+ case SourceLanguageUnknown: return "Unknown"; -+ case SourceLanguageESSL: return "ESSL"; -+ case SourceLanguageGLSL: return "GLSL"; -+ case SourceLanguageOpenCL_C: return "OpenCL_C"; -+ case SourceLanguageOpenCL_CPP: return "OpenCL_CPP"; -+ case SourceLanguageHLSL: return "HLSL"; -+ case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; -+ case SourceLanguageSYCL: return "SYCL"; -+ case SourceLanguageHERO_C: return "HERO_C"; -+ case SourceLanguageNZSL: return "NZSL"; -+ case SourceLanguageWGSL: return "WGSL"; -+ case SourceLanguageSlang: return "Slang"; -+ case SourceLanguageZig: return "Zig"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ExecutionModelToString(ExecutionModel value) { -+ switch (value) { -+ case ExecutionModelVertex: return "Vertex"; -+ case ExecutionModelTessellationControl: return "TessellationControl"; -+ case ExecutionModelTessellationEvaluation: return "TessellationEvaluation"; -+ case ExecutionModelGeometry: return "Geometry"; -+ case ExecutionModelFragment: return "Fragment"; -+ case ExecutionModelGLCompute: return "GLCompute"; -+ case ExecutionModelKernel: return "Kernel"; -+ case ExecutionModelTaskNV: return "TaskNV"; -+ case ExecutionModelMeshNV: return "MeshNV"; -+ case ExecutionModelRayGenerationKHR: return "RayGenerationKHR"; -+ case ExecutionModelIntersectionKHR: return "IntersectionKHR"; -+ case ExecutionModelAnyHitKHR: return "AnyHitKHR"; -+ case ExecutionModelClosestHitKHR: return "ClosestHitKHR"; -+ case ExecutionModelMissKHR: return "MissKHR"; -+ case ExecutionModelCallableKHR: return "CallableKHR"; -+ case ExecutionModelTaskEXT: return "TaskEXT"; -+ case ExecutionModelMeshEXT: return "MeshEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* AddressingModelToString(AddressingModel value) { -+ switch (value) { -+ case AddressingModelLogical: return "Logical"; -+ case AddressingModelPhysical32: return "Physical32"; -+ case AddressingModelPhysical64: return "Physical64"; -+ case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* MemoryModelToString(MemoryModel value) { -+ switch (value) { -+ case MemoryModelSimple: return "Simple"; -+ case MemoryModelGLSL450: return "GLSL450"; -+ case MemoryModelOpenCL: return "OpenCL"; -+ case MemoryModelVulkan: return "Vulkan"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ExecutionModeToString(ExecutionMode value) { -+ switch (value) { -+ case ExecutionModeInvocations: return "Invocations"; -+ case ExecutionModeSpacingEqual: return "SpacingEqual"; -+ case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; -+ case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; -+ case ExecutionModeVertexOrderCw: return "VertexOrderCw"; -+ case ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; -+ case ExecutionModePixelCenterInteger: return "PixelCenterInteger"; -+ case ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; -+ case ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; -+ case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; -+ case ExecutionModePointMode: return "PointMode"; -+ case ExecutionModeXfb: return "Xfb"; -+ case ExecutionModeDepthReplacing: return "DepthReplacing"; -+ case ExecutionModeDepthGreater: return "DepthGreater"; -+ case ExecutionModeDepthLess: return "DepthLess"; -+ case ExecutionModeDepthUnchanged: return "DepthUnchanged"; -+ case ExecutionModeLocalSize: return "LocalSize"; -+ case ExecutionModeLocalSizeHint: return "LocalSizeHint"; -+ case ExecutionModeInputPoints: return "InputPoints"; -+ case ExecutionModeInputLines: return "InputLines"; -+ case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; -+ case ExecutionModeTriangles: return "Triangles"; -+ case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; -+ case ExecutionModeQuads: return "Quads"; -+ case ExecutionModeIsolines: return "Isolines"; -+ case ExecutionModeOutputVertices: return "OutputVertices"; -+ case ExecutionModeOutputPoints: return "OutputPoints"; -+ case ExecutionModeOutputLineStrip: return "OutputLineStrip"; -+ case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; -+ case ExecutionModeVecTypeHint: return "VecTypeHint"; -+ case ExecutionModeContractionOff: return "ContractionOff"; -+ case ExecutionModeInitializer: return "Initializer"; -+ case ExecutionModeFinalizer: return "Finalizer"; -+ case ExecutionModeSubgroupSize: return "SubgroupSize"; -+ case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; -+ case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; -+ case ExecutionModeLocalSizeId: return "LocalSizeId"; -+ case ExecutionModeLocalSizeHintId: return "LocalSizeHintId"; -+ case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; -+ case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; -+ case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; -+ case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; -+ case ExecutionModePostDepthCoverage: return "PostDepthCoverage"; -+ case ExecutionModeDenormPreserve: return "DenormPreserve"; -+ case ExecutionModeDenormFlushToZero: return "DenormFlushToZero"; -+ case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; -+ case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; -+ case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; -+ case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; -+ case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; -+ case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; -+ case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; -+ case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; -+ case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; -+ case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; -+ case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; -+ case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; -+ case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; -+ case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; -+ case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; -+ case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; -+ case ExecutionModeOutputLinesEXT: return "OutputLinesEXT"; -+ case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; -+ case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; -+ case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; -+ case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; -+ case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; -+ case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; -+ case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; -+ case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; -+ case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; -+ case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; -+ case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; -+ case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; -+ case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; -+ case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; -+ case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; -+ case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; -+ case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; -+ case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; -+ case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; -+ case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; -+ case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; -+ case ExecutionModeFPFastMathDefault: return "FPFastMathDefault"; -+ case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; -+ case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; -+ case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; -+ case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; -+ case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; -+ case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* StorageClassToString(StorageClass value) { -+ switch (value) { -+ case StorageClassUniformConstant: return "UniformConstant"; -+ case StorageClassInput: return "Input"; -+ case StorageClassUniform: return "Uniform"; -+ case StorageClassOutput: return "Output"; -+ case StorageClassWorkgroup: return "Workgroup"; -+ case StorageClassCrossWorkgroup: return "CrossWorkgroup"; -+ case StorageClassPrivate: return "Private"; -+ case StorageClassFunction: return "Function"; -+ case StorageClassGeneric: return "Generic"; -+ case StorageClassPushConstant: return "PushConstant"; -+ case StorageClassAtomicCounter: return "AtomicCounter"; -+ case StorageClassImage: return "Image"; -+ case StorageClassStorageBuffer: return "StorageBuffer"; -+ case StorageClassTileImageEXT: return "TileImageEXT"; -+ case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; -+ case StorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; -+ case StorageClassCallableDataKHR: return "CallableDataKHR"; -+ case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; -+ case StorageClassRayPayloadKHR: return "RayPayloadKHR"; -+ case StorageClassHitAttributeKHR: return "HitAttributeKHR"; -+ case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; -+ case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; -+ case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; -+ case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; -+ case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; -+ case StorageClassCodeSectionINTEL: return "CodeSectionINTEL"; -+ case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; -+ case StorageClassHostOnlyINTEL: return "HostOnlyINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* DimToString(Dim value) { -+ switch (value) { -+ case Dim1D: return "1D"; -+ case Dim2D: return "2D"; -+ case Dim3D: return "3D"; -+ case DimCube: return "Cube"; -+ case DimRect: return "Rect"; -+ case DimBuffer: return "Buffer"; -+ case DimSubpassData: return "SubpassData"; -+ case DimTileImageDataEXT: return "TileImageDataEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) { -+ switch (value) { -+ case SamplerAddressingModeNone: return "None"; -+ case SamplerAddressingModeClampToEdge: return "ClampToEdge"; -+ case SamplerAddressingModeClamp: return "Clamp"; -+ case SamplerAddressingModeRepeat: return "Repeat"; -+ case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SamplerFilterModeToString(SamplerFilterMode value) { -+ switch (value) { -+ case SamplerFilterModeNearest: return "Nearest"; -+ case SamplerFilterModeLinear: return "Linear"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageFormatToString(ImageFormat value) { -+ switch (value) { -+ case ImageFormatUnknown: return "Unknown"; -+ case ImageFormatRgba32f: return "Rgba32f"; -+ case ImageFormatRgba16f: return "Rgba16f"; -+ case ImageFormatR32f: return "R32f"; -+ case ImageFormatRgba8: return "Rgba8"; -+ case ImageFormatRgba8Snorm: return "Rgba8Snorm"; -+ case ImageFormatRg32f: return "Rg32f"; -+ case ImageFormatRg16f: return "Rg16f"; -+ case ImageFormatR11fG11fB10f: return "R11fG11fB10f"; -+ case ImageFormatR16f: return "R16f"; -+ case ImageFormatRgba16: return "Rgba16"; -+ case ImageFormatRgb10A2: return "Rgb10A2"; -+ case ImageFormatRg16: return "Rg16"; -+ case ImageFormatRg8: return "Rg8"; -+ case ImageFormatR16: return "R16"; -+ case ImageFormatR8: return "R8"; -+ case ImageFormatRgba16Snorm: return "Rgba16Snorm"; -+ case ImageFormatRg16Snorm: return "Rg16Snorm"; -+ case ImageFormatRg8Snorm: return "Rg8Snorm"; -+ case ImageFormatR16Snorm: return "R16Snorm"; -+ case ImageFormatR8Snorm: return "R8Snorm"; -+ case ImageFormatRgba32i: return "Rgba32i"; -+ case ImageFormatRgba16i: return "Rgba16i"; -+ case ImageFormatRgba8i: return "Rgba8i"; -+ case ImageFormatR32i: return "R32i"; -+ case ImageFormatRg32i: return "Rg32i"; -+ case ImageFormatRg16i: return "Rg16i"; -+ case ImageFormatRg8i: return "Rg8i"; -+ case ImageFormatR16i: return "R16i"; -+ case ImageFormatR8i: return "R8i"; -+ case ImageFormatRgba32ui: return "Rgba32ui"; -+ case ImageFormatRgba16ui: return "Rgba16ui"; -+ case ImageFormatRgba8ui: return "Rgba8ui"; -+ case ImageFormatR32ui: return "R32ui"; -+ case ImageFormatRgb10a2ui: return "Rgb10a2ui"; -+ case ImageFormatRg32ui: return "Rg32ui"; -+ case ImageFormatRg16ui: return "Rg16ui"; -+ case ImageFormatRg8ui: return "Rg8ui"; -+ case ImageFormatR16ui: return "R16ui"; -+ case ImageFormatR8ui: return "R8ui"; -+ case ImageFormatR64ui: return "R64ui"; -+ case ImageFormatR64i: return "R64i"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageChannelOrderToString(ImageChannelOrder value) { -+ switch (value) { -+ case ImageChannelOrderR: return "R"; -+ case ImageChannelOrderA: return "A"; -+ case ImageChannelOrderRG: return "RG"; -+ case ImageChannelOrderRA: return "RA"; -+ case ImageChannelOrderRGB: return "RGB"; -+ case ImageChannelOrderRGBA: return "RGBA"; -+ case ImageChannelOrderBGRA: return "BGRA"; -+ case ImageChannelOrderARGB: return "ARGB"; -+ case ImageChannelOrderIntensity: return "Intensity"; -+ case ImageChannelOrderLuminance: return "Luminance"; -+ case ImageChannelOrderRx: return "Rx"; -+ case ImageChannelOrderRGx: return "RGx"; -+ case ImageChannelOrderRGBx: return "RGBx"; -+ case ImageChannelOrderDepth: return "Depth"; -+ case ImageChannelOrderDepthStencil: return "DepthStencil"; -+ case ImageChannelOrdersRGB: return "sRGB"; -+ case ImageChannelOrdersRGBx: return "sRGBx"; -+ case ImageChannelOrdersRGBA: return "sRGBA"; -+ case ImageChannelOrdersBGRA: return "sBGRA"; -+ case ImageChannelOrderABGR: return "ABGR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) { -+ switch (value) { -+ case ImageChannelDataTypeSnormInt8: return "SnormInt8"; -+ case ImageChannelDataTypeSnormInt16: return "SnormInt16"; -+ case ImageChannelDataTypeUnormInt8: return "UnormInt8"; -+ case ImageChannelDataTypeUnormInt16: return "UnormInt16"; -+ case ImageChannelDataTypeUnormShort565: return "UnormShort565"; -+ case ImageChannelDataTypeUnormShort555: return "UnormShort555"; -+ case ImageChannelDataTypeUnormInt101010: return "UnormInt101010"; -+ case ImageChannelDataTypeSignedInt8: return "SignedInt8"; -+ case ImageChannelDataTypeSignedInt16: return "SignedInt16"; -+ case ImageChannelDataTypeSignedInt32: return "SignedInt32"; -+ case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; -+ case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; -+ case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; -+ case ImageChannelDataTypeHalfFloat: return "HalfFloat"; -+ case ImageChannelDataTypeFloat: return "Float"; -+ case ImageChannelDataTypeUnormInt24: return "UnormInt24"; -+ case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; -+ case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; -+ case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPRoundingModeToString(FPRoundingMode value) { -+ switch (value) { -+ case FPRoundingModeRTE: return "RTE"; -+ case FPRoundingModeRTZ: return "RTZ"; -+ case FPRoundingModeRTP: return "RTP"; -+ case FPRoundingModeRTN: return "RTN"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* LinkageTypeToString(LinkageType value) { -+ switch (value) { -+ case LinkageTypeExport: return "Export"; -+ case LinkageTypeImport: return "Import"; -+ case LinkageTypeLinkOnceODR: return "LinkOnceODR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* AccessQualifierToString(AccessQualifier value) { -+ switch (value) { -+ case AccessQualifierReadOnly: return "ReadOnly"; -+ case AccessQualifierWriteOnly: return "WriteOnly"; -+ case AccessQualifierReadWrite: return "ReadWrite"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) { -+ switch (value) { -+ case FunctionParameterAttributeZext: return "Zext"; -+ case FunctionParameterAttributeSext: return "Sext"; -+ case FunctionParameterAttributeByVal: return "ByVal"; -+ case FunctionParameterAttributeSret: return "Sret"; -+ case FunctionParameterAttributeNoAlias: return "NoAlias"; -+ case FunctionParameterAttributeNoCapture: return "NoCapture"; -+ case FunctionParameterAttributeNoWrite: return "NoWrite"; -+ case FunctionParameterAttributeNoReadWrite: return "NoReadWrite"; -+ case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* DecorationToString(Decoration value) { -+ switch (value) { -+ case DecorationRelaxedPrecision: return "RelaxedPrecision"; -+ case DecorationSpecId: return "SpecId"; -+ case DecorationBlock: return "Block"; -+ case DecorationBufferBlock: return "BufferBlock"; -+ case DecorationRowMajor: return "RowMajor"; -+ case DecorationColMajor: return "ColMajor"; -+ case DecorationArrayStride: return "ArrayStride"; -+ case DecorationMatrixStride: return "MatrixStride"; -+ case DecorationGLSLShared: return "GLSLShared"; -+ case DecorationGLSLPacked: return "GLSLPacked"; -+ case DecorationCPacked: return "CPacked"; -+ case DecorationBuiltIn: return "BuiltIn"; -+ case DecorationNoPerspective: return "NoPerspective"; -+ case DecorationFlat: return "Flat"; -+ case DecorationPatch: return "Patch"; -+ case DecorationCentroid: return "Centroid"; -+ case DecorationSample: return "Sample"; -+ case DecorationInvariant: return "Invariant"; -+ case DecorationRestrict: return "Restrict"; -+ case DecorationAliased: return "Aliased"; -+ case DecorationVolatile: return "Volatile"; -+ case DecorationConstant: return "Constant"; -+ case DecorationCoherent: return "Coherent"; -+ case DecorationNonWritable: return "NonWritable"; -+ case DecorationNonReadable: return "NonReadable"; -+ case DecorationUniform: return "Uniform"; -+ case DecorationUniformId: return "UniformId"; -+ case DecorationSaturatedConversion: return "SaturatedConversion"; -+ case DecorationStream: return "Stream"; -+ case DecorationLocation: return "Location"; -+ case DecorationComponent: return "Component"; -+ case DecorationIndex: return "Index"; -+ case DecorationBinding: return "Binding"; -+ case DecorationDescriptorSet: return "DescriptorSet"; -+ case DecorationOffset: return "Offset"; -+ case DecorationXfbBuffer: return "XfbBuffer"; -+ case DecorationXfbStride: return "XfbStride"; -+ case DecorationFuncParamAttr: return "FuncParamAttr"; -+ case DecorationFPRoundingMode: return "FPRoundingMode"; -+ case DecorationFPFastMathMode: return "FPFastMathMode"; -+ case DecorationLinkageAttributes: return "LinkageAttributes"; -+ case DecorationNoContraction: return "NoContraction"; -+ case DecorationInputAttachmentIndex: return "InputAttachmentIndex"; -+ case DecorationAlignment: return "Alignment"; -+ case DecorationMaxByteOffset: return "MaxByteOffset"; -+ case DecorationAlignmentId: return "AlignmentId"; -+ case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; -+ case DecorationNoSignedWrap: return "NoSignedWrap"; -+ case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; -+ case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; -+ case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; -+ case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; -+ case DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; -+ case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; -+ case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; -+ case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; -+ case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; -+ case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; -+ case DecorationPassthroughNV: return "PassthroughNV"; -+ case DecorationViewportRelativeNV: return "ViewportRelativeNV"; -+ case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; -+ case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; -+ case DecorationPerViewNV: return "PerViewNV"; -+ case DecorationPerTaskNV: return "PerTaskNV"; -+ case DecorationPerVertexKHR: return "PerVertexKHR"; -+ case DecorationNonUniform: return "NonUniform"; -+ case DecorationRestrictPointer: return "RestrictPointer"; -+ case DecorationAliasedPointer: return "AliasedPointer"; -+ case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; -+ case DecorationBindlessSamplerNV: return "BindlessSamplerNV"; -+ case DecorationBindlessImageNV: return "BindlessImageNV"; -+ case DecorationBoundSamplerNV: return "BoundSamplerNV"; -+ case DecorationBoundImageNV: return "BoundImageNV"; -+ case DecorationSIMTCallINTEL: return "SIMTCallINTEL"; -+ case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; -+ case DecorationClobberINTEL: return "ClobberINTEL"; -+ case DecorationSideEffectsINTEL: return "SideEffectsINTEL"; -+ case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; -+ case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; -+ case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; -+ case DecorationStackCallINTEL: return "StackCallINTEL"; -+ case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; -+ case DecorationCounterBuffer: return "CounterBuffer"; -+ case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; -+ case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; -+ case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; -+ case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; -+ case DecorationRegisterINTEL: return "RegisterINTEL"; -+ case DecorationMemoryINTEL: return "MemoryINTEL"; -+ case DecorationNumbanksINTEL: return "NumbanksINTEL"; -+ case DecorationBankwidthINTEL: return "BankwidthINTEL"; -+ case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; -+ case DecorationSinglepumpINTEL: return "SinglepumpINTEL"; -+ case DecorationDoublepumpINTEL: return "DoublepumpINTEL"; -+ case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; -+ case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; -+ case DecorationMergeINTEL: return "MergeINTEL"; -+ case DecorationBankBitsINTEL: return "BankBitsINTEL"; -+ case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; -+ case DecorationStridesizeINTEL: return "StridesizeINTEL"; -+ case DecorationWordsizeINTEL: return "WordsizeINTEL"; -+ case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; -+ case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; -+ case DecorationCacheSizeINTEL: return "CacheSizeINTEL"; -+ case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; -+ case DecorationPrefetchINTEL: return "PrefetchINTEL"; -+ case DecorationStallEnableINTEL: return "StallEnableINTEL"; -+ case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; -+ case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; -+ case DecorationAliasScopeINTEL: return "AliasScopeINTEL"; -+ case DecorationNoAliasINTEL: return "NoAliasINTEL"; -+ case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; -+ case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; -+ case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; -+ case DecorationBufferLocationINTEL: return "BufferLocationINTEL"; -+ case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; -+ case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; -+ case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; -+ case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; -+ case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; -+ case DecorationStallFreeINTEL: return "StallFreeINTEL"; -+ case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; -+ case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; -+ case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; -+ case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; -+ case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; -+ case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; -+ case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; -+ case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; -+ case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; -+ case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; -+ case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; -+ case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; -+ case DecorationHostAccessINTEL: return "HostAccessINTEL"; -+ case DecorationInitModeINTEL: return "InitModeINTEL"; -+ case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; -+ case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; -+ case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* BuiltInToString(BuiltIn value) { -+ switch (value) { -+ case BuiltInPosition: return "Position"; -+ case BuiltInPointSize: return "PointSize"; -+ case BuiltInClipDistance: return "ClipDistance"; -+ case BuiltInCullDistance: return "CullDistance"; -+ case BuiltInVertexId: return "VertexId"; -+ case BuiltInInstanceId: return "InstanceId"; -+ case BuiltInPrimitiveId: return "PrimitiveId"; -+ case BuiltInInvocationId: return "InvocationId"; -+ case BuiltInLayer: return "Layer"; -+ case BuiltInViewportIndex: return "ViewportIndex"; -+ case BuiltInTessLevelOuter: return "TessLevelOuter"; -+ case BuiltInTessLevelInner: return "TessLevelInner"; -+ case BuiltInTessCoord: return "TessCoord"; -+ case BuiltInPatchVertices: return "PatchVertices"; -+ case BuiltInFragCoord: return "FragCoord"; -+ case BuiltInPointCoord: return "PointCoord"; -+ case BuiltInFrontFacing: return "FrontFacing"; -+ case BuiltInSampleId: return "SampleId"; -+ case BuiltInSamplePosition: return "SamplePosition"; -+ case BuiltInSampleMask: return "SampleMask"; -+ case BuiltInFragDepth: return "FragDepth"; -+ case BuiltInHelperInvocation: return "HelperInvocation"; -+ case BuiltInNumWorkgroups: return "NumWorkgroups"; -+ case BuiltInWorkgroupSize: return "WorkgroupSize"; -+ case BuiltInWorkgroupId: return "WorkgroupId"; -+ case BuiltInLocalInvocationId: return "LocalInvocationId"; -+ case BuiltInGlobalInvocationId: return "GlobalInvocationId"; -+ case BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; -+ case BuiltInWorkDim: return "WorkDim"; -+ case BuiltInGlobalSize: return "GlobalSize"; -+ case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; -+ case BuiltInGlobalOffset: return "GlobalOffset"; -+ case BuiltInGlobalLinearId: return "GlobalLinearId"; -+ case BuiltInSubgroupSize: return "SubgroupSize"; -+ case BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; -+ case BuiltInNumSubgroups: return "NumSubgroups"; -+ case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; -+ case BuiltInSubgroupId: return "SubgroupId"; -+ case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; -+ case BuiltInVertexIndex: return "VertexIndex"; -+ case BuiltInInstanceIndex: return "InstanceIndex"; -+ case BuiltInCoreIDARM: return "CoreIDARM"; -+ case BuiltInCoreCountARM: return "CoreCountARM"; -+ case BuiltInCoreMaxIDARM: return "CoreMaxIDARM"; -+ case BuiltInWarpIDARM: return "WarpIDARM"; -+ case BuiltInWarpMaxIDARM: return "WarpMaxIDARM"; -+ case BuiltInSubgroupEqMask: return "SubgroupEqMask"; -+ case BuiltInSubgroupGeMask: return "SubgroupGeMask"; -+ case BuiltInSubgroupGtMask: return "SubgroupGtMask"; -+ case BuiltInSubgroupLeMask: return "SubgroupLeMask"; -+ case BuiltInSubgroupLtMask: return "SubgroupLtMask"; -+ case BuiltInBaseVertex: return "BaseVertex"; -+ case BuiltInBaseInstance: return "BaseInstance"; -+ case BuiltInDrawIndex: return "DrawIndex"; -+ case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; -+ case BuiltInDeviceIndex: return "DeviceIndex"; -+ case BuiltInViewIndex: return "ViewIndex"; -+ case BuiltInShadingRateKHR: return "ShadingRateKHR"; -+ case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; -+ case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; -+ case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; -+ case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; -+ case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; -+ case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; -+ case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; -+ case BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; -+ case BuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; -+ case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case BuiltInViewportMaskNV: return "ViewportMaskNV"; -+ case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; -+ case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; -+ case BuiltInPositionPerViewNV: return "PositionPerViewNV"; -+ case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; -+ case BuiltInFullyCoveredEXT: return "FullyCoveredEXT"; -+ case BuiltInTaskCountNV: return "TaskCountNV"; -+ case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; -+ case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; -+ case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; -+ case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; -+ case BuiltInLayerPerViewNV: return "LayerPerViewNV"; -+ case BuiltInMeshViewCountNV: return "MeshViewCountNV"; -+ case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; -+ case BuiltInBaryCoordKHR: return "BaryCoordKHR"; -+ case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; -+ case BuiltInFragSizeEXT: return "FragSizeEXT"; -+ case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; -+ case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; -+ case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; -+ case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; -+ case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; -+ case BuiltInLaunchIdKHR: return "LaunchIdKHR"; -+ case BuiltInLaunchSizeKHR: return "LaunchSizeKHR"; -+ case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; -+ case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; -+ case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; -+ case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; -+ case BuiltInRayTminKHR: return "RayTminKHR"; -+ case BuiltInRayTmaxKHR: return "RayTmaxKHR"; -+ case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; -+ case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; -+ case BuiltInWorldToObjectKHR: return "WorldToObjectKHR"; -+ case BuiltInHitTNV: return "HitTNV"; -+ case BuiltInHitKindKHR: return "HitKindKHR"; -+ case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; -+ case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; -+ case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; -+ case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; -+ case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; -+ case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; -+ case BuiltInWarpsPerSMNV: return "WarpsPerSMNV"; -+ case BuiltInSMCountNV: return "SMCountNV"; -+ case BuiltInWarpIDNV: return "WarpIDNV"; -+ case BuiltInSMIDNV: return "SMIDNV"; -+ case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; -+ case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; -+ case BuiltInCullMaskKHR: return "CullMaskKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ScopeToString(Scope value) { -+ switch (value) { -+ case ScopeCrossDevice: return "CrossDevice"; -+ case ScopeDevice: return "Device"; -+ case ScopeWorkgroup: return "Workgroup"; -+ case ScopeSubgroup: return "Subgroup"; -+ case ScopeInvocation: return "Invocation"; -+ case ScopeQueueFamily: return "QueueFamily"; -+ case ScopeShaderCallKHR: return "ShaderCallKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* GroupOperationToString(GroupOperation value) { -+ switch (value) { -+ case GroupOperationReduce: return "Reduce"; -+ case GroupOperationInclusiveScan: return "InclusiveScan"; -+ case GroupOperationExclusiveScan: return "ExclusiveScan"; -+ case GroupOperationClusteredReduce: return "ClusteredReduce"; -+ case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; -+ case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; -+ case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) { -+ switch (value) { -+ case KernelEnqueueFlagsNoWait: return "NoWait"; -+ case KernelEnqueueFlagsWaitKernel: return "WaitKernel"; -+ case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CapabilityToString(Capability value) { -+ switch (value) { -+ case CapabilityMatrix: return "Matrix"; -+ case CapabilityShader: return "Shader"; -+ case CapabilityGeometry: return "Geometry"; -+ case CapabilityTessellation: return "Tessellation"; -+ case CapabilityAddresses: return "Addresses"; -+ case CapabilityLinkage: return "Linkage"; -+ case CapabilityKernel: return "Kernel"; -+ case CapabilityVector16: return "Vector16"; -+ case CapabilityFloat16Buffer: return "Float16Buffer"; -+ case CapabilityFloat16: return "Float16"; -+ case CapabilityFloat64: return "Float64"; -+ case CapabilityInt64: return "Int64"; -+ case CapabilityInt64Atomics: return "Int64Atomics"; -+ case CapabilityImageBasic: return "ImageBasic"; -+ case CapabilityImageReadWrite: return "ImageReadWrite"; -+ case CapabilityImageMipmap: return "ImageMipmap"; -+ case CapabilityPipes: return "Pipes"; -+ case CapabilityGroups: return "Groups"; -+ case CapabilityDeviceEnqueue: return "DeviceEnqueue"; -+ case CapabilityLiteralSampler: return "LiteralSampler"; -+ case CapabilityAtomicStorage: return "AtomicStorage"; -+ case CapabilityInt16: return "Int16"; -+ case CapabilityTessellationPointSize: return "TessellationPointSize"; -+ case CapabilityGeometryPointSize: return "GeometryPointSize"; -+ case CapabilityImageGatherExtended: return "ImageGatherExtended"; -+ case CapabilityStorageImageMultisample: return "StorageImageMultisample"; -+ case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; -+ case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; -+ case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; -+ case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; -+ case CapabilityClipDistance: return "ClipDistance"; -+ case CapabilityCullDistance: return "CullDistance"; -+ case CapabilityImageCubeArray: return "ImageCubeArray"; -+ case CapabilitySampleRateShading: return "SampleRateShading"; -+ case CapabilityImageRect: return "ImageRect"; -+ case CapabilitySampledRect: return "SampledRect"; -+ case CapabilityGenericPointer: return "GenericPointer"; -+ case CapabilityInt8: return "Int8"; -+ case CapabilityInputAttachment: return "InputAttachment"; -+ case CapabilitySparseResidency: return "SparseResidency"; -+ case CapabilityMinLod: return "MinLod"; -+ case CapabilitySampled1D: return "Sampled1D"; -+ case CapabilityImage1D: return "Image1D"; -+ case CapabilitySampledCubeArray: return "SampledCubeArray"; -+ case CapabilitySampledBuffer: return "SampledBuffer"; -+ case CapabilityImageBuffer: return "ImageBuffer"; -+ case CapabilityImageMSArray: return "ImageMSArray"; -+ case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; -+ case CapabilityImageQuery: return "ImageQuery"; -+ case CapabilityDerivativeControl: return "DerivativeControl"; -+ case CapabilityInterpolationFunction: return "InterpolationFunction"; -+ case CapabilityTransformFeedback: return "TransformFeedback"; -+ case CapabilityGeometryStreams: return "GeometryStreams"; -+ case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; -+ case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; -+ case CapabilityMultiViewport: return "MultiViewport"; -+ case CapabilitySubgroupDispatch: return "SubgroupDispatch"; -+ case CapabilityNamedBarrier: return "NamedBarrier"; -+ case CapabilityPipeStorage: return "PipeStorage"; -+ case CapabilityGroupNonUniform: return "GroupNonUniform"; -+ case CapabilityGroupNonUniformVote: return "GroupNonUniformVote"; -+ case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; -+ case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; -+ case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; -+ case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; -+ case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; -+ case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; -+ case CapabilityShaderLayer: return "ShaderLayer"; -+ case CapabilityShaderViewportIndex: return "ShaderViewportIndex"; -+ case CapabilityUniformDecoration: return "UniformDecoration"; -+ case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; -+ case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; -+ case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; -+ case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; -+ case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; -+ case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; -+ case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; -+ case CapabilityDrawParameters: return "DrawParameters"; -+ case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; -+ case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; -+ case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; -+ case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; -+ case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; -+ case CapabilityStorageUniform16: return "StorageUniform16"; -+ case CapabilityStoragePushConstant16: return "StoragePushConstant16"; -+ case CapabilityStorageInputOutput16: return "StorageInputOutput16"; -+ case CapabilityDeviceGroup: return "DeviceGroup"; -+ case CapabilityMultiView: return "MultiView"; -+ case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; -+ case CapabilityVariablePointers: return "VariablePointers"; -+ case CapabilityAtomicStorageOps: return "AtomicStorageOps"; -+ case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; -+ case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; -+ case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; -+ case CapabilityStoragePushConstant8: return "StoragePushConstant8"; -+ case CapabilityDenormPreserve: return "DenormPreserve"; -+ case CapabilityDenormFlushToZero: return "DenormFlushToZero"; -+ case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case CapabilityRoundingModeRTE: return "RoundingModeRTE"; -+ case CapabilityRoundingModeRTZ: return "RoundingModeRTZ"; -+ case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; -+ case CapabilityRayQueryKHR: return "RayQueryKHR"; -+ case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; -+ case CapabilityRayTracingKHR: return "RayTracingKHR"; -+ case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; -+ case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; -+ case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; -+ case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; -+ case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; -+ case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; -+ case CapabilityFragmentMaskAMD: return "FragmentMaskAMD"; -+ case CapabilityStencilExportEXT: return "StencilExportEXT"; -+ case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; -+ case CapabilityInt64ImageEXT: return "Int64ImageEXT"; -+ case CapabilityShaderClockKHR: return "ShaderClockKHR"; -+ case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; -+ case CapabilityQuadControlKHR: return "QuadControlKHR"; -+ case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; -+ case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; -+ case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; -+ case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; -+ case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; -+ case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; -+ case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; -+ case CapabilityMeshShadingNV: return "MeshShadingNV"; -+ case CapabilityImageFootprintNV: return "ImageFootprintNV"; -+ case CapabilityMeshShadingEXT: return "MeshShadingEXT"; -+ case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; -+ case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; -+ case CapabilityFragmentDensityEXT: return "FragmentDensityEXT"; -+ case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; -+ case CapabilityShaderNonUniform: return "ShaderNonUniform"; -+ case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; -+ case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; -+ case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; -+ case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; -+ case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; -+ case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; -+ case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; -+ case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; -+ case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; -+ case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; -+ case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; -+ case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; -+ case CapabilityRayTracingNV: return "RayTracingNV"; -+ case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; -+ case CapabilityVulkanMemoryModel: return "VulkanMemoryModel"; -+ case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; -+ case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; -+ case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; -+ case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; -+ case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; -+ case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; -+ case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; -+ case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; -+ case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; -+ case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; -+ case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; -+ case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; -+ case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; -+ case CapabilityBindlessTextureNV: return "BindlessTextureNV"; -+ case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; -+ case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; -+ case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; -+ case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; -+ case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; -+ case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; -+ case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; -+ case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; -+ case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; -+ case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; -+ case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; -+ case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; -+ case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; -+ case CapabilityAsmINTEL: return "AsmINTEL"; -+ case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; -+ case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; -+ case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; -+ case CapabilityVectorComputeINTEL: return "VectorComputeINTEL"; -+ case CapabilityVectorAnyINTEL: return "VectorAnyINTEL"; -+ case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; -+ case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; -+ case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; -+ case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; -+ case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; -+ case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; -+ case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; -+ case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; -+ case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; -+ case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; -+ case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; -+ case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; -+ case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; -+ case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; -+ case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; -+ case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; -+ case CapabilityLoopFuseINTEL: return "LoopFuseINTEL"; -+ case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; -+ case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; -+ case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; -+ case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; -+ case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; -+ case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; -+ case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; -+ case CapabilityIOPipesINTEL: return "IOPipesINTEL"; -+ case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; -+ case CapabilityFPGARegINTEL: return "FPGARegINTEL"; -+ case CapabilityDotProductInputAll: return "DotProductInputAll"; -+ case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; -+ case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; -+ case CapabilityDotProduct: return "DotProduct"; -+ case CapabilityRayCullMaskKHR: return "RayCullMaskKHR"; -+ case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; -+ case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; -+ case CapabilityBitInstructions: return "BitInstructions"; -+ case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; -+ case CapabilityFloatControls2: return "FloatControls2"; -+ case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; -+ case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; -+ case CapabilityLongCompositesINTEL: return "LongCompositesINTEL"; -+ case CapabilityOptNoneINTEL: return "OptNoneINTEL"; -+ case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; -+ case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; -+ case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; -+ case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; -+ case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; -+ case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; -+ case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; -+ case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; -+ case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; -+ case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; -+ case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; -+ case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; -+ case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; -+ case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; -+ case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryIntersectionToString(RayQueryIntersection value) { -+ switch (value) { -+ case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; -+ case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) { -+ switch (value) { -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) { -+ switch (value) { -+ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; -+ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPDenormModeToString(FPDenormMode value) { -+ switch (value) { -+ case FPDenormModePreserve: return "Preserve"; -+ case FPDenormModeFlushToZero: return "FlushToZero"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPOperationModeToString(FPOperationMode value) { -+ switch (value) { -+ case FPOperationModeIEEE: return "IEEE"; -+ case FPOperationModeALT: return "ALT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* QuantizationModesToString(QuantizationModes value) { -+ switch (value) { -+ case QuantizationModesTRN: return "TRN"; -+ case QuantizationModesTRN_ZERO: return "TRN_ZERO"; -+ case QuantizationModesRND: return "RND"; -+ case QuantizationModesRND_ZERO: return "RND_ZERO"; -+ case QuantizationModesRND_INF: return "RND_INF"; -+ case QuantizationModesRND_MIN_INF: return "RND_MIN_INF"; -+ case QuantizationModesRND_CONV: return "RND_CONV"; -+ case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* OverflowModesToString(OverflowModes value) { -+ switch (value) { -+ case OverflowModesWRAP: return "WRAP"; -+ case OverflowModesSAT: return "SAT"; -+ case OverflowModesSAT_ZERO: return "SAT_ZERO"; -+ case OverflowModesSAT_SYM: return "SAT_SYM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* PackedVectorFormatToString(PackedVectorFormat value) { -+ switch (value) { -+ case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) { -+ switch (value) { -+ case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; -+ case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; -+ case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; -+ case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) { -+ switch (value) { -+ case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; -+ case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; -+ case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) { -+ switch (value) { -+ case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; -+ case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* HostAccessQualifierToString(HostAccessQualifier value) { -+ switch (value) { -+ case HostAccessQualifierNoneINTEL: return "NoneINTEL"; -+ case HostAccessQualifierReadINTEL: return "ReadINTEL"; -+ case HostAccessQualifierWriteINTEL: return "WriteINTEL"; -+ case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* LoadCacheControlToString(LoadCacheControl value) { -+ switch (value) { -+ case LoadCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case LoadCacheControlCachedINTEL: return "CachedINTEL"; -+ case LoadCacheControlStreamingINTEL: return "StreamingINTEL"; -+ case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; -+ case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* StoreCacheControlToString(StoreCacheControl value) { -+ switch (value) { -+ case StoreCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; -+ case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; -+ case StoreCacheControlStreamingINTEL: return "StreamingINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) { -+ switch (value) { -+ case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* OpToString(Op value) { -+ switch (value) { -+ case OpNop: return "OpNop"; -+ case OpUndef: return "OpUndef"; -+ case OpSourceContinued: return "OpSourceContinued"; -+ case OpSource: return "OpSource"; -+ case OpSourceExtension: return "OpSourceExtension"; -+ case OpName: return "OpName"; -+ case OpMemberName: return "OpMemberName"; -+ case OpString: return "OpString"; -+ case OpLine: return "OpLine"; -+ case OpExtension: return "OpExtension"; -+ case OpExtInstImport: return "OpExtInstImport"; -+ case OpExtInst: return "OpExtInst"; -+ case OpMemoryModel: return "OpMemoryModel"; -+ case OpEntryPoint: return "OpEntryPoint"; -+ case OpExecutionMode: return "OpExecutionMode"; -+ case OpCapability: return "OpCapability"; -+ case OpTypeVoid: return "OpTypeVoid"; -+ case OpTypeBool: return "OpTypeBool"; -+ case OpTypeInt: return "OpTypeInt"; -+ case OpTypeFloat: return "OpTypeFloat"; -+ case OpTypeVector: return "OpTypeVector"; -+ case OpTypeMatrix: return "OpTypeMatrix"; -+ case OpTypeImage: return "OpTypeImage"; -+ case OpTypeSampler: return "OpTypeSampler"; -+ case OpTypeSampledImage: return "OpTypeSampledImage"; -+ case OpTypeArray: return "OpTypeArray"; -+ case OpTypeRuntimeArray: return "OpTypeRuntimeArray"; -+ case OpTypeStruct: return "OpTypeStruct"; -+ case OpTypeOpaque: return "OpTypeOpaque"; -+ case OpTypePointer: return "OpTypePointer"; -+ case OpTypeFunction: return "OpTypeFunction"; -+ case OpTypeEvent: return "OpTypeEvent"; -+ case OpTypeDeviceEvent: return "OpTypeDeviceEvent"; -+ case OpTypeReserveId: return "OpTypeReserveId"; -+ case OpTypeQueue: return "OpTypeQueue"; -+ case OpTypePipe: return "OpTypePipe"; -+ case OpTypeForwardPointer: return "OpTypeForwardPointer"; -+ case OpConstantTrue: return "OpConstantTrue"; -+ case OpConstantFalse: return "OpConstantFalse"; -+ case OpConstant: return "OpConstant"; -+ case OpConstantComposite: return "OpConstantComposite"; -+ case OpConstantSampler: return "OpConstantSampler"; -+ case OpConstantNull: return "OpConstantNull"; -+ case OpSpecConstantTrue: return "OpSpecConstantTrue"; -+ case OpSpecConstantFalse: return "OpSpecConstantFalse"; -+ case OpSpecConstant: return "OpSpecConstant"; -+ case OpSpecConstantComposite: return "OpSpecConstantComposite"; -+ case OpSpecConstantOp: return "OpSpecConstantOp"; -+ case OpFunction: return "OpFunction"; -+ case OpFunctionParameter: return "OpFunctionParameter"; -+ case OpFunctionEnd: return "OpFunctionEnd"; -+ case OpFunctionCall: return "OpFunctionCall"; -+ case OpVariable: return "OpVariable"; -+ case OpImageTexelPointer: return "OpImageTexelPointer"; -+ case OpLoad: return "OpLoad"; -+ case OpStore: return "OpStore"; -+ case OpCopyMemory: return "OpCopyMemory"; -+ case OpCopyMemorySized: return "OpCopyMemorySized"; -+ case OpAccessChain: return "OpAccessChain"; -+ case OpInBoundsAccessChain: return "OpInBoundsAccessChain"; -+ case OpPtrAccessChain: return "OpPtrAccessChain"; -+ case OpArrayLength: return "OpArrayLength"; -+ case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; -+ case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; -+ case OpDecorate: return "OpDecorate"; -+ case OpMemberDecorate: return "OpMemberDecorate"; -+ case OpDecorationGroup: return "OpDecorationGroup"; -+ case OpGroupDecorate: return "OpGroupDecorate"; -+ case OpGroupMemberDecorate: return "OpGroupMemberDecorate"; -+ case OpVectorExtractDynamic: return "OpVectorExtractDynamic"; -+ case OpVectorInsertDynamic: return "OpVectorInsertDynamic"; -+ case OpVectorShuffle: return "OpVectorShuffle"; -+ case OpCompositeConstruct: return "OpCompositeConstruct"; -+ case OpCompositeExtract: return "OpCompositeExtract"; -+ case OpCompositeInsert: return "OpCompositeInsert"; -+ case OpCopyObject: return "OpCopyObject"; -+ case OpTranspose: return "OpTranspose"; -+ case OpSampledImage: return "OpSampledImage"; -+ case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; -+ case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; -+ case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; -+ case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; -+ case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; -+ case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; -+ case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; -+ case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; -+ case OpImageFetch: return "OpImageFetch"; -+ case OpImageGather: return "OpImageGather"; -+ case OpImageDrefGather: return "OpImageDrefGather"; -+ case OpImageRead: return "OpImageRead"; -+ case OpImageWrite: return "OpImageWrite"; -+ case OpImage: return "OpImage"; -+ case OpImageQueryFormat: return "OpImageQueryFormat"; -+ case OpImageQueryOrder: return "OpImageQueryOrder"; -+ case OpImageQuerySizeLod: return "OpImageQuerySizeLod"; -+ case OpImageQuerySize: return "OpImageQuerySize"; -+ case OpImageQueryLod: return "OpImageQueryLod"; -+ case OpImageQueryLevels: return "OpImageQueryLevels"; -+ case OpImageQuerySamples: return "OpImageQuerySamples"; -+ case OpConvertFToU: return "OpConvertFToU"; -+ case OpConvertFToS: return "OpConvertFToS"; -+ case OpConvertSToF: return "OpConvertSToF"; -+ case OpConvertUToF: return "OpConvertUToF"; -+ case OpUConvert: return "OpUConvert"; -+ case OpSConvert: return "OpSConvert"; -+ case OpFConvert: return "OpFConvert"; -+ case OpQuantizeToF16: return "OpQuantizeToF16"; -+ case OpConvertPtrToU: return "OpConvertPtrToU"; -+ case OpSatConvertSToU: return "OpSatConvertSToU"; -+ case OpSatConvertUToS: return "OpSatConvertUToS"; -+ case OpConvertUToPtr: return "OpConvertUToPtr"; -+ case OpPtrCastToGeneric: return "OpPtrCastToGeneric"; -+ case OpGenericCastToPtr: return "OpGenericCastToPtr"; -+ case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; -+ case OpBitcast: return "OpBitcast"; -+ case OpSNegate: return "OpSNegate"; -+ case OpFNegate: return "OpFNegate"; -+ case OpIAdd: return "OpIAdd"; -+ case OpFAdd: return "OpFAdd"; -+ case OpISub: return "OpISub"; -+ case OpFSub: return "OpFSub"; -+ case OpIMul: return "OpIMul"; -+ case OpFMul: return "OpFMul"; -+ case OpUDiv: return "OpUDiv"; -+ case OpSDiv: return "OpSDiv"; -+ case OpFDiv: return "OpFDiv"; -+ case OpUMod: return "OpUMod"; -+ case OpSRem: return "OpSRem"; -+ case OpSMod: return "OpSMod"; -+ case OpFRem: return "OpFRem"; -+ case OpFMod: return "OpFMod"; -+ case OpVectorTimesScalar: return "OpVectorTimesScalar"; -+ case OpMatrixTimesScalar: return "OpMatrixTimesScalar"; -+ case OpVectorTimesMatrix: return "OpVectorTimesMatrix"; -+ case OpMatrixTimesVector: return "OpMatrixTimesVector"; -+ case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; -+ case OpOuterProduct: return "OpOuterProduct"; -+ case OpDot: return "OpDot"; -+ case OpIAddCarry: return "OpIAddCarry"; -+ case OpISubBorrow: return "OpISubBorrow"; -+ case OpUMulExtended: return "OpUMulExtended"; -+ case OpSMulExtended: return "OpSMulExtended"; -+ case OpAny: return "OpAny"; -+ case OpAll: return "OpAll"; -+ case OpIsNan: return "OpIsNan"; -+ case OpIsInf: return "OpIsInf"; -+ case OpIsFinite: return "OpIsFinite"; -+ case OpIsNormal: return "OpIsNormal"; -+ case OpSignBitSet: return "OpSignBitSet"; -+ case OpLessOrGreater: return "OpLessOrGreater"; -+ case OpOrdered: return "OpOrdered"; -+ case OpUnordered: return "OpUnordered"; -+ case OpLogicalEqual: return "OpLogicalEqual"; -+ case OpLogicalNotEqual: return "OpLogicalNotEqual"; -+ case OpLogicalOr: return "OpLogicalOr"; -+ case OpLogicalAnd: return "OpLogicalAnd"; -+ case OpLogicalNot: return "OpLogicalNot"; -+ case OpSelect: return "OpSelect"; -+ case OpIEqual: return "OpIEqual"; -+ case OpINotEqual: return "OpINotEqual"; -+ case OpUGreaterThan: return "OpUGreaterThan"; -+ case OpSGreaterThan: return "OpSGreaterThan"; -+ case OpUGreaterThanEqual: return "OpUGreaterThanEqual"; -+ case OpSGreaterThanEqual: return "OpSGreaterThanEqual"; -+ case OpULessThan: return "OpULessThan"; -+ case OpSLessThan: return "OpSLessThan"; -+ case OpULessThanEqual: return "OpULessThanEqual"; -+ case OpSLessThanEqual: return "OpSLessThanEqual"; -+ case OpFOrdEqual: return "OpFOrdEqual"; -+ case OpFUnordEqual: return "OpFUnordEqual"; -+ case OpFOrdNotEqual: return "OpFOrdNotEqual"; -+ case OpFUnordNotEqual: return "OpFUnordNotEqual"; -+ case OpFOrdLessThan: return "OpFOrdLessThan"; -+ case OpFUnordLessThan: return "OpFUnordLessThan"; -+ case OpFOrdGreaterThan: return "OpFOrdGreaterThan"; -+ case OpFUnordGreaterThan: return "OpFUnordGreaterThan"; -+ case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; -+ case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; -+ case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; -+ case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; -+ case OpShiftRightLogical: return "OpShiftRightLogical"; -+ case OpShiftRightArithmetic: return "OpShiftRightArithmetic"; -+ case OpShiftLeftLogical: return "OpShiftLeftLogical"; -+ case OpBitwiseOr: return "OpBitwiseOr"; -+ case OpBitwiseXor: return "OpBitwiseXor"; -+ case OpBitwiseAnd: return "OpBitwiseAnd"; -+ case OpNot: return "OpNot"; -+ case OpBitFieldInsert: return "OpBitFieldInsert"; -+ case OpBitFieldSExtract: return "OpBitFieldSExtract"; -+ case OpBitFieldUExtract: return "OpBitFieldUExtract"; -+ case OpBitReverse: return "OpBitReverse"; -+ case OpBitCount: return "OpBitCount"; -+ case OpDPdx: return "OpDPdx"; -+ case OpDPdy: return "OpDPdy"; -+ case OpFwidth: return "OpFwidth"; -+ case OpDPdxFine: return "OpDPdxFine"; -+ case OpDPdyFine: return "OpDPdyFine"; -+ case OpFwidthFine: return "OpFwidthFine"; -+ case OpDPdxCoarse: return "OpDPdxCoarse"; -+ case OpDPdyCoarse: return "OpDPdyCoarse"; -+ case OpFwidthCoarse: return "OpFwidthCoarse"; -+ case OpEmitVertex: return "OpEmitVertex"; -+ case OpEndPrimitive: return "OpEndPrimitive"; -+ case OpEmitStreamVertex: return "OpEmitStreamVertex"; -+ case OpEndStreamPrimitive: return "OpEndStreamPrimitive"; -+ case OpControlBarrier: return "OpControlBarrier"; -+ case OpMemoryBarrier: return "OpMemoryBarrier"; -+ case OpAtomicLoad: return "OpAtomicLoad"; -+ case OpAtomicStore: return "OpAtomicStore"; -+ case OpAtomicExchange: return "OpAtomicExchange"; -+ case OpAtomicCompareExchange: return "OpAtomicCompareExchange"; -+ case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; -+ case OpAtomicIIncrement: return "OpAtomicIIncrement"; -+ case OpAtomicIDecrement: return "OpAtomicIDecrement"; -+ case OpAtomicIAdd: return "OpAtomicIAdd"; -+ case OpAtomicISub: return "OpAtomicISub"; -+ case OpAtomicSMin: return "OpAtomicSMin"; -+ case OpAtomicUMin: return "OpAtomicUMin"; -+ case OpAtomicSMax: return "OpAtomicSMax"; -+ case OpAtomicUMax: return "OpAtomicUMax"; -+ case OpAtomicAnd: return "OpAtomicAnd"; -+ case OpAtomicOr: return "OpAtomicOr"; -+ case OpAtomicXor: return "OpAtomicXor"; -+ case OpPhi: return "OpPhi"; -+ case OpLoopMerge: return "OpLoopMerge"; -+ case OpSelectionMerge: return "OpSelectionMerge"; -+ case OpLabel: return "OpLabel"; -+ case OpBranch: return "OpBranch"; -+ case OpBranchConditional: return "OpBranchConditional"; -+ case OpSwitch: return "OpSwitch"; -+ case OpKill: return "OpKill"; -+ case OpReturn: return "OpReturn"; -+ case OpReturnValue: return "OpReturnValue"; -+ case OpUnreachable: return "OpUnreachable"; -+ case OpLifetimeStart: return "OpLifetimeStart"; -+ case OpLifetimeStop: return "OpLifetimeStop"; -+ case OpGroupAsyncCopy: return "OpGroupAsyncCopy"; -+ case OpGroupWaitEvents: return "OpGroupWaitEvents"; -+ case OpGroupAll: return "OpGroupAll"; -+ case OpGroupAny: return "OpGroupAny"; -+ case OpGroupBroadcast: return "OpGroupBroadcast"; -+ case OpGroupIAdd: return "OpGroupIAdd"; -+ case OpGroupFAdd: return "OpGroupFAdd"; -+ case OpGroupFMin: return "OpGroupFMin"; -+ case OpGroupUMin: return "OpGroupUMin"; -+ case OpGroupSMin: return "OpGroupSMin"; -+ case OpGroupFMax: return "OpGroupFMax"; -+ case OpGroupUMax: return "OpGroupUMax"; -+ case OpGroupSMax: return "OpGroupSMax"; -+ case OpReadPipe: return "OpReadPipe"; -+ case OpWritePipe: return "OpWritePipe"; -+ case OpReservedReadPipe: return "OpReservedReadPipe"; -+ case OpReservedWritePipe: return "OpReservedWritePipe"; -+ case OpReserveReadPipePackets: return "OpReserveReadPipePackets"; -+ case OpReserveWritePipePackets: return "OpReserveWritePipePackets"; -+ case OpCommitReadPipe: return "OpCommitReadPipe"; -+ case OpCommitWritePipe: return "OpCommitWritePipe"; -+ case OpIsValidReserveId: return "OpIsValidReserveId"; -+ case OpGetNumPipePackets: return "OpGetNumPipePackets"; -+ case OpGetMaxPipePackets: return "OpGetMaxPipePackets"; -+ case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; -+ case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; -+ case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; -+ case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; -+ case OpEnqueueMarker: return "OpEnqueueMarker"; -+ case OpEnqueueKernel: return "OpEnqueueKernel"; -+ case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; -+ case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; -+ case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; -+ case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; -+ case OpRetainEvent: return "OpRetainEvent"; -+ case OpReleaseEvent: return "OpReleaseEvent"; -+ case OpCreateUserEvent: return "OpCreateUserEvent"; -+ case OpIsValidEvent: return "OpIsValidEvent"; -+ case OpSetUserEventStatus: return "OpSetUserEventStatus"; -+ case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; -+ case OpGetDefaultQueue: return "OpGetDefaultQueue"; -+ case OpBuildNDRange: return "OpBuildNDRange"; -+ case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; -+ case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; -+ case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; -+ case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; -+ case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; -+ case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; -+ case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; -+ case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; -+ case OpImageSparseFetch: return "OpImageSparseFetch"; -+ case OpImageSparseGather: return "OpImageSparseGather"; -+ case OpImageSparseDrefGather: return "OpImageSparseDrefGather"; -+ case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; -+ case OpNoLine: return "OpNoLine"; -+ case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; -+ case OpAtomicFlagClear: return "OpAtomicFlagClear"; -+ case OpImageSparseRead: return "OpImageSparseRead"; -+ case OpSizeOf: return "OpSizeOf"; -+ case OpTypePipeStorage: return "OpTypePipeStorage"; -+ case OpConstantPipeStorage: return "OpConstantPipeStorage"; -+ case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; -+ case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; -+ case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; -+ case OpTypeNamedBarrier: return "OpTypeNamedBarrier"; -+ case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; -+ case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; -+ case OpModuleProcessed: return "OpModuleProcessed"; -+ case OpExecutionModeId: return "OpExecutionModeId"; -+ case OpDecorateId: return "OpDecorateId"; -+ case OpGroupNonUniformElect: return "OpGroupNonUniformElect"; -+ case OpGroupNonUniformAll: return "OpGroupNonUniformAll"; -+ case OpGroupNonUniformAny: return "OpGroupNonUniformAny"; -+ case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; -+ case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; -+ case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; -+ case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; -+ case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; -+ case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; -+ case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; -+ case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; -+ case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; -+ case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; -+ case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; -+ case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; -+ case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; -+ case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; -+ case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; -+ case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; -+ case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; -+ case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; -+ case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; -+ case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; -+ case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; -+ case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; -+ case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; -+ case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; -+ case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; -+ case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; -+ case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; -+ case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; -+ case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; -+ case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; -+ case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; -+ case OpCopyLogical: return "OpCopyLogical"; -+ case OpPtrEqual: return "OpPtrEqual"; -+ case OpPtrNotEqual: return "OpPtrNotEqual"; -+ case OpPtrDiff: return "OpPtrDiff"; -+ case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; -+ case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; -+ case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; -+ case OpTerminateInvocation: return "OpTerminateInvocation"; -+ case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; -+ case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; -+ case OpSubgroupAllKHR: return "OpSubgroupAllKHR"; -+ case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; -+ case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; -+ case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; -+ case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; -+ case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; -+ case OpTraceRayKHR: return "OpTraceRayKHR"; -+ case OpExecuteCallableKHR: return "OpExecuteCallableKHR"; -+ case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; -+ case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; -+ case OpTerminateRayKHR: return "OpTerminateRayKHR"; -+ case OpSDot: return "OpSDot"; -+ case OpUDot: return "OpUDot"; -+ case OpSUDot: return "OpSUDot"; -+ case OpSDotAccSat: return "OpSDotAccSat"; -+ case OpUDotAccSat: return "OpUDotAccSat"; -+ case OpSUDotAccSat: return "OpSUDotAccSat"; -+ case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; -+ case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; -+ case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; -+ case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; -+ case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; -+ case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; -+ case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; -+ case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; -+ case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; -+ case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; -+ case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; -+ case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; -+ case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; -+ case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; -+ case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; -+ case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; -+ case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; -+ case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; -+ case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; -+ case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; -+ case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; -+ case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; -+ case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; -+ case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; -+ case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; -+ case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; -+ case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; -+ case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; -+ case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; -+ case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; -+ case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; -+ case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; -+ case OpFragmentFetchAMD: return "OpFragmentFetchAMD"; -+ case OpReadClockKHR: return "OpReadClockKHR"; -+ case OpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; -+ case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; -+ case OpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; -+ case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; -+ case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; -+ case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; -+ case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; -+ case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; -+ case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; -+ case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; -+ case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; -+ case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; -+ case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; -+ case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; -+ case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; -+ case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; -+ case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; -+ case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; -+ case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; -+ case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; -+ case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; -+ case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; -+ case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; -+ case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; -+ case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; -+ case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; -+ case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; -+ case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; -+ case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; -+ case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; -+ case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; -+ case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; -+ case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; -+ case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; -+ case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; -+ case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; -+ case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; -+ case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; -+ case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; -+ case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; -+ case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; -+ case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; -+ case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; -+ case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; -+ case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; -+ case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; -+ case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; -+ case OpTerminateRayNV: return "OpTerminateRayNV"; -+ case OpTraceNV: return "OpTraceNV"; -+ case OpTraceMotionNV: return "OpTraceMotionNV"; -+ case OpTraceRayMotionNV: return "OpTraceRayMotionNV"; -+ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; -+ case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; -+ case OpExecuteCallableNV: return "OpExecuteCallableNV"; -+ case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; -+ case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; -+ case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; -+ case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; -+ case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; -+ case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; -+ case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; -+ case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; -+ case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; -+ case OpConvertUToImageNV: return "OpConvertUToImageNV"; -+ case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; -+ case OpConvertImageToUNV: return "OpConvertImageToUNV"; -+ case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; -+ case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; -+ case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; -+ case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; -+ case OpRawAccessChainNV: return "OpRawAccessChainNV"; -+ case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; -+ case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; -+ case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; -+ case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; -+ case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; -+ case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; -+ case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; -+ case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; -+ case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; -+ case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; -+ case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; -+ case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; -+ case OpAbsISubINTEL: return "OpAbsISubINTEL"; -+ case OpAbsUSubINTEL: return "OpAbsUSubINTEL"; -+ case OpIAddSatINTEL: return "OpIAddSatINTEL"; -+ case OpUAddSatINTEL: return "OpUAddSatINTEL"; -+ case OpIAverageINTEL: return "OpIAverageINTEL"; -+ case OpUAverageINTEL: return "OpUAverageINTEL"; -+ case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; -+ case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; -+ case OpISubSatINTEL: return "OpISubSatINTEL"; -+ case OpUSubSatINTEL: return "OpUSubSatINTEL"; -+ case OpIMul32x16INTEL: return "OpIMul32x16INTEL"; -+ case OpUMul32x16INTEL: return "OpUMul32x16INTEL"; -+ case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; -+ case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; -+ case OpAsmTargetINTEL: return "OpAsmTargetINTEL"; -+ case OpAsmINTEL: return "OpAsmINTEL"; -+ case OpAsmCallINTEL: return "OpAsmCallINTEL"; -+ case OpAtomicFMinEXT: return "OpAtomicFMinEXT"; -+ case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; -+ case OpAssumeTrueKHR: return "OpAssumeTrueKHR"; -+ case OpExpectKHR: return "OpExpectKHR"; -+ case OpDecorateString: return "OpDecorateString"; -+ case OpMemberDecorateString: return "OpMemberDecorateString"; -+ case OpVmeImageINTEL: return "OpVmeImageINTEL"; -+ case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; -+ case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; -+ case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; -+ case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; -+ case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; -+ case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; -+ case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; -+ case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; -+ case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; -+ case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; -+ case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; -+ case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; -+ case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; -+ case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; -+ case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; -+ case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; -+ case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; -+ case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; -+ case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; -+ case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; -+ case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; -+ case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; -+ case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; -+ case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; -+ case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; -+ case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; -+ case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; -+ case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; -+ case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; -+ case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; -+ case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; -+ case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; -+ case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; -+ case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; -+ case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; -+ case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; -+ case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; -+ case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; -+ case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; -+ case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; -+ case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; -+ case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; -+ case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; -+ case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; -+ case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; -+ case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; -+ case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; -+ case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; -+ case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; -+ case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; -+ case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; -+ case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; -+ case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; -+ case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; -+ case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; -+ case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; -+ case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; -+ case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; -+ case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; -+ case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; -+ case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; -+ case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; -+ case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; -+ case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; -+ case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; -+ case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; -+ case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; -+ case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; -+ case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; -+ case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; -+ case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; -+ case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; -+ case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; -+ case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; -+ case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; -+ case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; -+ case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; -+ case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; -+ case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; -+ case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; -+ case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; -+ case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; -+ case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; -+ case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; -+ case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; -+ case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; -+ case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; -+ case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; -+ case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; -+ case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; -+ case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; -+ case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; -+ case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; -+ case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; -+ case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; -+ case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; -+ case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; -+ case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; -+ case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; -+ case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; -+ case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; -+ case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; -+ case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; -+ case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; -+ case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; -+ case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; -+ case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; -+ case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; -+ case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; -+ case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; -+ case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; -+ case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; -+ case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; -+ case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; -+ case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; -+ case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; -+ case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; -+ case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; -+ case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; -+ case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; -+ case OpLoopControlINTEL: return "OpLoopControlINTEL"; -+ case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; -+ case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; -+ case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; -+ case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; -+ case OpFixedRecipINTEL: return "OpFixedRecipINTEL"; -+ case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; -+ case OpFixedSinINTEL: return "OpFixedSinINTEL"; -+ case OpFixedCosINTEL: return "OpFixedCosINTEL"; -+ case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; -+ case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; -+ case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; -+ case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; -+ case OpFixedLogINTEL: return "OpFixedLogINTEL"; -+ case OpFixedExpINTEL: return "OpFixedExpINTEL"; -+ case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; -+ case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; -+ case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; -+ case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; -+ case OpFPGARegINTEL: return "OpFPGARegINTEL"; -+ case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; -+ case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; -+ case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; -+ case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; -+ case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; -+ case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; -+ case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; -+ case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; -+ case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; -+ case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; -+ case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; -+ case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; -+ case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; -+ case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; -+ case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; -+ case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; -+ case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; -+ case OpAtomicFAddEXT: return "OpAtomicFAddEXT"; -+ case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; -+ case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; -+ case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; -+ case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; -+ case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; -+ case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; -+ case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; -+ case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; -+ case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; -+ case OpGroupIMulKHR: return "OpGroupIMulKHR"; -+ case OpGroupFMulKHR: return "OpGroupFMulKHR"; -+ case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; -+ case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; -+ case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; -+ case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; -+ case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; -+ case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; -+ case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; -+ case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; -+ default: return "Unknown"; -+ } -+} -+ - #endif /* SPV_ENABLE_UTILITY_CODE */ - - // Overload bitwise operators for mask bit combining -diff --git include/spirv/unified1/spirv.hpp11 include/spirv/unified1/spirv.hpp11 -index d6b4fb7..25177a4 100644 ---- include/spirv/unified1/spirv.hpp11 -+++ include/spirv/unified1/spirv.hpp11 -@@ -1045,6 +1045,7 @@ enum class Capability : unsigned { - TileImageColorReadAccessEXT = 4166, - TileImageDepthReadAccessEXT = 4167, - TileImageStencilReadAccessEXT = 4168, -+ CooperativeMatrixLayoutsARM = 4201, - FragmentShadingRateKHR = 4422, - SubgroupBallotKHR = 4423, - DrawParameters = 4427, -@@ -1208,6 +1209,7 @@ enum class Capability : unsigned { - DotProductKHR = 6019, - RayCullMaskKHR = 6020, - CooperativeMatrixKHR = 6022, -+ ReplicatedCompositesEXT = 6024, - BitInstructions = 6025, - GroupNonUniformRotateKHR = 6026, - FloatControls2 = 6029, -@@ -1357,6 +1359,8 @@ enum class CooperativeMatrixOperandsMask : unsigned { - enum class CooperativeMatrixLayout : unsigned { - RowMajorKHR = 0, - ColumnMajorKHR = 1, -+ RowBlockedInterleavedARM = 4202, -+ ColumnBlockedInterleavedARM = 4203, - Max = 0x7fffffff, - }; - -@@ -1771,6 +1775,7 @@ enum class Op : unsigned { - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1793,6 +1798,9 @@ enum class Op : unsigned { - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -@@ -2515,6 +2523,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; - case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; - case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; -+ case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; - case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break; - case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; - case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; -@@ -2531,6 +2540,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case Op::OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; - case Op::OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; - case Op::OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; -+ case Op::OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case Op::OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break; -+ case Op::OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break; - case Op::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; - case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; - case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; -@@ -2602,14 +2614,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case Op::OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; - case Op::OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break; - case Op::OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break; -- case Op::OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; -+ case Op::OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break; - case Op::OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; - case Op::OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; - case Op::OpTraceNV: *hasResult = false; *hasResultType = false; break; - case Op::OpTraceMotionNV: *hasResult = false; *hasResultType = false; break; - case Op::OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break; - case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; -- case Op::OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; -+ case Op::OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; - case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; - case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; -@@ -2884,6 +2896,1787 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - case Op::OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; - } - } -+inline const char* SourceLanguageToString(SourceLanguage value) { -+ switch (value) { -+ case SourceLanguageUnknown: return "Unknown"; -+ case SourceLanguageESSL: return "ESSL"; -+ case SourceLanguageGLSL: return "GLSL"; -+ case SourceLanguageOpenCL_C: return "OpenCL_C"; -+ case SourceLanguageOpenCL_CPP: return "OpenCL_CPP"; -+ case SourceLanguageHLSL: return "HLSL"; -+ case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL"; -+ case SourceLanguageSYCL: return "SYCL"; -+ case SourceLanguageHERO_C: return "HERO_C"; -+ case SourceLanguageNZSL: return "NZSL"; -+ case SourceLanguageWGSL: return "WGSL"; -+ case SourceLanguageSlang: return "Slang"; -+ case SourceLanguageZig: return "Zig"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ExecutionModelToString(ExecutionModel value) { -+ switch (value) { -+ case ExecutionModelVertex: return "Vertex"; -+ case ExecutionModelTessellationControl: return "TessellationControl"; -+ case ExecutionModelTessellationEvaluation: return "TessellationEvaluation"; -+ case ExecutionModelGeometry: return "Geometry"; -+ case ExecutionModelFragment: return "Fragment"; -+ case ExecutionModelGLCompute: return "GLCompute"; -+ case ExecutionModelKernel: return "Kernel"; -+ case ExecutionModelTaskNV: return "TaskNV"; -+ case ExecutionModelMeshNV: return "MeshNV"; -+ case ExecutionModelRayGenerationKHR: return "RayGenerationKHR"; -+ case ExecutionModelIntersectionKHR: return "IntersectionKHR"; -+ case ExecutionModelAnyHitKHR: return "AnyHitKHR"; -+ case ExecutionModelClosestHitKHR: return "ClosestHitKHR"; -+ case ExecutionModelMissKHR: return "MissKHR"; -+ case ExecutionModelCallableKHR: return "CallableKHR"; -+ case ExecutionModelTaskEXT: return "TaskEXT"; -+ case ExecutionModelMeshEXT: return "MeshEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* AddressingModelToString(AddressingModel value) { -+ switch (value) { -+ case AddressingModelLogical: return "Logical"; -+ case AddressingModelPhysical32: return "Physical32"; -+ case AddressingModelPhysical64: return "Physical64"; -+ case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* MemoryModelToString(MemoryModel value) { -+ switch (value) { -+ case MemoryModelSimple: return "Simple"; -+ case MemoryModelGLSL450: return "GLSL450"; -+ case MemoryModelOpenCL: return "OpenCL"; -+ case MemoryModelVulkan: return "Vulkan"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ExecutionModeToString(ExecutionMode value) { -+ switch (value) { -+ case ExecutionModeInvocations: return "Invocations"; -+ case ExecutionModeSpacingEqual: return "SpacingEqual"; -+ case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; -+ case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; -+ case ExecutionModeVertexOrderCw: return "VertexOrderCw"; -+ case ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; -+ case ExecutionModePixelCenterInteger: return "PixelCenterInteger"; -+ case ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; -+ case ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; -+ case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; -+ case ExecutionModePointMode: return "PointMode"; -+ case ExecutionModeXfb: return "Xfb"; -+ case ExecutionModeDepthReplacing: return "DepthReplacing"; -+ case ExecutionModeDepthGreater: return "DepthGreater"; -+ case ExecutionModeDepthLess: return "DepthLess"; -+ case ExecutionModeDepthUnchanged: return "DepthUnchanged"; -+ case ExecutionModeLocalSize: return "LocalSize"; -+ case ExecutionModeLocalSizeHint: return "LocalSizeHint"; -+ case ExecutionModeInputPoints: return "InputPoints"; -+ case ExecutionModeInputLines: return "InputLines"; -+ case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; -+ case ExecutionModeTriangles: return "Triangles"; -+ case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; -+ case ExecutionModeQuads: return "Quads"; -+ case ExecutionModeIsolines: return "Isolines"; -+ case ExecutionModeOutputVertices: return "OutputVertices"; -+ case ExecutionModeOutputPoints: return "OutputPoints"; -+ case ExecutionModeOutputLineStrip: return "OutputLineStrip"; -+ case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; -+ case ExecutionModeVecTypeHint: return "VecTypeHint"; -+ case ExecutionModeContractionOff: return "ContractionOff"; -+ case ExecutionModeInitializer: return "Initializer"; -+ case ExecutionModeFinalizer: return "Finalizer"; -+ case ExecutionModeSubgroupSize: return "SubgroupSize"; -+ case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup"; -+ case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId"; -+ case ExecutionModeLocalSizeId: return "LocalSizeId"; -+ case ExecutionModeLocalSizeHintId: return "LocalSizeHintId"; -+ case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT"; -+ case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT"; -+ case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT"; -+ case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR"; -+ case ExecutionModePostDepthCoverage: return "PostDepthCoverage"; -+ case ExecutionModeDenormPreserve: return "DenormPreserve"; -+ case ExecutionModeDenormFlushToZero: return "DenormFlushToZero"; -+ case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; -+ case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; -+ case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; -+ case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; -+ case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; -+ case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX"; -+ case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX"; -+ case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX"; -+ case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD"; -+ case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD"; -+ case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD"; -+ case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD"; -+ case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD"; -+ case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD"; -+ case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR"; -+ case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR"; -+ case ExecutionModeOutputLinesEXT: return "OutputLinesEXT"; -+ case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT"; -+ case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV"; -+ case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV"; -+ case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT"; -+ case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT"; -+ case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT"; -+ case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT"; -+ case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT"; -+ case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT"; -+ case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT"; -+ case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL"; -+ case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL"; -+ case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL"; -+ case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL"; -+ case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL"; -+ case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL"; -+ case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL"; -+ case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL"; -+ case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL"; -+ case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL"; -+ case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR"; -+ case ExecutionModeFPFastMathDefault: return "FPFastMathDefault"; -+ case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL"; -+ case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL"; -+ case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL"; -+ case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL"; -+ case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL"; -+ case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* StorageClassToString(StorageClass value) { -+ switch (value) { -+ case StorageClassUniformConstant: return "UniformConstant"; -+ case StorageClassInput: return "Input"; -+ case StorageClassUniform: return "Uniform"; -+ case StorageClassOutput: return "Output"; -+ case StorageClassWorkgroup: return "Workgroup"; -+ case StorageClassCrossWorkgroup: return "CrossWorkgroup"; -+ case StorageClassPrivate: return "Private"; -+ case StorageClassFunction: return "Function"; -+ case StorageClassGeneric: return "Generic"; -+ case StorageClassPushConstant: return "PushConstant"; -+ case StorageClassAtomicCounter: return "AtomicCounter"; -+ case StorageClassImage: return "Image"; -+ case StorageClassStorageBuffer: return "StorageBuffer"; -+ case StorageClassTileImageEXT: return "TileImageEXT"; -+ case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; -+ case StorageClassNodeOutputPayloadAMDX: return "NodeOutputPayloadAMDX"; -+ case StorageClassCallableDataKHR: return "CallableDataKHR"; -+ case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; -+ case StorageClassRayPayloadKHR: return "RayPayloadKHR"; -+ case StorageClassHitAttributeKHR: return "HitAttributeKHR"; -+ case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR"; -+ case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR"; -+ case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer"; -+ case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV"; -+ case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; -+ case StorageClassCodeSectionINTEL: return "CodeSectionINTEL"; -+ case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL"; -+ case StorageClassHostOnlyINTEL: return "HostOnlyINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* DimToString(Dim value) { -+ switch (value) { -+ case Dim1D: return "1D"; -+ case Dim2D: return "2D"; -+ case Dim3D: return "3D"; -+ case DimCube: return "Cube"; -+ case DimRect: return "Rect"; -+ case DimBuffer: return "Buffer"; -+ case DimSubpassData: return "SubpassData"; -+ case DimTileImageDataEXT: return "TileImageDataEXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) { -+ switch (value) { -+ case SamplerAddressingModeNone: return "None"; -+ case SamplerAddressingModeClampToEdge: return "ClampToEdge"; -+ case SamplerAddressingModeClamp: return "Clamp"; -+ case SamplerAddressingModeRepeat: return "Repeat"; -+ case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* SamplerFilterModeToString(SamplerFilterMode value) { -+ switch (value) { -+ case SamplerFilterModeNearest: return "Nearest"; -+ case SamplerFilterModeLinear: return "Linear"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageFormatToString(ImageFormat value) { -+ switch (value) { -+ case ImageFormatUnknown: return "Unknown"; -+ case ImageFormatRgba32f: return "Rgba32f"; -+ case ImageFormatRgba16f: return "Rgba16f"; -+ case ImageFormatR32f: return "R32f"; -+ case ImageFormatRgba8: return "Rgba8"; -+ case ImageFormatRgba8Snorm: return "Rgba8Snorm"; -+ case ImageFormatRg32f: return "Rg32f"; -+ case ImageFormatRg16f: return "Rg16f"; -+ case ImageFormatR11fG11fB10f: return "R11fG11fB10f"; -+ case ImageFormatR16f: return "R16f"; -+ case ImageFormatRgba16: return "Rgba16"; -+ case ImageFormatRgb10A2: return "Rgb10A2"; -+ case ImageFormatRg16: return "Rg16"; -+ case ImageFormatRg8: return "Rg8"; -+ case ImageFormatR16: return "R16"; -+ case ImageFormatR8: return "R8"; -+ case ImageFormatRgba16Snorm: return "Rgba16Snorm"; -+ case ImageFormatRg16Snorm: return "Rg16Snorm"; -+ case ImageFormatRg8Snorm: return "Rg8Snorm"; -+ case ImageFormatR16Snorm: return "R16Snorm"; -+ case ImageFormatR8Snorm: return "R8Snorm"; -+ case ImageFormatRgba32i: return "Rgba32i"; -+ case ImageFormatRgba16i: return "Rgba16i"; -+ case ImageFormatRgba8i: return "Rgba8i"; -+ case ImageFormatR32i: return "R32i"; -+ case ImageFormatRg32i: return "Rg32i"; -+ case ImageFormatRg16i: return "Rg16i"; -+ case ImageFormatRg8i: return "Rg8i"; -+ case ImageFormatR16i: return "R16i"; -+ case ImageFormatR8i: return "R8i"; -+ case ImageFormatRgba32ui: return "Rgba32ui"; -+ case ImageFormatRgba16ui: return "Rgba16ui"; -+ case ImageFormatRgba8ui: return "Rgba8ui"; -+ case ImageFormatR32ui: return "R32ui"; -+ case ImageFormatRgb10a2ui: return "Rgb10a2ui"; -+ case ImageFormatRg32ui: return "Rg32ui"; -+ case ImageFormatRg16ui: return "Rg16ui"; -+ case ImageFormatRg8ui: return "Rg8ui"; -+ case ImageFormatR16ui: return "R16ui"; -+ case ImageFormatR8ui: return "R8ui"; -+ case ImageFormatR64ui: return "R64ui"; -+ case ImageFormatR64i: return "R64i"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageChannelOrderToString(ImageChannelOrder value) { -+ switch (value) { -+ case ImageChannelOrderR: return "R"; -+ case ImageChannelOrderA: return "A"; -+ case ImageChannelOrderRG: return "RG"; -+ case ImageChannelOrderRA: return "RA"; -+ case ImageChannelOrderRGB: return "RGB"; -+ case ImageChannelOrderRGBA: return "RGBA"; -+ case ImageChannelOrderBGRA: return "BGRA"; -+ case ImageChannelOrderARGB: return "ARGB"; -+ case ImageChannelOrderIntensity: return "Intensity"; -+ case ImageChannelOrderLuminance: return "Luminance"; -+ case ImageChannelOrderRx: return "Rx"; -+ case ImageChannelOrderRGx: return "RGx"; -+ case ImageChannelOrderRGBx: return "RGBx"; -+ case ImageChannelOrderDepth: return "Depth"; -+ case ImageChannelOrderDepthStencil: return "DepthStencil"; -+ case ImageChannelOrdersRGB: return "sRGB"; -+ case ImageChannelOrdersRGBx: return "sRGBx"; -+ case ImageChannelOrdersRGBA: return "sRGBA"; -+ case ImageChannelOrdersBGRA: return "sBGRA"; -+ case ImageChannelOrderABGR: return "ABGR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) { -+ switch (value) { -+ case ImageChannelDataTypeSnormInt8: return "SnormInt8"; -+ case ImageChannelDataTypeSnormInt16: return "SnormInt16"; -+ case ImageChannelDataTypeUnormInt8: return "UnormInt8"; -+ case ImageChannelDataTypeUnormInt16: return "UnormInt16"; -+ case ImageChannelDataTypeUnormShort565: return "UnormShort565"; -+ case ImageChannelDataTypeUnormShort555: return "UnormShort555"; -+ case ImageChannelDataTypeUnormInt101010: return "UnormInt101010"; -+ case ImageChannelDataTypeSignedInt8: return "SignedInt8"; -+ case ImageChannelDataTypeSignedInt16: return "SignedInt16"; -+ case ImageChannelDataTypeSignedInt32: return "SignedInt32"; -+ case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8"; -+ case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16"; -+ case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32"; -+ case ImageChannelDataTypeHalfFloat: return "HalfFloat"; -+ case ImageChannelDataTypeFloat: return "Float"; -+ case ImageChannelDataTypeUnormInt24: return "UnormInt24"; -+ case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2"; -+ case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT"; -+ case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPRoundingModeToString(FPRoundingMode value) { -+ switch (value) { -+ case FPRoundingModeRTE: return "RTE"; -+ case FPRoundingModeRTZ: return "RTZ"; -+ case FPRoundingModeRTP: return "RTP"; -+ case FPRoundingModeRTN: return "RTN"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* LinkageTypeToString(LinkageType value) { -+ switch (value) { -+ case LinkageTypeExport: return "Export"; -+ case LinkageTypeImport: return "Import"; -+ case LinkageTypeLinkOnceODR: return "LinkOnceODR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* AccessQualifierToString(AccessQualifier value) { -+ switch (value) { -+ case AccessQualifierReadOnly: return "ReadOnly"; -+ case AccessQualifierWriteOnly: return "WriteOnly"; -+ case AccessQualifierReadWrite: return "ReadWrite"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) { -+ switch (value) { -+ case FunctionParameterAttributeZext: return "Zext"; -+ case FunctionParameterAttributeSext: return "Sext"; -+ case FunctionParameterAttributeByVal: return "ByVal"; -+ case FunctionParameterAttributeSret: return "Sret"; -+ case FunctionParameterAttributeNoAlias: return "NoAlias"; -+ case FunctionParameterAttributeNoCapture: return "NoCapture"; -+ case FunctionParameterAttributeNoWrite: return "NoWrite"; -+ case FunctionParameterAttributeNoReadWrite: return "NoReadWrite"; -+ case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* DecorationToString(Decoration value) { -+ switch (value) { -+ case DecorationRelaxedPrecision: return "RelaxedPrecision"; -+ case DecorationSpecId: return "SpecId"; -+ case DecorationBlock: return "Block"; -+ case DecorationBufferBlock: return "BufferBlock"; -+ case DecorationRowMajor: return "RowMajor"; -+ case DecorationColMajor: return "ColMajor"; -+ case DecorationArrayStride: return "ArrayStride"; -+ case DecorationMatrixStride: return "MatrixStride"; -+ case DecorationGLSLShared: return "GLSLShared"; -+ case DecorationGLSLPacked: return "GLSLPacked"; -+ case DecorationCPacked: return "CPacked"; -+ case DecorationBuiltIn: return "BuiltIn"; -+ case DecorationNoPerspective: return "NoPerspective"; -+ case DecorationFlat: return "Flat"; -+ case DecorationPatch: return "Patch"; -+ case DecorationCentroid: return "Centroid"; -+ case DecorationSample: return "Sample"; -+ case DecorationInvariant: return "Invariant"; -+ case DecorationRestrict: return "Restrict"; -+ case DecorationAliased: return "Aliased"; -+ case DecorationVolatile: return "Volatile"; -+ case DecorationConstant: return "Constant"; -+ case DecorationCoherent: return "Coherent"; -+ case DecorationNonWritable: return "NonWritable"; -+ case DecorationNonReadable: return "NonReadable"; -+ case DecorationUniform: return "Uniform"; -+ case DecorationUniformId: return "UniformId"; -+ case DecorationSaturatedConversion: return "SaturatedConversion"; -+ case DecorationStream: return "Stream"; -+ case DecorationLocation: return "Location"; -+ case DecorationComponent: return "Component"; -+ case DecorationIndex: return "Index"; -+ case DecorationBinding: return "Binding"; -+ case DecorationDescriptorSet: return "DescriptorSet"; -+ case DecorationOffset: return "Offset"; -+ case DecorationXfbBuffer: return "XfbBuffer"; -+ case DecorationXfbStride: return "XfbStride"; -+ case DecorationFuncParamAttr: return "FuncParamAttr"; -+ case DecorationFPRoundingMode: return "FPRoundingMode"; -+ case DecorationFPFastMathMode: return "FPFastMathMode"; -+ case DecorationLinkageAttributes: return "LinkageAttributes"; -+ case DecorationNoContraction: return "NoContraction"; -+ case DecorationInputAttachmentIndex: return "InputAttachmentIndex"; -+ case DecorationAlignment: return "Alignment"; -+ case DecorationMaxByteOffset: return "MaxByteOffset"; -+ case DecorationAlignmentId: return "AlignmentId"; -+ case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; -+ case DecorationNoSignedWrap: return "NoSignedWrap"; -+ case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; -+ case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; -+ case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM"; -+ case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM"; -+ case DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; -+ case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX"; -+ case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX"; -+ case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX"; -+ case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX"; -+ case DecorationOverrideCoverageNV: return "OverrideCoverageNV"; -+ case DecorationPassthroughNV: return "PassthroughNV"; -+ case DecorationViewportRelativeNV: return "ViewportRelativeNV"; -+ case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; -+ case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT"; -+ case DecorationPerViewNV: return "PerViewNV"; -+ case DecorationPerTaskNV: return "PerTaskNV"; -+ case DecorationPerVertexKHR: return "PerVertexKHR"; -+ case DecorationNonUniform: return "NonUniform"; -+ case DecorationRestrictPointer: return "RestrictPointer"; -+ case DecorationAliasedPointer: return "AliasedPointer"; -+ case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV"; -+ case DecorationBindlessSamplerNV: return "BindlessSamplerNV"; -+ case DecorationBindlessImageNV: return "BindlessImageNV"; -+ case DecorationBoundSamplerNV: return "BoundSamplerNV"; -+ case DecorationBoundImageNV: return "BoundImageNV"; -+ case DecorationSIMTCallINTEL: return "SIMTCallINTEL"; -+ case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL"; -+ case DecorationClobberINTEL: return "ClobberINTEL"; -+ case DecorationSideEffectsINTEL: return "SideEffectsINTEL"; -+ case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL"; -+ case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL"; -+ case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL"; -+ case DecorationStackCallINTEL: return "StackCallINTEL"; -+ case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL"; -+ case DecorationCounterBuffer: return "CounterBuffer"; -+ case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE"; -+ case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE"; -+ case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL"; -+ case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL"; -+ case DecorationRegisterINTEL: return "RegisterINTEL"; -+ case DecorationMemoryINTEL: return "MemoryINTEL"; -+ case DecorationNumbanksINTEL: return "NumbanksINTEL"; -+ case DecorationBankwidthINTEL: return "BankwidthINTEL"; -+ case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL"; -+ case DecorationSinglepumpINTEL: return "SinglepumpINTEL"; -+ case DecorationDoublepumpINTEL: return "DoublepumpINTEL"; -+ case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL"; -+ case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL"; -+ case DecorationMergeINTEL: return "MergeINTEL"; -+ case DecorationBankBitsINTEL: return "BankBitsINTEL"; -+ case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL"; -+ case DecorationStridesizeINTEL: return "StridesizeINTEL"; -+ case DecorationWordsizeINTEL: return "WordsizeINTEL"; -+ case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL"; -+ case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL"; -+ case DecorationCacheSizeINTEL: return "CacheSizeINTEL"; -+ case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL"; -+ case DecorationPrefetchINTEL: return "PrefetchINTEL"; -+ case DecorationStallEnableINTEL: return "StallEnableINTEL"; -+ case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL"; -+ case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL"; -+ case DecorationAliasScopeINTEL: return "AliasScopeINTEL"; -+ case DecorationNoAliasINTEL: return "NoAliasINTEL"; -+ case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL"; -+ case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL"; -+ case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL"; -+ case DecorationBufferLocationINTEL: return "BufferLocationINTEL"; -+ case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL"; -+ case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL"; -+ case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL"; -+ case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL"; -+ case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL"; -+ case DecorationStallFreeINTEL: return "StallFreeINTEL"; -+ case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL"; -+ case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL"; -+ case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL"; -+ case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL"; -+ case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL"; -+ case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL"; -+ case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL"; -+ case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL"; -+ case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL"; -+ case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL"; -+ case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL"; -+ case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL"; -+ case DecorationHostAccessINTEL: return "HostAccessINTEL"; -+ case DecorationInitModeINTEL: return "InitModeINTEL"; -+ case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; -+ case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; -+ case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* BuiltInToString(BuiltIn value) { -+ switch (value) { -+ case BuiltInPosition: return "Position"; -+ case BuiltInPointSize: return "PointSize"; -+ case BuiltInClipDistance: return "ClipDistance"; -+ case BuiltInCullDistance: return "CullDistance"; -+ case BuiltInVertexId: return "VertexId"; -+ case BuiltInInstanceId: return "InstanceId"; -+ case BuiltInPrimitiveId: return "PrimitiveId"; -+ case BuiltInInvocationId: return "InvocationId"; -+ case BuiltInLayer: return "Layer"; -+ case BuiltInViewportIndex: return "ViewportIndex"; -+ case BuiltInTessLevelOuter: return "TessLevelOuter"; -+ case BuiltInTessLevelInner: return "TessLevelInner"; -+ case BuiltInTessCoord: return "TessCoord"; -+ case BuiltInPatchVertices: return "PatchVertices"; -+ case BuiltInFragCoord: return "FragCoord"; -+ case BuiltInPointCoord: return "PointCoord"; -+ case BuiltInFrontFacing: return "FrontFacing"; -+ case BuiltInSampleId: return "SampleId"; -+ case BuiltInSamplePosition: return "SamplePosition"; -+ case BuiltInSampleMask: return "SampleMask"; -+ case BuiltInFragDepth: return "FragDepth"; -+ case BuiltInHelperInvocation: return "HelperInvocation"; -+ case BuiltInNumWorkgroups: return "NumWorkgroups"; -+ case BuiltInWorkgroupSize: return "WorkgroupSize"; -+ case BuiltInWorkgroupId: return "WorkgroupId"; -+ case BuiltInLocalInvocationId: return "LocalInvocationId"; -+ case BuiltInGlobalInvocationId: return "GlobalInvocationId"; -+ case BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; -+ case BuiltInWorkDim: return "WorkDim"; -+ case BuiltInGlobalSize: return "GlobalSize"; -+ case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; -+ case BuiltInGlobalOffset: return "GlobalOffset"; -+ case BuiltInGlobalLinearId: return "GlobalLinearId"; -+ case BuiltInSubgroupSize: return "SubgroupSize"; -+ case BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; -+ case BuiltInNumSubgroups: return "NumSubgroups"; -+ case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; -+ case BuiltInSubgroupId: return "SubgroupId"; -+ case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; -+ case BuiltInVertexIndex: return "VertexIndex"; -+ case BuiltInInstanceIndex: return "InstanceIndex"; -+ case BuiltInCoreIDARM: return "CoreIDARM"; -+ case BuiltInCoreCountARM: return "CoreCountARM"; -+ case BuiltInCoreMaxIDARM: return "CoreMaxIDARM"; -+ case BuiltInWarpIDARM: return "WarpIDARM"; -+ case BuiltInWarpMaxIDARM: return "WarpMaxIDARM"; -+ case BuiltInSubgroupEqMask: return "SubgroupEqMask"; -+ case BuiltInSubgroupGeMask: return "SubgroupGeMask"; -+ case BuiltInSubgroupGtMask: return "SubgroupGtMask"; -+ case BuiltInSubgroupLeMask: return "SubgroupLeMask"; -+ case BuiltInSubgroupLtMask: return "SubgroupLtMask"; -+ case BuiltInBaseVertex: return "BaseVertex"; -+ case BuiltInBaseInstance: return "BaseInstance"; -+ case BuiltInDrawIndex: return "DrawIndex"; -+ case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR"; -+ case BuiltInDeviceIndex: return "DeviceIndex"; -+ case BuiltInViewIndex: return "ViewIndex"; -+ case BuiltInShadingRateKHR: return "ShadingRateKHR"; -+ case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; -+ case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; -+ case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; -+ case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; -+ case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; -+ case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; -+ case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; -+ case BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; -+ case BuiltInCoalescedInputCountAMDX: return "CoalescedInputCountAMDX"; -+ case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX"; -+ case BuiltInViewportMaskNV: return "ViewportMaskNV"; -+ case BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; -+ case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; -+ case BuiltInPositionPerViewNV: return "PositionPerViewNV"; -+ case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; -+ case BuiltInFullyCoveredEXT: return "FullyCoveredEXT"; -+ case BuiltInTaskCountNV: return "TaskCountNV"; -+ case BuiltInPrimitiveCountNV: return "PrimitiveCountNV"; -+ case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV"; -+ case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV"; -+ case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV"; -+ case BuiltInLayerPerViewNV: return "LayerPerViewNV"; -+ case BuiltInMeshViewCountNV: return "MeshViewCountNV"; -+ case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV"; -+ case BuiltInBaryCoordKHR: return "BaryCoordKHR"; -+ case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR"; -+ case BuiltInFragSizeEXT: return "FragSizeEXT"; -+ case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT"; -+ case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT"; -+ case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT"; -+ case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT"; -+ case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT"; -+ case BuiltInLaunchIdKHR: return "LaunchIdKHR"; -+ case BuiltInLaunchSizeKHR: return "LaunchSizeKHR"; -+ case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR"; -+ case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR"; -+ case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR"; -+ case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR"; -+ case BuiltInRayTminKHR: return "RayTminKHR"; -+ case BuiltInRayTmaxKHR: return "RayTmaxKHR"; -+ case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR"; -+ case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR"; -+ case BuiltInWorldToObjectKHR: return "WorldToObjectKHR"; -+ case BuiltInHitTNV: return "HitTNV"; -+ case BuiltInHitKindKHR: return "HitKindKHR"; -+ case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV"; -+ case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR"; -+ case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV"; -+ case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV"; -+ case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR"; -+ case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR"; -+ case BuiltInWarpsPerSMNV: return "WarpsPerSMNV"; -+ case BuiltInSMCountNV: return "SMCountNV"; -+ case BuiltInWarpIDNV: return "WarpIDNV"; -+ case BuiltInSMIDNV: return "SMIDNV"; -+ case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV"; -+ case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV"; -+ case BuiltInCullMaskKHR: return "CullMaskKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* ScopeToString(Scope value) { -+ switch (value) { -+ case ScopeCrossDevice: return "CrossDevice"; -+ case ScopeDevice: return "Device"; -+ case ScopeWorkgroup: return "Workgroup"; -+ case ScopeSubgroup: return "Subgroup"; -+ case ScopeInvocation: return "Invocation"; -+ case ScopeQueueFamily: return "QueueFamily"; -+ case ScopeShaderCallKHR: return "ShaderCallKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* GroupOperationToString(GroupOperation value) { -+ switch (value) { -+ case GroupOperationReduce: return "Reduce"; -+ case GroupOperationInclusiveScan: return "InclusiveScan"; -+ case GroupOperationExclusiveScan: return "ExclusiveScan"; -+ case GroupOperationClusteredReduce: return "ClusteredReduce"; -+ case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV"; -+ case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV"; -+ case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) { -+ switch (value) { -+ case KernelEnqueueFlagsNoWait: return "NoWait"; -+ case KernelEnqueueFlagsWaitKernel: return "WaitKernel"; -+ case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CapabilityToString(Capability value) { -+ switch (value) { -+ case CapabilityMatrix: return "Matrix"; -+ case CapabilityShader: return "Shader"; -+ case CapabilityGeometry: return "Geometry"; -+ case CapabilityTessellation: return "Tessellation"; -+ case CapabilityAddresses: return "Addresses"; -+ case CapabilityLinkage: return "Linkage"; -+ case CapabilityKernel: return "Kernel"; -+ case CapabilityVector16: return "Vector16"; -+ case CapabilityFloat16Buffer: return "Float16Buffer"; -+ case CapabilityFloat16: return "Float16"; -+ case CapabilityFloat64: return "Float64"; -+ case CapabilityInt64: return "Int64"; -+ case CapabilityInt64Atomics: return "Int64Atomics"; -+ case CapabilityImageBasic: return "ImageBasic"; -+ case CapabilityImageReadWrite: return "ImageReadWrite"; -+ case CapabilityImageMipmap: return "ImageMipmap"; -+ case CapabilityPipes: return "Pipes"; -+ case CapabilityGroups: return "Groups"; -+ case CapabilityDeviceEnqueue: return "DeviceEnqueue"; -+ case CapabilityLiteralSampler: return "LiteralSampler"; -+ case CapabilityAtomicStorage: return "AtomicStorage"; -+ case CapabilityInt16: return "Int16"; -+ case CapabilityTessellationPointSize: return "TessellationPointSize"; -+ case CapabilityGeometryPointSize: return "GeometryPointSize"; -+ case CapabilityImageGatherExtended: return "ImageGatherExtended"; -+ case CapabilityStorageImageMultisample: return "StorageImageMultisample"; -+ case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing"; -+ case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; -+ case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing"; -+ case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; -+ case CapabilityClipDistance: return "ClipDistance"; -+ case CapabilityCullDistance: return "CullDistance"; -+ case CapabilityImageCubeArray: return "ImageCubeArray"; -+ case CapabilitySampleRateShading: return "SampleRateShading"; -+ case CapabilityImageRect: return "ImageRect"; -+ case CapabilitySampledRect: return "SampledRect"; -+ case CapabilityGenericPointer: return "GenericPointer"; -+ case CapabilityInt8: return "Int8"; -+ case CapabilityInputAttachment: return "InputAttachment"; -+ case CapabilitySparseResidency: return "SparseResidency"; -+ case CapabilityMinLod: return "MinLod"; -+ case CapabilitySampled1D: return "Sampled1D"; -+ case CapabilityImage1D: return "Image1D"; -+ case CapabilitySampledCubeArray: return "SampledCubeArray"; -+ case CapabilitySampledBuffer: return "SampledBuffer"; -+ case CapabilityImageBuffer: return "ImageBuffer"; -+ case CapabilityImageMSArray: return "ImageMSArray"; -+ case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; -+ case CapabilityImageQuery: return "ImageQuery"; -+ case CapabilityDerivativeControl: return "DerivativeControl"; -+ case CapabilityInterpolationFunction: return "InterpolationFunction"; -+ case CapabilityTransformFeedback: return "TransformFeedback"; -+ case CapabilityGeometryStreams: return "GeometryStreams"; -+ case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; -+ case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; -+ case CapabilityMultiViewport: return "MultiViewport"; -+ case CapabilitySubgroupDispatch: return "SubgroupDispatch"; -+ case CapabilityNamedBarrier: return "NamedBarrier"; -+ case CapabilityPipeStorage: return "PipeStorage"; -+ case CapabilityGroupNonUniform: return "GroupNonUniform"; -+ case CapabilityGroupNonUniformVote: return "GroupNonUniformVote"; -+ case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic"; -+ case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot"; -+ case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle"; -+ case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative"; -+ case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered"; -+ case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad"; -+ case CapabilityShaderLayer: return "ShaderLayer"; -+ case CapabilityShaderViewportIndex: return "ShaderViewportIndex"; -+ case CapabilityUniformDecoration: return "UniformDecoration"; -+ case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; -+ case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; -+ case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; -+ case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; -+ case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; -+ case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; -+ case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; -+ case CapabilityDrawParameters: return "DrawParameters"; -+ case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; -+ case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; -+ case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; -+ case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; -+ case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess"; -+ case CapabilityStorageUniform16: return "StorageUniform16"; -+ case CapabilityStoragePushConstant16: return "StoragePushConstant16"; -+ case CapabilityStorageInputOutput16: return "StorageInputOutput16"; -+ case CapabilityDeviceGroup: return "DeviceGroup"; -+ case CapabilityMultiView: return "MultiView"; -+ case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; -+ case CapabilityVariablePointers: return "VariablePointers"; -+ case CapabilityAtomicStorageOps: return "AtomicStorageOps"; -+ case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; -+ case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess"; -+ case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess"; -+ case CapabilityStoragePushConstant8: return "StoragePushConstant8"; -+ case CapabilityDenormPreserve: return "DenormPreserve"; -+ case CapabilityDenormFlushToZero: return "DenormFlushToZero"; -+ case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; -+ case CapabilityRoundingModeRTE: return "RoundingModeRTE"; -+ case CapabilityRoundingModeRTZ: return "RoundingModeRTZ"; -+ case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR"; -+ case CapabilityRayQueryKHR: return "RayQueryKHR"; -+ case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR"; -+ case CapabilityRayTracingKHR: return "RayTracingKHR"; -+ case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; -+ case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; -+ case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; -+ case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; -+ case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; -+ case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; -+ case CapabilityFragmentMaskAMD: return "FragmentMaskAMD"; -+ case CapabilityStencilExportEXT: return "StencilExportEXT"; -+ case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD"; -+ case CapabilityInt64ImageEXT: return "Int64ImageEXT"; -+ case CapabilityShaderClockKHR: return "ShaderClockKHR"; -+ case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; -+ case CapabilityQuadControlKHR: return "QuadControlKHR"; -+ case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; -+ case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; -+ case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT"; -+ case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; -+ case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; -+ case CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; -+ case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT"; -+ case CapabilityMeshShadingNV: return "MeshShadingNV"; -+ case CapabilityImageFootprintNV: return "ImageFootprintNV"; -+ case CapabilityMeshShadingEXT: return "MeshShadingEXT"; -+ case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR"; -+ case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; -+ case CapabilityFragmentDensityEXT: return "FragmentDensityEXT"; -+ case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV"; -+ case CapabilityShaderNonUniform: return "ShaderNonUniform"; -+ case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray"; -+ case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing"; -+ case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing"; -+ case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing"; -+ case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing"; -+ case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing"; -+ case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing"; -+ case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing"; -+ case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing"; -+ case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing"; -+ case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing"; -+ case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; -+ case CapabilityRayTracingNV: return "RayTracingNV"; -+ case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV"; -+ case CapabilityVulkanMemoryModel: return "VulkanMemoryModel"; -+ case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope"; -+ case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses"; -+ case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; -+ case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR"; -+ case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV"; -+ case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; -+ case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; -+ case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV"; -+ case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; -+ case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation"; -+ case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV"; -+ case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; -+ case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; -+ case CapabilityBindlessTextureNV: return "BindlessTextureNV"; -+ case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; -+ case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV"; -+ case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; -+ case CapabilityRawAccessChainsNV: return "RawAccessChainsNV"; -+ case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL"; -+ case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL"; -+ case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL"; -+ case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL"; -+ case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL"; -+ case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL"; -+ case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; -+ case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL"; -+ case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL"; -+ case CapabilityAsmINTEL: return "AsmINTEL"; -+ case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; -+ case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; -+ case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT"; -+ case CapabilityVectorComputeINTEL: return "VectorComputeINTEL"; -+ case CapabilityVectorAnyINTEL: return "VectorAnyINTEL"; -+ case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR"; -+ case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL"; -+ case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL"; -+ case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL"; -+ case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL"; -+ case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL"; -+ case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL"; -+ case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL"; -+ case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL"; -+ case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL"; -+ case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL"; -+ case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL"; -+ case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL"; -+ case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL"; -+ case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL"; -+ case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL"; -+ case CapabilityLoopFuseINTEL: return "LoopFuseINTEL"; -+ case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL"; -+ case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL"; -+ case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL"; -+ case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL"; -+ case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL"; -+ case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL"; -+ case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL"; -+ case CapabilityIOPipesINTEL: return "IOPipesINTEL"; -+ case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL"; -+ case CapabilityFPGARegINTEL: return "FPGARegINTEL"; -+ case CapabilityDotProductInputAll: return "DotProductInputAll"; -+ case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit"; -+ case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked"; -+ case CapabilityDotProduct: return "DotProduct"; -+ case CapabilityRayCullMaskKHR: return "RayCullMaskKHR"; -+ case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR"; -+ case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; -+ case CapabilityBitInstructions: return "BitInstructions"; -+ case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; -+ case CapabilityFloatControls2: return "FloatControls2"; -+ case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; -+ case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; -+ case CapabilityLongCompositesINTEL: return "LongCompositesINTEL"; -+ case CapabilityOptNoneINTEL: return "OptNoneINTEL"; -+ case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT"; -+ case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL"; -+ case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL"; -+ case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL"; -+ case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL"; -+ case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL"; -+ case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL"; -+ case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL"; -+ case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL"; -+ case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL"; -+ case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL"; -+ case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; -+ case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; -+ case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; -+ case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryIntersectionToString(RayQueryIntersection value) { -+ switch (value) { -+ case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR"; -+ case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) { -+ switch (value) { -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR"; -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR"; -+ case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) { -+ switch (value) { -+ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR"; -+ case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPDenormModeToString(FPDenormMode value) { -+ switch (value) { -+ case FPDenormModePreserve: return "Preserve"; -+ case FPDenormModeFlushToZero: return "FlushToZero"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* FPOperationModeToString(FPOperationMode value) { -+ switch (value) { -+ case FPOperationModeIEEE: return "IEEE"; -+ case FPOperationModeALT: return "ALT"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* QuantizationModesToString(QuantizationModes value) { -+ switch (value) { -+ case QuantizationModesTRN: return "TRN"; -+ case QuantizationModesTRN_ZERO: return "TRN_ZERO"; -+ case QuantizationModesRND: return "RND"; -+ case QuantizationModesRND_ZERO: return "RND_ZERO"; -+ case QuantizationModesRND_INF: return "RND_INF"; -+ case QuantizationModesRND_MIN_INF: return "RND_MIN_INF"; -+ case QuantizationModesRND_CONV: return "RND_CONV"; -+ case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* OverflowModesToString(OverflowModes value) { -+ switch (value) { -+ case OverflowModesWRAP: return "WRAP"; -+ case OverflowModesSAT: return "SAT"; -+ case OverflowModesSAT_ZERO: return "SAT_ZERO"; -+ case OverflowModesSAT_SYM: return "SAT_SYM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* PackedVectorFormatToString(PackedVectorFormat value) { -+ switch (value) { -+ case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) { -+ switch (value) { -+ case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR"; -+ case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR"; -+ case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM"; -+ case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) { -+ switch (value) { -+ case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR"; -+ case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR"; -+ case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) { -+ switch (value) { -+ case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL"; -+ case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* HostAccessQualifierToString(HostAccessQualifier value) { -+ switch (value) { -+ case HostAccessQualifierNoneINTEL: return "NoneINTEL"; -+ case HostAccessQualifierReadINTEL: return "ReadINTEL"; -+ case HostAccessQualifierWriteINTEL: return "WriteINTEL"; -+ case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* LoadCacheControlToString(LoadCacheControl value) { -+ switch (value) { -+ case LoadCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case LoadCacheControlCachedINTEL: return "CachedINTEL"; -+ case LoadCacheControlStreamingINTEL: return "StreamingINTEL"; -+ case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL"; -+ case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* StoreCacheControlToString(StoreCacheControl value) { -+ switch (value) { -+ case StoreCacheControlUncachedINTEL: return "UncachedINTEL"; -+ case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL"; -+ case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL"; -+ case StoreCacheControlStreamingINTEL: return "StreamingINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) { -+ switch (value) { -+ case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL"; -+ default: return "Unknown"; -+ } -+} -+ -+inline const char* OpToString(Op value) { -+ switch (value) { -+ case OpNop: return "OpNop"; -+ case OpUndef: return "OpUndef"; -+ case OpSourceContinued: return "OpSourceContinued"; -+ case OpSource: return "OpSource"; -+ case OpSourceExtension: return "OpSourceExtension"; -+ case OpName: return "OpName"; -+ case OpMemberName: return "OpMemberName"; -+ case OpString: return "OpString"; -+ case OpLine: return "OpLine"; -+ case OpExtension: return "OpExtension"; -+ case OpExtInstImport: return "OpExtInstImport"; -+ case OpExtInst: return "OpExtInst"; -+ case OpMemoryModel: return "OpMemoryModel"; -+ case OpEntryPoint: return "OpEntryPoint"; -+ case OpExecutionMode: return "OpExecutionMode"; -+ case OpCapability: return "OpCapability"; -+ case OpTypeVoid: return "OpTypeVoid"; -+ case OpTypeBool: return "OpTypeBool"; -+ case OpTypeInt: return "OpTypeInt"; -+ case OpTypeFloat: return "OpTypeFloat"; -+ case OpTypeVector: return "OpTypeVector"; -+ case OpTypeMatrix: return "OpTypeMatrix"; -+ case OpTypeImage: return "OpTypeImage"; -+ case OpTypeSampler: return "OpTypeSampler"; -+ case OpTypeSampledImage: return "OpTypeSampledImage"; -+ case OpTypeArray: return "OpTypeArray"; -+ case OpTypeRuntimeArray: return "OpTypeRuntimeArray"; -+ case OpTypeStruct: return "OpTypeStruct"; -+ case OpTypeOpaque: return "OpTypeOpaque"; -+ case OpTypePointer: return "OpTypePointer"; -+ case OpTypeFunction: return "OpTypeFunction"; -+ case OpTypeEvent: return "OpTypeEvent"; -+ case OpTypeDeviceEvent: return "OpTypeDeviceEvent"; -+ case OpTypeReserveId: return "OpTypeReserveId"; -+ case OpTypeQueue: return "OpTypeQueue"; -+ case OpTypePipe: return "OpTypePipe"; -+ case OpTypeForwardPointer: return "OpTypeForwardPointer"; -+ case OpConstantTrue: return "OpConstantTrue"; -+ case OpConstantFalse: return "OpConstantFalse"; -+ case OpConstant: return "OpConstant"; -+ case OpConstantComposite: return "OpConstantComposite"; -+ case OpConstantSampler: return "OpConstantSampler"; -+ case OpConstantNull: return "OpConstantNull"; -+ case OpSpecConstantTrue: return "OpSpecConstantTrue"; -+ case OpSpecConstantFalse: return "OpSpecConstantFalse"; -+ case OpSpecConstant: return "OpSpecConstant"; -+ case OpSpecConstantComposite: return "OpSpecConstantComposite"; -+ case OpSpecConstantOp: return "OpSpecConstantOp"; -+ case OpFunction: return "OpFunction"; -+ case OpFunctionParameter: return "OpFunctionParameter"; -+ case OpFunctionEnd: return "OpFunctionEnd"; -+ case OpFunctionCall: return "OpFunctionCall"; -+ case OpVariable: return "OpVariable"; -+ case OpImageTexelPointer: return "OpImageTexelPointer"; -+ case OpLoad: return "OpLoad"; -+ case OpStore: return "OpStore"; -+ case OpCopyMemory: return "OpCopyMemory"; -+ case OpCopyMemorySized: return "OpCopyMemorySized"; -+ case OpAccessChain: return "OpAccessChain"; -+ case OpInBoundsAccessChain: return "OpInBoundsAccessChain"; -+ case OpPtrAccessChain: return "OpPtrAccessChain"; -+ case OpArrayLength: return "OpArrayLength"; -+ case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics"; -+ case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain"; -+ case OpDecorate: return "OpDecorate"; -+ case OpMemberDecorate: return "OpMemberDecorate"; -+ case OpDecorationGroup: return "OpDecorationGroup"; -+ case OpGroupDecorate: return "OpGroupDecorate"; -+ case OpGroupMemberDecorate: return "OpGroupMemberDecorate"; -+ case OpVectorExtractDynamic: return "OpVectorExtractDynamic"; -+ case OpVectorInsertDynamic: return "OpVectorInsertDynamic"; -+ case OpVectorShuffle: return "OpVectorShuffle"; -+ case OpCompositeConstruct: return "OpCompositeConstruct"; -+ case OpCompositeExtract: return "OpCompositeExtract"; -+ case OpCompositeInsert: return "OpCompositeInsert"; -+ case OpCopyObject: return "OpCopyObject"; -+ case OpTranspose: return "OpTranspose"; -+ case OpSampledImage: return "OpSampledImage"; -+ case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod"; -+ case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod"; -+ case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod"; -+ case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod"; -+ case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod"; -+ case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod"; -+ case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod"; -+ case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod"; -+ case OpImageFetch: return "OpImageFetch"; -+ case OpImageGather: return "OpImageGather"; -+ case OpImageDrefGather: return "OpImageDrefGather"; -+ case OpImageRead: return "OpImageRead"; -+ case OpImageWrite: return "OpImageWrite"; -+ case OpImage: return "OpImage"; -+ case OpImageQueryFormat: return "OpImageQueryFormat"; -+ case OpImageQueryOrder: return "OpImageQueryOrder"; -+ case OpImageQuerySizeLod: return "OpImageQuerySizeLod"; -+ case OpImageQuerySize: return "OpImageQuerySize"; -+ case OpImageQueryLod: return "OpImageQueryLod"; -+ case OpImageQueryLevels: return "OpImageQueryLevels"; -+ case OpImageQuerySamples: return "OpImageQuerySamples"; -+ case OpConvertFToU: return "OpConvertFToU"; -+ case OpConvertFToS: return "OpConvertFToS"; -+ case OpConvertSToF: return "OpConvertSToF"; -+ case OpConvertUToF: return "OpConvertUToF"; -+ case OpUConvert: return "OpUConvert"; -+ case OpSConvert: return "OpSConvert"; -+ case OpFConvert: return "OpFConvert"; -+ case OpQuantizeToF16: return "OpQuantizeToF16"; -+ case OpConvertPtrToU: return "OpConvertPtrToU"; -+ case OpSatConvertSToU: return "OpSatConvertSToU"; -+ case OpSatConvertUToS: return "OpSatConvertUToS"; -+ case OpConvertUToPtr: return "OpConvertUToPtr"; -+ case OpPtrCastToGeneric: return "OpPtrCastToGeneric"; -+ case OpGenericCastToPtr: return "OpGenericCastToPtr"; -+ case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit"; -+ case OpBitcast: return "OpBitcast"; -+ case OpSNegate: return "OpSNegate"; -+ case OpFNegate: return "OpFNegate"; -+ case OpIAdd: return "OpIAdd"; -+ case OpFAdd: return "OpFAdd"; -+ case OpISub: return "OpISub"; -+ case OpFSub: return "OpFSub"; -+ case OpIMul: return "OpIMul"; -+ case OpFMul: return "OpFMul"; -+ case OpUDiv: return "OpUDiv"; -+ case OpSDiv: return "OpSDiv"; -+ case OpFDiv: return "OpFDiv"; -+ case OpUMod: return "OpUMod"; -+ case OpSRem: return "OpSRem"; -+ case OpSMod: return "OpSMod"; -+ case OpFRem: return "OpFRem"; -+ case OpFMod: return "OpFMod"; -+ case OpVectorTimesScalar: return "OpVectorTimesScalar"; -+ case OpMatrixTimesScalar: return "OpMatrixTimesScalar"; -+ case OpVectorTimesMatrix: return "OpVectorTimesMatrix"; -+ case OpMatrixTimesVector: return "OpMatrixTimesVector"; -+ case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix"; -+ case OpOuterProduct: return "OpOuterProduct"; -+ case OpDot: return "OpDot"; -+ case OpIAddCarry: return "OpIAddCarry"; -+ case OpISubBorrow: return "OpISubBorrow"; -+ case OpUMulExtended: return "OpUMulExtended"; -+ case OpSMulExtended: return "OpSMulExtended"; -+ case OpAny: return "OpAny"; -+ case OpAll: return "OpAll"; -+ case OpIsNan: return "OpIsNan"; -+ case OpIsInf: return "OpIsInf"; -+ case OpIsFinite: return "OpIsFinite"; -+ case OpIsNormal: return "OpIsNormal"; -+ case OpSignBitSet: return "OpSignBitSet"; -+ case OpLessOrGreater: return "OpLessOrGreater"; -+ case OpOrdered: return "OpOrdered"; -+ case OpUnordered: return "OpUnordered"; -+ case OpLogicalEqual: return "OpLogicalEqual"; -+ case OpLogicalNotEqual: return "OpLogicalNotEqual"; -+ case OpLogicalOr: return "OpLogicalOr"; -+ case OpLogicalAnd: return "OpLogicalAnd"; -+ case OpLogicalNot: return "OpLogicalNot"; -+ case OpSelect: return "OpSelect"; -+ case OpIEqual: return "OpIEqual"; -+ case OpINotEqual: return "OpINotEqual"; -+ case OpUGreaterThan: return "OpUGreaterThan"; -+ case OpSGreaterThan: return "OpSGreaterThan"; -+ case OpUGreaterThanEqual: return "OpUGreaterThanEqual"; -+ case OpSGreaterThanEqual: return "OpSGreaterThanEqual"; -+ case OpULessThan: return "OpULessThan"; -+ case OpSLessThan: return "OpSLessThan"; -+ case OpULessThanEqual: return "OpULessThanEqual"; -+ case OpSLessThanEqual: return "OpSLessThanEqual"; -+ case OpFOrdEqual: return "OpFOrdEqual"; -+ case OpFUnordEqual: return "OpFUnordEqual"; -+ case OpFOrdNotEqual: return "OpFOrdNotEqual"; -+ case OpFUnordNotEqual: return "OpFUnordNotEqual"; -+ case OpFOrdLessThan: return "OpFOrdLessThan"; -+ case OpFUnordLessThan: return "OpFUnordLessThan"; -+ case OpFOrdGreaterThan: return "OpFOrdGreaterThan"; -+ case OpFUnordGreaterThan: return "OpFUnordGreaterThan"; -+ case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual"; -+ case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual"; -+ case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual"; -+ case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual"; -+ case OpShiftRightLogical: return "OpShiftRightLogical"; -+ case OpShiftRightArithmetic: return "OpShiftRightArithmetic"; -+ case OpShiftLeftLogical: return "OpShiftLeftLogical"; -+ case OpBitwiseOr: return "OpBitwiseOr"; -+ case OpBitwiseXor: return "OpBitwiseXor"; -+ case OpBitwiseAnd: return "OpBitwiseAnd"; -+ case OpNot: return "OpNot"; -+ case OpBitFieldInsert: return "OpBitFieldInsert"; -+ case OpBitFieldSExtract: return "OpBitFieldSExtract"; -+ case OpBitFieldUExtract: return "OpBitFieldUExtract"; -+ case OpBitReverse: return "OpBitReverse"; -+ case OpBitCount: return "OpBitCount"; -+ case OpDPdx: return "OpDPdx"; -+ case OpDPdy: return "OpDPdy"; -+ case OpFwidth: return "OpFwidth"; -+ case OpDPdxFine: return "OpDPdxFine"; -+ case OpDPdyFine: return "OpDPdyFine"; -+ case OpFwidthFine: return "OpFwidthFine"; -+ case OpDPdxCoarse: return "OpDPdxCoarse"; -+ case OpDPdyCoarse: return "OpDPdyCoarse"; -+ case OpFwidthCoarse: return "OpFwidthCoarse"; -+ case OpEmitVertex: return "OpEmitVertex"; -+ case OpEndPrimitive: return "OpEndPrimitive"; -+ case OpEmitStreamVertex: return "OpEmitStreamVertex"; -+ case OpEndStreamPrimitive: return "OpEndStreamPrimitive"; -+ case OpControlBarrier: return "OpControlBarrier"; -+ case OpMemoryBarrier: return "OpMemoryBarrier"; -+ case OpAtomicLoad: return "OpAtomicLoad"; -+ case OpAtomicStore: return "OpAtomicStore"; -+ case OpAtomicExchange: return "OpAtomicExchange"; -+ case OpAtomicCompareExchange: return "OpAtomicCompareExchange"; -+ case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak"; -+ case OpAtomicIIncrement: return "OpAtomicIIncrement"; -+ case OpAtomicIDecrement: return "OpAtomicIDecrement"; -+ case OpAtomicIAdd: return "OpAtomicIAdd"; -+ case OpAtomicISub: return "OpAtomicISub"; -+ case OpAtomicSMin: return "OpAtomicSMin"; -+ case OpAtomicUMin: return "OpAtomicUMin"; -+ case OpAtomicSMax: return "OpAtomicSMax"; -+ case OpAtomicUMax: return "OpAtomicUMax"; -+ case OpAtomicAnd: return "OpAtomicAnd"; -+ case OpAtomicOr: return "OpAtomicOr"; -+ case OpAtomicXor: return "OpAtomicXor"; -+ case OpPhi: return "OpPhi"; -+ case OpLoopMerge: return "OpLoopMerge"; -+ case OpSelectionMerge: return "OpSelectionMerge"; -+ case OpLabel: return "OpLabel"; -+ case OpBranch: return "OpBranch"; -+ case OpBranchConditional: return "OpBranchConditional"; -+ case OpSwitch: return "OpSwitch"; -+ case OpKill: return "OpKill"; -+ case OpReturn: return "OpReturn"; -+ case OpReturnValue: return "OpReturnValue"; -+ case OpUnreachable: return "OpUnreachable"; -+ case OpLifetimeStart: return "OpLifetimeStart"; -+ case OpLifetimeStop: return "OpLifetimeStop"; -+ case OpGroupAsyncCopy: return "OpGroupAsyncCopy"; -+ case OpGroupWaitEvents: return "OpGroupWaitEvents"; -+ case OpGroupAll: return "OpGroupAll"; -+ case OpGroupAny: return "OpGroupAny"; -+ case OpGroupBroadcast: return "OpGroupBroadcast"; -+ case OpGroupIAdd: return "OpGroupIAdd"; -+ case OpGroupFAdd: return "OpGroupFAdd"; -+ case OpGroupFMin: return "OpGroupFMin"; -+ case OpGroupUMin: return "OpGroupUMin"; -+ case OpGroupSMin: return "OpGroupSMin"; -+ case OpGroupFMax: return "OpGroupFMax"; -+ case OpGroupUMax: return "OpGroupUMax"; -+ case OpGroupSMax: return "OpGroupSMax"; -+ case OpReadPipe: return "OpReadPipe"; -+ case OpWritePipe: return "OpWritePipe"; -+ case OpReservedReadPipe: return "OpReservedReadPipe"; -+ case OpReservedWritePipe: return "OpReservedWritePipe"; -+ case OpReserveReadPipePackets: return "OpReserveReadPipePackets"; -+ case OpReserveWritePipePackets: return "OpReserveWritePipePackets"; -+ case OpCommitReadPipe: return "OpCommitReadPipe"; -+ case OpCommitWritePipe: return "OpCommitWritePipe"; -+ case OpIsValidReserveId: return "OpIsValidReserveId"; -+ case OpGetNumPipePackets: return "OpGetNumPipePackets"; -+ case OpGetMaxPipePackets: return "OpGetMaxPipePackets"; -+ case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets"; -+ case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets"; -+ case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe"; -+ case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe"; -+ case OpEnqueueMarker: return "OpEnqueueMarker"; -+ case OpEnqueueKernel: return "OpEnqueueKernel"; -+ case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount"; -+ case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize"; -+ case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize"; -+ case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple"; -+ case OpRetainEvent: return "OpRetainEvent"; -+ case OpReleaseEvent: return "OpReleaseEvent"; -+ case OpCreateUserEvent: return "OpCreateUserEvent"; -+ case OpIsValidEvent: return "OpIsValidEvent"; -+ case OpSetUserEventStatus: return "OpSetUserEventStatus"; -+ case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo"; -+ case OpGetDefaultQueue: return "OpGetDefaultQueue"; -+ case OpBuildNDRange: return "OpBuildNDRange"; -+ case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod"; -+ case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod"; -+ case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod"; -+ case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod"; -+ case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod"; -+ case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod"; -+ case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod"; -+ case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod"; -+ case OpImageSparseFetch: return "OpImageSparseFetch"; -+ case OpImageSparseGather: return "OpImageSparseGather"; -+ case OpImageSparseDrefGather: return "OpImageSparseDrefGather"; -+ case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident"; -+ case OpNoLine: return "OpNoLine"; -+ case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet"; -+ case OpAtomicFlagClear: return "OpAtomicFlagClear"; -+ case OpImageSparseRead: return "OpImageSparseRead"; -+ case OpSizeOf: return "OpSizeOf"; -+ case OpTypePipeStorage: return "OpTypePipeStorage"; -+ case OpConstantPipeStorage: return "OpConstantPipeStorage"; -+ case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage"; -+ case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount"; -+ case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups"; -+ case OpTypeNamedBarrier: return "OpTypeNamedBarrier"; -+ case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize"; -+ case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier"; -+ case OpModuleProcessed: return "OpModuleProcessed"; -+ case OpExecutionModeId: return "OpExecutionModeId"; -+ case OpDecorateId: return "OpDecorateId"; -+ case OpGroupNonUniformElect: return "OpGroupNonUniformElect"; -+ case OpGroupNonUniformAll: return "OpGroupNonUniformAll"; -+ case OpGroupNonUniformAny: return "OpGroupNonUniformAny"; -+ case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual"; -+ case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast"; -+ case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst"; -+ case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot"; -+ case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot"; -+ case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract"; -+ case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount"; -+ case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB"; -+ case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB"; -+ case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle"; -+ case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor"; -+ case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp"; -+ case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown"; -+ case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd"; -+ case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd"; -+ case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul"; -+ case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul"; -+ case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin"; -+ case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin"; -+ case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin"; -+ case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax"; -+ case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax"; -+ case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax"; -+ case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd"; -+ case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr"; -+ case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor"; -+ case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd"; -+ case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr"; -+ case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor"; -+ case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast"; -+ case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap"; -+ case OpCopyLogical: return "OpCopyLogical"; -+ case OpPtrEqual: return "OpPtrEqual"; -+ case OpPtrNotEqual: return "OpPtrNotEqual"; -+ case OpPtrDiff: return "OpPtrDiff"; -+ case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; -+ case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; -+ case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; -+ case OpTerminateInvocation: return "OpTerminateInvocation"; -+ case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR"; -+ case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR"; -+ case OpSubgroupAllKHR: return "OpSubgroupAllKHR"; -+ case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; -+ case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; -+ case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; -+ case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; -+ case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; -+ case OpTraceRayKHR: return "OpTraceRayKHR"; -+ case OpExecuteCallableKHR: return "OpExecuteCallableKHR"; -+ case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; -+ case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR"; -+ case OpTerminateRayKHR: return "OpTerminateRayKHR"; -+ case OpSDot: return "OpSDot"; -+ case OpUDot: return "OpUDot"; -+ case OpSUDot: return "OpSUDot"; -+ case OpSDotAccSat: return "OpSDotAccSat"; -+ case OpUDotAccSat: return "OpUDotAccSat"; -+ case OpSUDotAccSat: return "OpSUDotAccSat"; -+ case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR"; -+ case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR"; -+ case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR"; -+ case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR"; -+ case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR"; -+ case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; -+ case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; -+ case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; -+ case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR"; -+ case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR"; -+ case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR"; -+ case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR"; -+ case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR"; -+ case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR"; -+ case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR"; -+ case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM"; -+ case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; -+ case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; -+ case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; -+ case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; -+ case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; -+ case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; -+ case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; -+ case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; -+ case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; -+ case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; -+ case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD"; -+ case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD"; -+ case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD"; -+ case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD"; -+ case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD"; -+ case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD"; -+ case OpFragmentFetchAMD: return "OpFragmentFetchAMD"; -+ case OpReadClockKHR: return "OpReadClockKHR"; -+ case OpFinalizeNodePayloadsAMDX: return "OpFinalizeNodePayloadsAMDX"; -+ case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX"; -+ case OpInitializeNodePayloadsAMDX: return "OpInitializeNodePayloadsAMDX"; -+ case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR"; -+ case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR"; -+ case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV"; -+ case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV"; -+ case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV"; -+ case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV"; -+ case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV"; -+ case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV"; -+ case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV"; -+ case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV"; -+ case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV"; -+ case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV"; -+ case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV"; -+ case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV"; -+ case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV"; -+ case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV"; -+ case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV"; -+ case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV"; -+ case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV"; -+ case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV"; -+ case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV"; -+ case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV"; -+ case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV"; -+ case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV"; -+ case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV"; -+ case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV"; -+ case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV"; -+ case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV"; -+ case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV"; -+ case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV"; -+ case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV"; -+ case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV"; -+ case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV"; -+ case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV"; -+ case OpTypeHitObjectNV: return "OpTypeHitObjectNV"; -+ case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV"; -+ case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT"; -+ case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT"; -+ case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV"; -+ case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV"; -+ case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV"; -+ case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV"; -+ case OpReportIntersectionKHR: return "OpReportIntersectionKHR"; -+ case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV"; -+ case OpTerminateRayNV: return "OpTerminateRayNV"; -+ case OpTraceNV: return "OpTraceNV"; -+ case OpTraceMotionNV: return "OpTraceMotionNV"; -+ case OpTraceRayMotionNV: return "OpTraceRayMotionNV"; -+ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR"; -+ case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR"; -+ case OpExecuteCallableNV: return "OpExecuteCallableNV"; -+ case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV"; -+ case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV"; -+ case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV"; -+ case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV"; -+ case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV"; -+ case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; -+ case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; -+ case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation"; -+ case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT"; -+ case OpConvertUToImageNV: return "OpConvertUToImageNV"; -+ case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV"; -+ case OpConvertImageToUNV: return "OpConvertImageToUNV"; -+ case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV"; -+ case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV"; -+ case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV"; -+ case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV"; -+ case OpRawAccessChainNV: return "OpRawAccessChainNV"; -+ case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL"; -+ case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL"; -+ case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL"; -+ case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL"; -+ case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL"; -+ case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL"; -+ case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL"; -+ case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL"; -+ case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL"; -+ case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL"; -+ case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL"; -+ case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL"; -+ case OpAbsISubINTEL: return "OpAbsISubINTEL"; -+ case OpAbsUSubINTEL: return "OpAbsUSubINTEL"; -+ case OpIAddSatINTEL: return "OpIAddSatINTEL"; -+ case OpUAddSatINTEL: return "OpUAddSatINTEL"; -+ case OpIAverageINTEL: return "OpIAverageINTEL"; -+ case OpUAverageINTEL: return "OpUAverageINTEL"; -+ case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL"; -+ case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL"; -+ case OpISubSatINTEL: return "OpISubSatINTEL"; -+ case OpUSubSatINTEL: return "OpUSubSatINTEL"; -+ case OpIMul32x16INTEL: return "OpIMul32x16INTEL"; -+ case OpUMul32x16INTEL: return "OpUMul32x16INTEL"; -+ case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL"; -+ case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL"; -+ case OpAsmTargetINTEL: return "OpAsmTargetINTEL"; -+ case OpAsmINTEL: return "OpAsmINTEL"; -+ case OpAsmCallINTEL: return "OpAsmCallINTEL"; -+ case OpAtomicFMinEXT: return "OpAtomicFMinEXT"; -+ case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT"; -+ case OpAssumeTrueKHR: return "OpAssumeTrueKHR"; -+ case OpExpectKHR: return "OpExpectKHR"; -+ case OpDecorateString: return "OpDecorateString"; -+ case OpMemberDecorateString: return "OpMemberDecorateString"; -+ case OpVmeImageINTEL: return "OpVmeImageINTEL"; -+ case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL"; -+ case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL"; -+ case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL"; -+ case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL"; -+ case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL"; -+ case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL"; -+ case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL"; -+ case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL"; -+ case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL"; -+ case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL"; -+ case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL"; -+ case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL"; -+ case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"; -+ case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"; -+ case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"; -+ case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"; -+ case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL"; -+ case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"; -+ case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"; -+ case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"; -+ case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL"; -+ case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL"; -+ case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL"; -+ case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL"; -+ case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL"; -+ case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL"; -+ case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL"; -+ case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL"; -+ case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL"; -+ case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL"; -+ case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL"; -+ case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL"; -+ case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL"; -+ case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL"; -+ case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"; -+ case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL"; -+ case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL"; -+ case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL"; -+ case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL"; -+ case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL"; -+ case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"; -+ case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"; -+ case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"; -+ case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"; -+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"; -+ case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL"; -+ case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL"; -+ case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"; -+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"; -+ case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL"; -+ case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"; -+ case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"; -+ case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"; -+ case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"; -+ case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL"; -+ case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL"; -+ case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"; -+ case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL"; -+ case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"; -+ case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"; -+ case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL"; -+ case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL"; -+ case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL"; -+ case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL"; -+ case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"; -+ case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL"; -+ case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL"; -+ case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"; -+ case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"; -+ case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"; -+ case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL"; -+ case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"; -+ case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"; -+ case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL"; -+ case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"; -+ case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"; -+ case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL"; -+ case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL"; -+ case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"; -+ case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"; -+ case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"; -+ case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL"; -+ case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"; -+ case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"; -+ case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL"; -+ case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL"; -+ case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL"; -+ case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL"; -+ case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL"; -+ case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL"; -+ case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL"; -+ case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL"; -+ case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL"; -+ case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL"; -+ case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL"; -+ case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL"; -+ case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL"; -+ case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL"; -+ case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL"; -+ case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL"; -+ case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL"; -+ case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL"; -+ case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL"; -+ case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL"; -+ case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL"; -+ case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL"; -+ case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL"; -+ case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL"; -+ case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL"; -+ case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL"; -+ case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL"; -+ case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL"; -+ case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL"; -+ case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL"; -+ case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL"; -+ case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL"; -+ case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL"; -+ case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL"; -+ case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL"; -+ case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL"; -+ case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL"; -+ case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL"; -+ case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL"; -+ case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL"; -+ case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL"; -+ case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL"; -+ case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL"; -+ case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL"; -+ case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL"; -+ case OpLoopControlINTEL: return "OpLoopControlINTEL"; -+ case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL"; -+ case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL"; -+ case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL"; -+ case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL"; -+ case OpFixedRecipINTEL: return "OpFixedRecipINTEL"; -+ case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL"; -+ case OpFixedSinINTEL: return "OpFixedSinINTEL"; -+ case OpFixedCosINTEL: return "OpFixedCosINTEL"; -+ case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL"; -+ case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL"; -+ case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL"; -+ case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL"; -+ case OpFixedLogINTEL: return "OpFixedLogINTEL"; -+ case OpFixedExpINTEL: return "OpFixedExpINTEL"; -+ case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL"; -+ case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL"; -+ case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL"; -+ case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL"; -+ case OpFPGARegINTEL: return "OpFPGARegINTEL"; -+ case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR"; -+ case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR"; -+ case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR"; -+ case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR"; -+ case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR"; -+ case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"; -+ case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR"; -+ case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR"; -+ case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR"; -+ case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR"; -+ case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"; -+ case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR"; -+ case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR"; -+ case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR"; -+ case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR"; -+ case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR"; -+ case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR"; -+ case OpAtomicFAddEXT: return "OpAtomicFAddEXT"; -+ case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL"; -+ case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL"; -+ case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL"; -+ case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL"; -+ case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL"; -+ case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL"; -+ case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL"; -+ case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL"; -+ case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL"; -+ case OpGroupIMulKHR: return "OpGroupIMulKHR"; -+ case OpGroupFMulKHR: return "OpGroupFMulKHR"; -+ case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; -+ case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR"; -+ case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR"; -+ case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR"; -+ case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR"; -+ case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR"; -+ case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; -+ case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; -+ default: return "Unknown"; -+ } -+} -+ - #endif /* SPV_ENABLE_UTILITY_CODE */ - - // Overload bitwise operators for mask bit combining -diff --git include/spirv/unified1/spirv.json include/spirv/unified1/spirv.json -index 204a9c5..430c74f 100644 ---- include/spirv/unified1/spirv.json -+++ include/spirv/unified1/spirv.json -@@ -1022,6 +1022,7 @@ - "TileImageColorReadAccessEXT": 4166, - "TileImageDepthReadAccessEXT": 4167, - "TileImageStencilReadAccessEXT": 4168, -+ "CooperativeMatrixLayoutsARM": 4201, - "FragmentShadingRateKHR": 4422, - "SubgroupBallotKHR": 4423, - "DrawParameters": 4427, -@@ -1185,6 +1186,7 @@ - "DotProductKHR": 6019, - "RayCullMaskKHR": 6020, - "CooperativeMatrixKHR": 6022, -+ "ReplicatedCompositesEXT": 6024, - "BitInstructions": 6025, - "GroupNonUniformRotateKHR": 6026, - "FloatControls2": 6029, -@@ -1337,7 +1339,9 @@ - "Values": - { - "RowMajorKHR": 0, -- "ColumnMajorKHR": 1 -+ "ColumnMajorKHR": 1, -+ "RowBlockedInterleavedARM": 4202, -+ "ColumnBlockedInterleavedARM": 4203 - } - }, - { -@@ -1770,6 +1774,7 @@ - "OpSubgroupAllEqualKHR": 4430, - "OpGroupNonUniformRotateKHR": 4431, - "OpSubgroupReadInvocationKHR": 4432, -+ "OpExtInstWithForwardRefsKHR": 4433, - "OpTraceRayKHR": 4445, - "OpExecuteCallableKHR": 4446, - "OpConvertUToAccelerationStructureKHR": 4447, -@@ -1792,6 +1797,9 @@ - "OpCooperativeMatrixStoreKHR": 4458, - "OpCooperativeMatrixMulAddKHR": 4459, - "OpCooperativeMatrixLengthKHR": 4460, -+ "OpConstantCompositeReplicateEXT": 4461, -+ "OpSpecConstantCompositeReplicateEXT": 4462, -+ "OpCompositeConstructReplicateEXT": 4463, - "OpTypeRayQueryKHR": 4472, - "OpRayQueryInitializeKHR": 4473, - "OpRayQueryTerminateKHR": 4474, -diff --git include/spirv/unified1/spirv.lua include/spirv/unified1/spirv.lua -index 6dcd1b8..8f3ded0 100644 ---- include/spirv/unified1/spirv.lua -+++ include/spirv/unified1/spirv.lua -@@ -1007,6 +1007,7 @@ spv = { - TileImageColorReadAccessEXT = 4166, - TileImageDepthReadAccessEXT = 4167, - TileImageStencilReadAccessEXT = 4168, -+ CooperativeMatrixLayoutsARM = 4201, - FragmentShadingRateKHR = 4422, - SubgroupBallotKHR = 4423, - DrawParameters = 4427, -@@ -1170,6 +1171,7 @@ spv = { - DotProductKHR = 6019, - RayCullMaskKHR = 6020, - CooperativeMatrixKHR = 6022, -+ ReplicatedCompositesEXT = 6024, - BitInstructions = 6025, - GroupNonUniformRotateKHR = 6026, - FloatControls2 = 6029, -@@ -1307,6 +1309,8 @@ spv = { - CooperativeMatrixLayout = { - RowMajorKHR = 0, - ColumnMajorKHR = 1, -+ RowBlockedInterleavedARM = 4202, -+ ColumnBlockedInterleavedARM = 4203, - }, - - CooperativeMatrixUse = { -@@ -1713,6 +1717,7 @@ spv = { - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1735,6 +1740,9 @@ spv = { - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -diff --git include/spirv/unified1/spirv.py include/spirv/unified1/spirv.py -index 4b011cf..23c0fcc 100644 ---- include/spirv/unified1/spirv.py -+++ include/spirv/unified1/spirv.py -@@ -1007,6 +1007,7 @@ spv = { - 'TileImageColorReadAccessEXT' : 4166, - 'TileImageDepthReadAccessEXT' : 4167, - 'TileImageStencilReadAccessEXT' : 4168, -+ 'CooperativeMatrixLayoutsARM' : 4201, - 'FragmentShadingRateKHR' : 4422, - 'SubgroupBallotKHR' : 4423, - 'DrawParameters' : 4427, -@@ -1170,6 +1171,7 @@ spv = { - 'DotProductKHR' : 6019, - 'RayCullMaskKHR' : 6020, - 'CooperativeMatrixKHR' : 6022, -+ 'ReplicatedCompositesEXT' : 6024, - 'BitInstructions' : 6025, - 'GroupNonUniformRotateKHR' : 6026, - 'FloatControls2' : 6029, -@@ -1307,6 +1309,8 @@ spv = { - 'CooperativeMatrixLayout' : { - 'RowMajorKHR' : 0, - 'ColumnMajorKHR' : 1, -+ 'RowBlockedInterleavedARM' : 4202, -+ 'ColumnBlockedInterleavedARM' : 4203, - }, - - 'CooperativeMatrixUse' : { -@@ -1713,6 +1717,7 @@ spv = { - 'OpSubgroupAllEqualKHR' : 4430, - 'OpGroupNonUniformRotateKHR' : 4431, - 'OpSubgroupReadInvocationKHR' : 4432, -+ 'OpExtInstWithForwardRefsKHR' : 4433, - 'OpTraceRayKHR' : 4445, - 'OpExecuteCallableKHR' : 4446, - 'OpConvertUToAccelerationStructureKHR' : 4447, -@@ -1735,6 +1740,9 @@ spv = { - 'OpCooperativeMatrixStoreKHR' : 4458, - 'OpCooperativeMatrixMulAddKHR' : 4459, - 'OpCooperativeMatrixLengthKHR' : 4460, -+ 'OpConstantCompositeReplicateEXT' : 4461, -+ 'OpSpecConstantCompositeReplicateEXT' : 4462, -+ 'OpCompositeConstructReplicateEXT' : 4463, - 'OpTypeRayQueryKHR' : 4472, - 'OpRayQueryInitializeKHR' : 4473, - 'OpRayQueryTerminateKHR' : 4474, -diff --git include/spirv/unified1/spv.d include/spirv/unified1/spv.d -index 64c115e..295678e 100644 ---- include/spirv/unified1/spv.d -+++ include/spirv/unified1/spv.d -@@ -1052,6 +1052,7 @@ enum Capability : uint - TileImageColorReadAccessEXT = 4166, - TileImageDepthReadAccessEXT = 4167, - TileImageStencilReadAccessEXT = 4168, -+ CooperativeMatrixLayoutsARM = 4201, - FragmentShadingRateKHR = 4422, - SubgroupBallotKHR = 4423, - DrawParameters = 4427, -@@ -1215,6 +1216,7 @@ enum Capability : uint - DotProductKHR = 6019, - RayCullMaskKHR = 6020, - CooperativeMatrixKHR = 6022, -+ ReplicatedCompositesEXT = 6024, - BitInstructions = 6025, - GroupNonUniformRotateKHR = 6026, - FloatControls2 = 6029, -@@ -1367,6 +1369,8 @@ enum CooperativeMatrixLayout : uint - { - RowMajorKHR = 0, - ColumnMajorKHR = 1, -+ RowBlockedInterleavedARM = 4202, -+ ColumnBlockedInterleavedARM = 4203, - } - - enum CooperativeMatrixUse : uint -@@ -1782,6 +1786,7 @@ enum Op : uint - OpSubgroupAllEqualKHR = 4430, - OpGroupNonUniformRotateKHR = 4431, - OpSubgroupReadInvocationKHR = 4432, -+ OpExtInstWithForwardRefsKHR = 4433, - OpTraceRayKHR = 4445, - OpExecuteCallableKHR = 4446, - OpConvertUToAccelerationStructureKHR = 4447, -@@ -1804,6 +1809,9 @@ enum Op : uint - OpCooperativeMatrixStoreKHR = 4458, - OpCooperativeMatrixMulAddKHR = 4459, - OpCooperativeMatrixLengthKHR = 4460, -+ OpConstantCompositeReplicateEXT = 4461, -+ OpSpecConstantCompositeReplicateEXT = 4462, -+ OpCompositeConstructReplicateEXT = 4463, - OpTypeRayQueryKHR = 4472, - OpRayQueryInitializeKHR = 4473, - OpRayQueryTerminateKHR = 4474, -diff --git tools/buildHeaders/header.cpp tools/buildHeaders/header.cpp -index d125a79..9dd4e40 100644 ---- tools/buildHeaders/header.cpp -+++ tools/buildHeaders/header.cpp -@@ -98,7 +98,7 @@ namespace { - virtual void printEpilogue(std::ostream&) const { } - virtual void printMeta(std::ostream&) const; - virtual void printTypes(std::ostream&) const { } -- virtual void printHasResultType(std::ostream&) const { }; -+ virtual void printUtility(std::ostream&) const { }; - - virtual std::string escapeComment(const std::string& s) const; - -@@ -369,7 +369,7 @@ IN THE MATERIALS. - printTypes(out); - printMeta(out); - printDefs(out); -- printHasResultType(out); -+ printUtility(out); - printEpilogue(out); - } - -@@ -503,8 +503,20 @@ IN THE MATERIALS. - - virtual std::string fmtEnumUse(const std::string& opPrefix, const std::string& name) const { return pre() + name; } - -- virtual void printHasResultType(std::ostream& out) const override -+ virtual void printUtility(std::ostream& out) const override - { -+ out << "#ifdef SPV_ENABLE_UTILITY_CODE" << std::endl; -+ out << "#ifndef __cplusplus" << std::endl; -+ out << "#include " << std::endl; -+ out << "#endif" << std::endl; -+ -+ printHasResultType(out); -+ printStringFunctions(out); -+ -+ out << "#endif /* SPV_ENABLE_UTILITY_CODE */" << std::endl << std::endl; -+ } -+ -+ void printHasResultType(std::ostream& out) const { - const Json::Value& enums = spvRoot["spv"]["enum"]; - - std::set seenValues; -@@ -515,10 +527,7 @@ IN THE MATERIALS. - continue; - } - -- out << "#ifdef SPV_ENABLE_UTILITY_CODE" << std::endl; -- out << "#ifndef __cplusplus" << std::endl; -- out << "#include " << std::endl; -- out << "#endif" << std::endl; -+ - out << "inline void " << pre() << "HasResultAndType(" << pre() << opName << " opcode, bool *hasResult, bool *hasResultType) {" << std::endl; - out << " *hasResult = *hasResultType = false;" << std::endl; - out << " switch (opcode) {" << std::endl; -@@ -539,7 +548,43 @@ IN THE MATERIALS. - - out << " }" << std::endl; - out << "}" << std::endl; -- out << "#endif /* SPV_ENABLE_UTILITY_CODE */" << std::endl << std::endl; -+ } -+ } -+ -+ void printStringFunctions(std::ostream& out) const { -+ const Json::Value& enums = spvRoot["spv"]["enum"]; -+ -+ for (auto it = enums.begin(); it != enums.end(); ++it) { -+ const auto type = (*it)["Type"].asString(); -+ // Skip bitmasks -+ if (type == "Bit") { -+ continue; -+ } -+ const auto name = (*it)["Name"].asString(); -+ const auto sorted = getSortedVals((*it)["Values"]); -+ -+ std::set seenValues; -+ std::string fullName = pre() + name; -+ -+ out << "inline const char* " << fullName << "ToString(" << fullName << " value) {" << std::endl; -+ out << " switch (value) {" << std::endl; -+ for (const auto& v : sorted) { -+ // Filter out duplicate enum values, which would break the switch statement. -+ // These are probably just extension enums promoted to core. -+ if (seenValues.count(v.first)) { -+ continue; -+ } -+ seenValues.insert(v.first); -+ -+ std::string label{name + v.second}; -+ if (name == "Op") { -+ label = v.second; -+ } -+ out << " " << "case " << pre() << label << ": return " << "\"" << v.second << "\";" << std::endl; -+ } -+ out << " default: return \"Unknown\";" << std::endl; -+ out << " }" << std::endl; -+ out << "}" << std::endl << std::endl; - } - } - }; -diff --git tools/buildHeaders/jsonToSpirv.cpp tools/buildHeaders/jsonToSpirv.cpp -index 34e0972..22beba7 100644 ---- tools/buildHeaders/jsonToSpirv.cpp -+++ tools/buildHeaders/jsonToSpirv.cpp -@@ -471,6 +471,37 @@ unsigned int NumberStringToBit(const std::string& str) - return bit; - } - -+// Given two pairs (name and in core) compares if the order is correct for naming -+// conventions. The conventions are: -+// * Core -+// * KHR -+// * EXT -+// * Vendor (no preference between vendors) -+// -+// Returns true if the order is valid. -+bool SuffixComparison(const std::string& prev, bool prevCore, -+ const std::string& cur, bool curCore) -+{ -+ // Duplicate entry -+ if (prev == cur) return false; -+ -+ if (prevCore) return true; -+ if (curCore) return false; -+ -+ // Both are suffixed names. -+ const bool prevKHR = prev.substr(prev.size() - 3) == "KHR"; -+ const bool prevEXT = prev.substr(prev.size() - 3) == "EXT"; -+ const bool curKHR = cur.substr(cur.size() - 3) == "KHR"; -+ const bool curEXT = cur.substr(cur.size() - 3) == "EXT"; -+ -+ if (prevKHR) return true; -+ if (curKHR) return false; -+ if (prevEXT) return true; -+ if (curEXT) return false; -+ -+ return true; -+} -+ - void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) - { - // only do this once. -@@ -547,6 +578,8 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) - // process the instructions - const Json::Value insts = root["instructions"]; - unsigned maxOpcode = 0; -+ std::string maxName = ""; -+ bool maxCore = false; - bool firstOpcode = true; - for (const auto& inst : insts) { - const auto printingClass = inst["class"].asString(); -@@ -565,8 +598,11 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) - } - const auto opcode = inst["opcode"].asUInt(); - const std::string name = inst["opname"].asString(); -+ std::string version = inst["version"].asString(); - if (firstOpcode) { - maxOpcode = opcode; -+ maxName = name; -+ maxCore = version != "None"; - firstOpcode = false; - } else { - if (maxOpcode > opcode) { -@@ -574,12 +610,20 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) - << " is out of order. It follows the instruction with opcode " << maxOpcode - << std::endl; - std::exit(1); -+ } else if (maxOpcode == opcode && -+ !SuffixComparison(maxName, maxCore, name, -+ version != "None")) { -+ std::cerr << "Error: " << name -+ << " is out of order. It follows alias " << maxName -+ << std::endl; -+ std::exit(1); - } else { - maxOpcode = opcode; -+ maxName = name; -+ maxCore = version != "None"; - } - } - EnumCaps caps = getCaps(inst); -- std::string version = inst["version"].asString(); - std::string lastVersion = inst["lastVersion"].asString(); - Extensions exts = getExts(inst); - OperandParameters operands; -@@ -625,28 +669,41 @@ void jsonToSpirv(const std::string& jsonPath, bool buildingHeaders) - }; - - unsigned maxValue = 0; -+ std::string maxName = ""; -+ bool maxCore = false; - bool firstValue = true; - for (const auto& enumerant : source["enumerants"]) { - unsigned value; - bool skip_zero_in_bitfield; - std::tie(value, skip_zero_in_bitfield) = getValue(enumerant); -+ std::string name = enumerant["enumerant"].asString(); -+ std::string version = enumerant["version"].asString(); - if (skip_zero_in_bitfield) - continue; - if (firstValue) { - maxValue = value; -+ maxName = name; -+ maxCore = version != "None"; - firstValue = false; - } else { - if (maxValue > value) { -- std::cerr << "Error: " << source["kind"] << " enumerant " << enumerant["enumerant"] -+ std::cerr << "Error: " << source["kind"] << " enumerant " << name - << " is out of order. It has value " << value - << " but follows the enumerant with value " << maxValue << std::endl; - std::exit(1); -+ } else if (maxValue == value && -+ !SuffixComparison(maxName, maxCore, name, -+ version != "None")) { -+ std::cerr << "Error: " << source["kind"] << " enumerant " << name -+ << " is out of order. It follows alias " << maxName << std::endl; -+ std::exit(1); - } else { - maxValue = value; -+ maxName = name; -+ maxCore = version != "None"; - } - } - EnumCaps caps(getCaps(enumerant)); -- std::string version = enumerant["version"].asString(); - std::string lastVersion = enumerant["lastVersion"].asString(); - Extensions exts(getExts(enumerant)); - OperandParameters params; From 77829e0af7be714471d6810c818f0bce1d4176bee04265cdda77e7e3a16fd587 Mon Sep 17 00:00:00 2001 From: OBS User unknown Date: Tue, 23 Jul 2024 04:49:33 +0000 Subject: [PATCH 3/3] [info=131519444b9804409644a169ee851b9b06ffd5f7a4c89044b692335cb50dd874] OBS-URL: https://build.opensuse.org/package/show/X11:Wayland/spirv-headers?expand=0&rev=102 --- _scmsync.obsinfo | 4 ++-- build.specials.obscpio | 2 +- spirv-headers.changes | 10 ++++++++++ spirv-headers.spec | 4 ++-- vulkan-sdk-1.3.283.tar.gz | 3 --- vulkan-sdk-1.3.290.tar.gz | 3 +++ 6 files changed, 18 insertions(+), 8 deletions(-) delete mode 100644 vulkan-sdk-1.3.283.tar.gz create mode 100644 vulkan-sdk-1.3.290.tar.gz diff --git a/_scmsync.obsinfo b/_scmsync.obsinfo index 8250904..36f06bd 100644 --- a/_scmsync.obsinfo +++ b/_scmsync.obsinfo @@ -1,4 +1,4 @@ -mtime: 1715969064 -commit: 32f7b29edfe3f81874015833637bf66b39a8d1c02d6e0fa9b4312f731d163b0c +mtime: 1721710366 +commit: 131519444b9804409644a169ee851b9b06ffd5f7a4c89044b692335cb50dd874 url: https://src.opensuse.org/jengelh/spirv-headers revision: master diff --git a/build.specials.obscpio b/build.specials.obscpio index 55e85be..459cadf 100644 --- a/build.specials.obscpio +++ b/build.specials.obscpio @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9551e8ba49de942a6116e50c53b000d639da665de8fc093765211b9b7dedc655 +oid sha256:8ced412eb3ae28541d439f1ae83adb6623590728df4f99dd07b00352adca35e4 size 256 diff --git a/spirv-headers.changes b/spirv-headers.changes index ae02a15..d2abfdf 100644 --- a/spirv-headers.changes +++ b/spirv-headers.changes @@ -1,3 +1,13 @@ +------------------------------------------------------------------- +Tue Jul 23 04:50:50 UTC 2024 - Jan Engelhardt + +- Updateto release SDK-1.3.290.0 + * Add utility functions to strinfigy value enums + * Add SPV_EXT_replicated_composites, + SPV_KHR_relaxed_extended_instruction and + SPV_ARM_cooperative_matrix_layouts + * Add KHR suffix to OpExtInstWithForwardRefsKHR + ------------------------------------------------------------------- Thu May 16 11:38:08 UTC 2024 - Jan Engelhardt diff --git a/spirv-headers.spec b/spirv-headers.spec index 6e6cf31..94a63d3 100644 --- a/spirv-headers.spec +++ b/spirv-headers.spec @@ -24,8 +24,8 @@ # and the independently increasing toolchain release number (283). Name: spirv-headers -Version: 1.6.1+sdk283 -%define innerver 1.3.283 +Version: 1.6.1+sdk290 +%define innerver 1.3.290 Release: 0 Summary: Machine-readable files from the SPIR-V registry License: MIT diff --git a/vulkan-sdk-1.3.283.tar.gz b/vulkan-sdk-1.3.283.tar.gz deleted file mode 100644 index c194065..0000000 --- a/vulkan-sdk-1.3.283.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c1bf1b9951a06d20329871ca8415b8ff5d0bebbc2f49cfd06fd095313e20dee -size 472243 diff --git a/vulkan-sdk-1.3.290.tar.gz b/vulkan-sdk-1.3.290.tar.gz new file mode 100644 index 0000000..641e7e6 --- /dev/null +++ b/vulkan-sdk-1.3.290.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6259184f829f9d8c01a343dd29c56a700cc3da71a17c439384687da98dee2cf4 +size 521623