commit 39ae9e7ec5db40b9d857559e3b4b22dc12ef6fd77b85fd5f4c6fcf5982a5c17e Author: Jan Engelhardt Date: Tue Jun 25 23:56:54 2024 +0000 - Add v283-to-2acb319.patch OBS-URL: https://build.opensuse.org/package/show/X11:Wayland/spirv-headers?expand=0&rev=100 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