From 508dc3a95de50de4a4d07d0a72a18e40d55b0e2e Mon Sep 17 00:00:00 2001 From: Ellie Hermaszewska Date: Tue, 29 Aug 2023 06:05:26 +0800 Subject: Allow bitwise or expressions and numeric literals in spirv_asm blocks (#3157) * Add -spirv-core-grammar option to load alternate spirv defs Also embed a version to use by default * Use perfect hash for spv op lookup * Neaten perfect hash embedding * Refactor spirv grammar lookup in preperation for more kinds of lookups * Load spirv capability list from spec * Add all SPIR-V enums to lookup table * regenerate vs projects * appease msvc * Use string slices for spir-v core grammar lookups * wiggle * comment * Add OpInfo for spv ops * regenerate vs projects * Embed op names * Add min/max operand counts and enum categories to spirv info * neaten * Operand kinds for spirv ops * Store and embed all information relating to spirv enums and qualifiers * Use SPIR-V spec to position instructions in spirv_asm blocks * Neaten spir-v info embedding * Neaten perfect hash embedding * Add assignment syntax to spirv_asm snippets * Better errors for spirv_asm parser * Add warning for too many operands in spirv asm * squash warnings * neaten * test wiggle * Lookup enums for spirv * Put OpCapability and OpExtension in the correct place for spirv_asm blocks * Tests for OpCapability and OpExtension * ci wiggle * Add expected failure * Allow raising immediate values to constant ids where necessary in spirv_asm blocks * Allow bitwise or expressions and numeric literals in spirv_asm blocks * test numeric literals * Fix memory issues. * fix. --------- Co-authored-by: Yong He --- .../compiler-core/compiler-core.vcxproj | 4 + .../compiler-core/compiler-core.vcxproj.filters | 12 + .../generate-lookup-tables.vcxproj | 34 - .../generate-spirv-embed.vcxproj | 164 + .../slang-spirv-embed-generator.vcxproj | 293 + .../slang-spirv-embed-generator.vcxproj.filters | 13 + build/visual-studio/slang/slang.vcxproj | 3 +- build/visual-studio/slang/slang.vcxproj.filters | 9 +- external/spirv/spirv-capabilities.txt | 238 - premake5.lua | 54 +- slang.h | 6 + slang.sln | 34 + source/compiler-core/slang-json-value.h | 5 + source/compiler-core/slang-misc-diagnostic-defs.h | 2 + source/compiler-core/slang-perfect-hash.cpp | 214 + source/compiler-core/slang-perfect-hash.h | 30 + source/compiler-core/slang-spirv-core-grammar.cpp | 340 + source/compiler-core/slang-spirv-core-grammar.h | 145 + source/core/slang-char-util.h | 4 + source/core/slang-common.h | 47 + source/core/slang-dictionary.h | 11 + source/core/slang-hash.h | 14 + source/core/slang-rtti-util.h | 47 +- source/core/slang-string-slice-pool.cpp | 3 + source/core/slang-string-util.cpp | 21 +- source/slang/slang-ast-dump.cpp | 3 + source/slang/slang-ast-expr.h | 28 +- source/slang/slang-check-expr.cpp | 125 +- source/slang/slang-compiler.h | 14 +- source/slang/slang-diagnostic-defs.h | 7 + source/slang/slang-emit-spirv.cpp | 106 +- source/slang/slang-ir-inst-defs.h | 11 +- source/slang/slang-ir-insts.h | 18 +- source/slang/slang-ir-spirv-legalize.cpp | 2 +- source/slang/slang-ir-spirv-legalize.h | 6 +- source/slang/slang-ir-spirv-snippet.cpp | 9 +- source/slang/slang-ir-spirv-snippet.h | 5 +- source/slang/slang-ir.cpp | 29 + source/slang/slang-lookup-glslstd450.cpp | 211 +- source/slang/slang-lookup-spirv.h | 2 - source/slang/slang-lookup-spvcapability.cpp | 303 - source/slang/slang-lookup-spvop.cpp | 813 -- source/slang/slang-lower-to-ir.cpp | 16 +- source/slang/slang-options.cpp | 17 + source/slang/slang-parser.cpp | 147 +- source/slang/slang-spirv-core-grammar-embed.cpp | 12451 +++++++++++++++++++ source/slang/slang.cpp | 31 + tests/expected-failure.txt | 3 +- .../spirv-asm/assignment-syntax.slang | 25 + .../spirv-asm/debug-instruction.slang | 29 + tests/language-feature/spirv-asm/enum-lookup.slang | 26 + tests/language-feature/spirv-asm/id-wrap.slang | 38 + .../language-feature/spirv-asm/opcapability.slang | 28 + tests/language-feature/spirv-asm/opextension.slang | 25 + .../spirv-asm/too-many-operands.slang | 26 + .../spirv-asm/typed-assignment-syntax.slang | 25 + .../spirv-asm/wrong-assignment-opcode.slang | 41 + .../lookup-generator-main.cpp | 222 +- .../spirv-embed-generator-main.cpp | 471 + 59 files changed, 15219 insertions(+), 1841 deletions(-) create mode 100644 build/visual-studio/generate-spirv-embed/generate-spirv-embed.vcxproj create mode 100644 build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj create mode 100644 build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj.filters delete mode 100644 external/spirv/spirv-capabilities.txt create mode 100644 source/compiler-core/slang-perfect-hash.cpp create mode 100644 source/compiler-core/slang-perfect-hash.h create mode 100644 source/compiler-core/slang-spirv-core-grammar.cpp create mode 100644 source/compiler-core/slang-spirv-core-grammar.h delete mode 100644 source/slang/slang-lookup-spvcapability.cpp delete mode 100644 source/slang/slang-lookup-spvop.cpp create mode 100644 source/slang/slang-spirv-core-grammar-embed.cpp create mode 100644 tests/language-feature/spirv-asm/assignment-syntax.slang create mode 100644 tests/language-feature/spirv-asm/debug-instruction.slang create mode 100644 tests/language-feature/spirv-asm/enum-lookup.slang create mode 100644 tests/language-feature/spirv-asm/id-wrap.slang create mode 100644 tests/language-feature/spirv-asm/opcapability.slang create mode 100644 tests/language-feature/spirv-asm/opextension.slang create mode 100644 tests/language-feature/spirv-asm/too-many-operands.slang create mode 100644 tests/language-feature/spirv-asm/typed-assignment-syntax.slang create mode 100644 tests/language-feature/spirv-asm/wrong-assignment-opcode.slang create mode 100644 tools/slang-spirv-embed-generator/spirv-embed-generator-main.cpp diff --git a/build/visual-studio/compiler-core/compiler-core.vcxproj b/build/visual-studio/compiler-core/compiler-core.vcxproj index cc3ac06da..cb33440f4 100644 --- a/build/visual-studio/compiler-core/compiler-core.vcxproj +++ b/build/visual-studio/compiler-core/compiler-core.vcxproj @@ -306,10 +306,12 @@ + + @@ -353,10 +355,12 @@ + + diff --git a/build/visual-studio/compiler-core/compiler-core.vcxproj.filters b/build/visual-studio/compiler-core/compiler-core.vcxproj.filters index c4d2737b2..14c7aa7da 100644 --- a/build/visual-studio/compiler-core/compiler-core.vcxproj.filters +++ b/build/visual-studio/compiler-core/compiler-core.vcxproj.filters @@ -132,6 +132,9 @@ Header Files + + Header Files + Header Files @@ -144,6 +147,9 @@ Header Files + + Header Files + Header Files @@ -269,6 +275,9 @@ Source Files + + Source Files + Source Files @@ -281,6 +290,9 @@ Source Files + + Source Files + Source Files diff --git a/build/visual-studio/generate-lookup-tables/generate-lookup-tables.vcxproj b/build/visual-studio/generate-lookup-tables/generate-lookup-tables.vcxproj index e558d3cb7..eaaffcb1c 100644 --- a/build/visual-studio/generate-lookup-tables/generate-lookup-tables.vcxproj +++ b/build/visual-studio/generate-lookup-tables/generate-lookup-tables.vcxproj @@ -157,40 +157,6 @@ ../../../external/spirv-headers/include/spirv/unified1/extinst.glsl.std.450.grammar.json;../../../bin/windows-x64/release/slang-lookup-generator.exe ../../../external/spirv-headers/include/spirv/unified1/extinst.glsl.std.450.grammar.json;../../../bin/windows-aarch64/release/slang-lookup-generator.exe - - Document - "../../../bin/windows-x86/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - "../../../bin/windows-x64/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - "../../../bin/windows-aarch64/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - "../../../bin/windows-x86/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - "../../../bin/windows-x64/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - "../../../bin/windows-aarch64/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvop.cpp SpvOp Spv spirv/unified1/spirv.h - ../../../source/slang/slang-lookup-spvop.cpp - slang-lookup-generator for slang-lookup-spvop.cpp - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x86/debug/slang-lookup-generator.exe - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x64/debug/slang-lookup-generator.exe - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-aarch64/debug/slang-lookup-generator.exe - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x86/release/slang-lookup-generator.exe - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x64/release/slang-lookup-generator.exe - ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-aarch64/release/slang-lookup-generator.exe - - - Document - "../../../bin/windows-x86/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - "../../../bin/windows-x64/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - "../../../bin/windows-aarch64/debug/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - "../../../bin/windows-x86/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - "../../../bin/windows-x64/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - "../../../bin/windows-aarch64/release/slang-lookup-generator" %(FullPath) $(SolutionDir)/source/slang/slang-lookup-spvcapability.cpp SpvCapability SpvCapability spirv/unified1/spirv.h - ../../../source/slang/slang-lookup-spvcapability.cpp - slang-lookup-generator for slang-lookup-spvcapability.cpp - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-x86/debug/slang-lookup-generator.exe - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-x64/debug/slang-lookup-generator.exe - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-aarch64/debug/slang-lookup-generator.exe - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-x86/release/slang-lookup-generator.exe - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-x64/release/slang-lookup-generator.exe - ../../../external/spirv/spirv-capabilities.txt;../../../bin/windows-aarch64/release/slang-lookup-generator.exe - diff --git a/build/visual-studio/generate-spirv-embed/generate-spirv-embed.vcxproj b/build/visual-studio/generate-spirv-embed/generate-spirv-embed.vcxproj new file mode 100644 index 000000000..8529cd788 --- /dev/null +++ b/build/visual-studio/generate-spirv-embed/generate-spirv-embed.vcxproj @@ -0,0 +1,164 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Debug + ARM64 + + + Debug aarch64 + Win32 + + + Debug aarch64 + x64 + + + Debug aarch64 + ARM64 + + + Release + Win32 + + + Release + x64 + + + Release + ARM64 + + + Release aarch64 + Win32 + + + Release aarch64 + x64 + + + Release aarch64 + ARM64 + + + + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4} + true + Win32Proj + generate-spirv-embed + + + + Utility + v142 + + + Utility + v142 + + + Utility + v142 + + + Utility + v142 + + + Utility + v142 + + + Utility + v142 + + + + + + + + + + + + + + + + + + + + + + + + + ..\..\..\bin\windows-x86\debug\ + ..\..\..\intermediate\windows-x86\debug\generate-spirv-embed\ + + + ..\..\..\bin\windows-x64\debug\ + ..\..\..\intermediate\windows-x64\debug\generate-spirv-embed\ + + + ..\..\..\bin\windows-aarch64\debug\ + ..\..\..\intermediate\windows-aarch64\debug\generate-spirv-embed\ + + + ..\..\..\bin\windows-x86\release\ + ..\..\..\intermediate\windows-x86\release\generate-spirv-embed\ + + + ..\..\..\bin\windows-x64\release\ + ..\..\..\intermediate\windows-x64\release\generate-spirv-embed\ + + + ..\..\..\bin\windows-aarch64\release\ + ..\..\..\intermediate\windows-aarch64\release\generate-spirv-embed\ + + + + + + + + + + + + + + + + Document + "../../../bin/windows-x86/debug/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + "../../../bin/windows-x64/debug/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + "../../../bin/windows-aarch64/debug/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + "../../../bin/windows-x86/release/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + "../../../bin/windows-x64/release/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + "../../../bin/windows-aarch64/release/slang-spirv-embed-generator" %(FullPath) $(SolutionDir)/source/slang/slang-spirv-core-grammar-embed.cpp + ../../../source/slang/slang-spirv-core-grammar-embed.cpp + slang-spirv-embed-generator for slang-spirv-core-grammar-embed.cpp + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x86/debug/slang-spirv-embed-generator.exe + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x64/debug/slang-spirv-embed-generator.exe + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-aarch64/debug/slang-spirv-embed-generator.exe + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x86/release/slang-spirv-embed-generator.exe + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-x64/release/slang-spirv-embed-generator.exe + ../../../external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json;../../../bin/windows-aarch64/release/slang-spirv-embed-generator.exe + + + + + + \ No newline at end of file diff --git a/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj b/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj new file mode 100644 index 000000000..7c2caf64b --- /dev/null +++ b/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj @@ -0,0 +1,293 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Debug + ARM64 + + + Debug aarch64 + Win32 + + + Debug aarch64 + x64 + + + Debug aarch64 + ARM64 + + + Release + Win32 + + + Release + x64 + + + Release + ARM64 + + + Release aarch64 + Win32 + + + Release aarch64 + x64 + + + Release aarch64 + ARM64 + + + + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB} + true + Win32Proj + slang-spirv-embed-generator + + + + Application + true + Unicode + v142 + + + Application + true + Unicode + v142 + + + Application + true + Unicode + v142 + true + + + Application + false + Unicode + v142 + + + Application + false + Unicode + v142 + + + Application + false + Unicode + v142 + true + + + + + + + + + + + + + + + + + + + + + + + + + true + ..\..\..\bin\windows-x86\debug\ + ..\..\..\intermediate\windows-x86\debug\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + true + ..\..\..\bin\windows-x64\debug\ + ..\..\..\intermediate\windows-x64\debug\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + true + ..\..\..\bin\windows-aarch64\debug\ + ..\..\..\intermediate\windows-aarch64\debug\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + false + ..\..\..\bin\windows-x86\release\ + ..\..\..\intermediate\windows-x86\release\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + false + ..\..\..\bin\windows-x64\release\ + ..\..\..\intermediate\windows-x64\release\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + false + ..\..\..\bin\windows-aarch64\release\ + ..\..\..\intermediate\windows-aarch64\release\slang-spirv-embed-generator\ + slang-spirv-embed-generator + .exe + + + + NotUsing + Level3 + _DEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + ProgramDatabase + Disabled + false + MultiThreadedDebug + true + stdcpp17 + + + Console + true + + + + + NotUsing + Level3 + _DEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + ProgramDatabase + Disabled + false + MultiThreadedDebug + true + stdcpp17 + + + Console + true + + + + + NotUsing + Level3 + _DEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + ProgramDatabase + Disabled + false + MultiThreadedDebug + true + stdcpp17 + + + Console + true + + + + + NotUsing + Level3 + NDEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + Full + true + true + false + true + MultiThreaded + true + stdcpp17 + + + Console + true + true + + + + + NotUsing + Level3 + NDEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + Full + true + true + false + true + MultiThreaded + true + stdcpp17 + + + Console + true + true + + + + + NotUsing + Level3 + NDEBUG;WIN32_LEAN_AND_MEAN;VC_EXTRALEAN;NOMINMAX;%(PreprocessorDefinitions) + ..\..\..;%(AdditionalIncludeDirectories) + Full + true + true + false + true + MultiThreaded + true + stdcpp17 + + + Console + true + true + + + + + + + + {12C1E89D-F5D0-41D3-8E8D-FB3F358F8126} + + + {F9BE7957-8399-899E-0C49-E714FDDD4B65} + + + + + + \ No newline at end of file diff --git a/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj.filters b/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj.filters new file mode 100644 index 000000000..0b113e25a --- /dev/null +++ b/build/visual-studio/slang-spirv-embed-generator/slang-spirv-embed-generator.vcxproj.filters @@ -0,0 +1,13 @@ + + + + + {E9C7FDCE-D52A-8D73-7EB0-C5296AF258F6} + + + + + Source Files + + + \ No newline at end of file diff --git a/build/visual-studio/slang/slang.vcxproj b/build/visual-studio/slang/slang.vcxproj index 573e4dff2..f5963d130 100644 --- a/build/visual-studio/slang/slang.vcxproj +++ b/build/visual-studio/slang/slang.vcxproj @@ -688,8 +688,6 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla - - @@ -712,6 +710,7 @@ IF EXIST ..\..\..\external\slang-glslang\bin\windows-aarch64\release\slang-glsla + diff --git a/build/visual-studio/slang/slang.vcxproj.filters b/build/visual-studio/slang/slang.vcxproj.filters index 1eca9a115..fc6da0943 100644 --- a/build/visual-studio/slang/slang.vcxproj.filters +++ b/build/visual-studio/slang/slang.vcxproj.filters @@ -1148,12 +1148,6 @@ Source Files - - Source Files - - - Source Files - Source Files @@ -1220,6 +1214,9 @@ Source Files + + Source Files + Source Files diff --git a/external/spirv/spirv-capabilities.txt b/external/spirv/spirv-capabilities.txt deleted file mode 100644 index abdd73fc0..000000000 --- a/external/spirv/spirv-capabilities.txt +++ /dev/null @@ -1,238 +0,0 @@ -Matrix -Shader -Geometry -Tessellation -Addresses -Linkage -Kernel -Vector16 -Float16Buffer -Float16 -Float64 -Int64 -Int64Atomics -ImageBasic -ImageReadWrite -ImageMipmap -Pipes -Groups -DeviceEnqueue -LiteralSampler -AtomicStorage -Int16 -TessellationPointSize -GeometryPointSize -ImageGatherExtended -StorageImageMultisample -UniformBufferArrayDynamicIndexing -SampledImageArrayDynamicIndexing -StorageBufferArrayDynamicIndexing -StorageImageArrayDynamicIndexing -ClipDistance -CullDistance -ImageCubeArray -SampleRateShading -ImageRect -SampledRect -GenericPointer -Int8 -InputAttachment -SparseResidency -MinLod -Sampled1D -Image1D -SampledCubeArray -SampledBuffer -ImageBuffer -ImageMSArray -StorageImageExtendedFormats -ImageQuery -DerivativeControl -InterpolationFunction -TransformFeedback -GeometryStreams -StorageImageReadWithoutFormat -StorageImageWriteWithoutFormat -MultiViewport -SubgroupDispatch -NamedBarrier -PipeStorage -GroupNonUniform -GroupNonUniformVote -GroupNonUniformArithmetic -GroupNonUniformBallot -GroupNonUniformShuffle -GroupNonUniformShuffleRelative -GroupNonUniformClustered -GroupNonUniformQuad -ShaderLayer -ShaderViewportIndex -UniformDecoration -CoreBuiltinsARM -TileImageColorReadAccessEXT -TileImageDepthReadAccessEXT -TileImageStencilReadAccessEXT -FragmentShadingRateKHR -SubgroupBallotKHR -DrawParameters -WorkgroupMemoryExplicitLayoutKHR -WorkgroupMemoryExplicitLayout8BitAccessKHR -WorkgroupMemoryExplicitLayout16BitAccessKHR -SubgroupVoteKHR -StorageBuffer16BitAccess -StorageUniformBufferBlock16 -StorageUniform16 -UniformAndStorageBuffer16BitAccess -StoragePushConstant16 -StorageInputOutput16 -DeviceGroup -MultiView -VariablePointersStorageBuffer -VariablePointers -AtomicStorageOps -SampleMaskPostDepthCoverage -StorageBuffer8BitAccess -UniformAndStorageBuffer8BitAccess -StoragePushConstant8 -DenormPreserve -DenormFlushToZero -SignedZeroInfNanPreserve -RoundingModeRTE -RoundingModeRTZ -RayQueryProvisionalKHR -RayQueryKHR -RayTraversalPrimitiveCullingKHR -RayTracingKHR -Float16ImageAMD -ImageGatherBiasLodAMD -FragmentMaskAMD -StencilExportEXT -ImageReadWriteLodAMD -Int64ImageEXT -ShaderClockKHR -SampleMaskOverrideCoverageNV -GeometryShaderPassthroughNV -ShaderViewportIndexLayerEXT -ShaderViewportIndexLayerNV -ShaderViewportMaskNV -ShaderStereoViewNV -PerViewAttributesNV -FragmentFullyCoveredEXT -MeshShadingNV -ImageFootprintNV -MeshShadingEXT -FragmentBarycentricKHR -FragmentBarycentricNV -ComputeDerivativeGroupQuadsNV -FragmentDensityEXT -ShadingRateNV -GroupNonUniformPartitionedNV -ShaderNonUniform -ShaderNonUniformEXT -RuntimeDescriptorArray -RuntimeDescriptorArrayEXT -InputAttachmentArrayDynamicIndexing -InputAttachmentArrayDynamicIndexingEXT -UniformTexelBufferArrayDynamicIndexing -UniformTexelBufferArrayDynamicIndexingEXT -StorageTexelBufferArrayDynamicIndexing -StorageTexelBufferArrayDynamicIndexingEXT -UniformBufferArrayNonUniformIndexing -UniformBufferArrayNonUniformIndexingEXT -SampledImageArrayNonUniformIndexing -SampledImageArrayNonUniformIndexingEXT -StorageBufferArrayNonUniformIndexing -StorageBufferArrayNonUniformIndexingEXT -StorageImageArrayNonUniformIndexing -StorageImageArrayNonUniformIndexingEXT -InputAttachmentArrayNonUniformIndexing -InputAttachmentArrayNonUniformIndexingEXT -UniformTexelBufferArrayNonUniformIndexing -UniformTexelBufferArrayNonUniformIndexingEXT -StorageTexelBufferArrayNonUniformIndexing -StorageTexelBufferArrayNonUniformIndexingEXT -RayTracingPositionFetchKHR -RayTracingNV -RayTracingMotionBlurNV -VulkanMemoryModel -VulkanMemoryModelKHR -VulkanMemoryModelDeviceScope -VulkanMemoryModelDeviceScopeKHR -PhysicalStorageBufferAddresses -PhysicalStorageBufferAddressesEXT -ComputeDerivativeGroupLinearNV -RayTracingProvisionalKHR -CooperativeMatrixNV -FragmentShaderSampleInterlockEXT -FragmentShaderShadingRateInterlockEXT -ShaderSMBuiltinsNV -FragmentShaderPixelInterlockEXT -DemoteToHelperInvocation -DemoteToHelperInvocationEXT -RayTracingOpacityMicromapEXT -ShaderInvocationReorderNV -BindlessTextureNV -RayQueryPositionFetchKHR -SubgroupShuffleINTEL -SubgroupBufferBlockIOINTEL -SubgroupImageBlockIOINTEL -SubgroupImageMediaBlockIOINTEL -RoundToInfinityINTEL -FloatingPointModeINTEL -IntegerFunctions2INTEL -FunctionPointersINTEL -IndirectReferencesINTEL -AsmINTEL -AtomicFloat32MinMaxEXT -AtomicFloat64MinMaxEXT -AtomicFloat16MinMaxEXT -VectorComputeINTEL -VectorAnyINTEL -ExpectAssumeKHR -SubgroupAvcMotionEstimationINTEL -SubgroupAvcMotionEstimationIntraINTEL -SubgroupAvcMotionEstimationChromaINTEL -VariableLengthArrayINTEL -FunctionFloatControlINTEL -FPGAMemoryAttributesINTEL -FPFastMathModeINTEL -ArbitraryPrecisionIntegersINTEL -ArbitraryPrecisionFloatingPointINTEL -UnstructuredLoopControlsINTEL -FPGALoopControlsINTEL -KernelAttributesINTEL -FPGAKernelAttributesINTEL -FPGAMemoryAccessesINTEL -FPGAClusterAttributesINTEL -LoopFuseINTEL -FPGADSPControlINTEL -MemoryAccessAliasingINTEL -FPGAInvocationPipeliningAttributesINTEL -FPGABufferLocationINTEL -ArbitraryPrecisionFixedPointINTEL -USMStorageClassesINTEL -RuntimeAlignedAttributeINTEL -IOPipesINTEL -BlockingPipesINTEL -FPGARegINTEL -DotProductInputAll -DotProductInputAllKHR -DotProductInput4x8Bit -DotProductInput4x8BitKHR -DotProductInput4x8BitPacked -DotProductInput4x8BitPackedKHR -DotProduct -DotProductKHR -RayCullMaskKHR -BitInstructions -GroupNonUniformRotateKHR -AtomicFloat32AddEXT -AtomicFloat64AddEXT -LongConstantCompositeINTEL -OptNoneINTEL -AtomicFloat16AddEXT -DebugInfoModuleINTEL -SplitBarrierINTEL -FPGAArgumentInterfacesINTEL -GroupUniformArithmeticKHR -Max \ No newline at end of file diff --git a/premake5.lua b/premake5.lua index 81f5f6c6b..e7b3774e2 100644 --- a/premake5.lua +++ b/premake5.lua @@ -958,6 +958,12 @@ tool "slang-cpp-extractor" links { "compiler-core", "core" } +tool "slang-spirv-embed-generator" + uuid "8da787cc-0e04-450f-8e29-88eac5ebe9bb" + includedirs { "." } + + links { "compiler-core", "core" } + tool "slang-lookup-generator" uuid "3242baa7-fc4c-4f76-83bc-e4403099dc1d" includedirs { "." } @@ -1397,6 +1403,39 @@ generatorProject("run-generators", nil) filter { } +generatorProject("generate-spirv-embed") + tables = { + { + json = "external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json", + }, + } + for _, t in pairs(tables) do + files {t.json} + end + + dependson { "slang-spirv-embed-generator" } + + local builddir = getBuildDir() + if executeBinary then + for _, t in pairs(tables) do + filter("files:" .. t.json) + + local inJson = "%{file.abspath}" + local cppFilename = "slang-spirv-core-grammar-embed.cpp" + local cppPath = "%{wks.location}/source/slang/" .. cppFilename + local buildcmd = '"' .. builddir .. '/slang-spirv-embed-generator" ' + .. inJson .. " " + .. cppPath + + buildmessage ("slang-spirv-embed-generator for " .. cppFilename) + buildcommands { buildcmd } + buildinputs { inJson, builddir .. "/slang-spirv-embed-generator" .. getExecutableSuffix() } + buildoutputs (cppPath) + end + end + + filter { } + generatorProject("generate-lookup-tables") tables = { { @@ -1405,18 +1444,6 @@ generatorProject("generate-lookup-tables") prefix = "GLSLstd450", type = "GLSLstd450" }, - { - json = "external/spirv-headers/include/spirv/unified1/spirv.core.grammar.json", - header = "spirv/unified1/spirv.h", - prefix = "Spv", - type = "SpvOp" - }, - { - json = "external/spirv/spirv-capabilities.txt", - header = "spirv/unified1/spirv.h", - prefix = "SpvCapability", - type = "SpvCapability" - }, } for _, t in pairs(tables) do files {t.json} @@ -1606,9 +1633,7 @@ standardProject("slang", "source/slang") -- Similarly for any generated lookup tables files { - "source/slang/slang-lookup-spvop.cpp", "source/slang/slang-lookup-glslstd450.cpp", - "source/slang/slang-lookup-spvcapability.cpp", } -- @@ -1620,6 +1645,7 @@ standardProject("slang", "source/slang") if not skipSourceGeneration then dependson { "run-generators" } dependson { "generate-lookup-tables" } + dependson { "generate-spirv-embed" } end -- If we have slang-llvm copy it diff --git a/slang.h b/slang.h index 6c00e8f01..0d9c0b44a 100644 --- a/slang.h +++ b/slang.h @@ -3526,6 +3526,12 @@ namespace slang /** Get the time in seconds spent in the slang and downstream compiler. */ virtual SLANG_NO_THROW void SLANG_MCALL getCompilerElapsedTime(double* outTotalTime, double* outDownstreamTime) = 0; + + /** Specify a spirv.core.grammar.json file to load and use when + * parsing and checking any SPIR-V code + */ + virtual SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar( + char const* jsonPath) = 0; }; #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid() diff --git a/slang.sln b/slang.sln index 8f682f3d3..51d1691f1 100644 --- a/slang.sln +++ b/slang.sln @@ -25,6 +25,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slang-generate", "build\vis EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slang-lookup-generator", "build\visual-studio\slang-lookup-generator\slang-lookup-generator.vcxproj", "{3242BAA7-FC4C-4F76-83BC-E4403099DC1D}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slang-spirv-embed-generator", "build\visual-studio\slang-spirv-embed-generator\slang-spirv-embed-generator.vcxproj", "{8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}" +EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slangd", "build\visual-studio\slangd\slangd.vcxproj", "{B2D63B45-92B0-40F7-B242-CCA4DFD64341}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test-process", "build\visual-studio\test-process\test-process.vcxproj", "{BE412850-4BB9-429A-877C-BFBC4B34186C}" @@ -68,6 +70,11 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "generate-lookup-tables", "b {3242BAA7-FC4C-4F76-83BC-E4403099DC1D} = {3242BAA7-FC4C-4F76-83BC-E4403099DC1D} EndProjectSection EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "generate-spirv-embed", "build\visual-studio\generate-spirv-embed\generate-spirv-embed.vcxproj", "{FB5DA174-E7EC-2A3E-900B-3F397C793BE4}" + ProjectSection(ProjectDependencies) = postProject + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB} = {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB} + EndProjectSection +EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "run-generators", "build\visual-studio\run-generators\run-generators.vcxproj", "{E145B2B8-CD13-A6BE-B6A7-16E5A2148223}" ProjectSection(ProjectDependencies) = postProject {CA8A30D1-8FA9-4330-B7F7-84709246D8DC} = {CA8A30D1-8FA9-4330-B7F7-84709246D8DC} @@ -83,6 +90,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slang", "build\visual-studi ProjectSection(ProjectDependencies) = postProject {E145B2B8-CD13-A6BE-B6A7-16E5A2148223} = {E145B2B8-CD13-A6BE-B6A7-16E5A2148223} {5FFA0764-4BF4-30B6-3461-C7C620FA9622} = {5FFA0764-4BF4-30B6-3461-C7C620FA9622} + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4} = {FB5DA174-E7EC-2A3E-900B-3F397C793BE4} EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "slang-rt", "build\visual-studio\slang-rt\slang-rt.vcxproj", "{DFC79D72-91DE-434C-871B-B3943B488BEB}" @@ -205,6 +213,18 @@ Global {3242BAA7-FC4C-4F76-83BC-E4403099DC1D}.Release|Win32.Build.0 = Release|Win32 {3242BAA7-FC4C-4F76-83BC-E4403099DC1D}.Release|x64.ActiveCfg = Release|x64 {3242BAA7-FC4C-4F76-83BC-E4403099DC1D}.Release|x64.Build.0 = Release|x64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|aarch64.ActiveCfg = Debug aarch64|ARM64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|aarch64.Build.0 = Debug aarch64|ARM64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|Win32.ActiveCfg = Debug|Win32 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|Win32.Build.0 = Debug|Win32 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|x64.ActiveCfg = Debug|x64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Debug|x64.Build.0 = Debug|x64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|aarch64.ActiveCfg = Release aarch64|ARM64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|aarch64.Build.0 = Release aarch64|ARM64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|Win32.ActiveCfg = Release|Win32 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|Win32.Build.0 = Release|Win32 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|x64.ActiveCfg = Release|x64 + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB}.Release|x64.Build.0 = Release|x64 {B2D63B45-92B0-40F7-B242-CCA4DFD64341}.Debug|aarch64.ActiveCfg = Debug aarch64|ARM64 {B2D63B45-92B0-40F7-B242-CCA4DFD64341}.Debug|aarch64.Build.0 = Debug aarch64|ARM64 {B2D63B45-92B0-40F7-B242-CCA4DFD64341}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -421,6 +441,18 @@ Global {5FFA0764-4BF4-30B6-3461-C7C620FA9622}.Release|Win32.Build.0 = Release|Win32 {5FFA0764-4BF4-30B6-3461-C7C620FA9622}.Release|x64.ActiveCfg = Release|x64 {5FFA0764-4BF4-30B6-3461-C7C620FA9622}.Release|x64.Build.0 = Release|x64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|aarch64.ActiveCfg = Debug aarch64|ARM64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|aarch64.Build.0 = Debug aarch64|ARM64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|Win32.ActiveCfg = Debug|Win32 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|Win32.Build.0 = Debug|Win32 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|x64.ActiveCfg = Debug|x64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Debug|x64.Build.0 = Debug|x64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|aarch64.ActiveCfg = Release aarch64|ARM64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|aarch64.Build.0 = Release aarch64|ARM64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|Win32.ActiveCfg = Release|Win32 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|Win32.Build.0 = Release|Win32 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|x64.ActiveCfg = Release|x64 + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4}.Release|x64.Build.0 = Release|x64 {E145B2B8-CD13-A6BE-B6A7-16E5A2148223}.Debug|aarch64.ActiveCfg = Debug aarch64|ARM64 {E145B2B8-CD13-A6BE-B6A7-16E5A2148223}.Debug|aarch64.Build.0 = Debug aarch64|ARM64 {E145B2B8-CD13-A6BE-B6A7-16E5A2148223}.Debug|Win32.ActiveCfg = Debug|Win32 @@ -554,6 +586,7 @@ Global {7F773DD9-EB8F-2403-B43C-B49C2014B99C} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} {66174227-8541-41FC-A6DF-4764FC66F78E} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} {3242BAA7-FC4C-4F76-83BC-E4403099DC1D} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} + {8DA787CC-0E04-450F-8E29-88EAC5EBE9BB} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} {B2D63B45-92B0-40F7-B242-CCA4DFD64341} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} {BE412850-4BB9-429A-877C-BFBC4B34186C} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} {23149706-C12F-4329-B6AA-8266407C32D3} = {FD47AE19-69FD-260F-F2F1-20E65EA61D13} @@ -570,6 +603,7 @@ Global {0FC5DE93-FBEA-A8FA-E430-2EC6D0F5CDC6} = {EB5FC2C6-D72D-B6CC-C0C1-26F3AC2E9231} {3BB99068-27C9-3C39-9082-A1577CB12BD2} = {EB5FC2C6-D72D-B6CC-C0C1-26F3AC2E9231} {5FFA0764-4BF4-30B6-3461-C7C620FA9622} = {F3AB4ED5-5F37-BC99-6848-3F8ED452189A} + {FB5DA174-E7EC-2A3E-900B-3F397C793BE4} = {F3AB4ED5-5F37-BC99-6848-3F8ED452189A} {E145B2B8-CD13-A6BE-B6A7-16E5A2148223} = {F3AB4ED5-5F37-BC99-6848-3F8ED452189A} {092DAB9F-1DA5-4538-ADD7-1A8D1DBFD519} = {57B5AA5E-C340-1823-CC51-9B17385C7423} {61F7EB00-7281-4BF3-9470-7C2EA92620C3} = {57B5AA5E-C340-1823-CC51-9B17385C7423} diff --git a/source/compiler-core/slang-json-value.h b/source/compiler-core/slang-json-value.h index 25e74cb36..0abe7c9a6 100644 --- a/source/compiler-core/slang-json-value.h +++ b/source/compiler-core/slang-json-value.h @@ -311,6 +311,11 @@ public: /// Returns true if all the keys are unique static bool areKeysUnique(const JSONKeyValue* keyValues, Index keyValueCount); + /// Access the internal set of strings, removing anything from this + /// will invalidate the container, so only do it immediately prior to + /// destruction. + StringSlicePool& getStringSlicePool() {return m_slicePool;}; + protected: struct Range { diff --git a/source/compiler-core/slang-misc-diagnostic-defs.h b/source/compiler-core/slang-misc-diagnostic-defs.h index aed83eb30..a2ccc4657 100644 --- a/source/compiler-core/slang-misc-diagnostic-defs.h +++ b/source/compiler-core/slang-misc-diagnostic-defs.h @@ -33,4 +33,6 @@ DIAGNOSTIC(100005, Error, invalidArgumentForOption, "invalid argument format for DIAGNOSTIC(99999, Note, noteLocationOfInternalError, "an internal error threw an exception while working on code near this location") +DIAGNOSTIC(29104, Error, spirvCoreGrammarJSONParseFailure, "unexpected JSON in spirv core grammar file: $0") + #undef DIAGNOSTIC diff --git a/source/compiler-core/slang-perfect-hash.cpp b/source/compiler-core/slang-perfect-hash.cpp new file mode 100644 index 000000000..bfe8d4876 --- /dev/null +++ b/source/compiler-core/slang-perfect-hash.cpp @@ -0,0 +1,214 @@ +#include "slang-perfect-hash.h" + +#include "../core/slang-string-util.h" +#include "../core/slang-writer.h" + +namespace Slang +{ + +// Implemented according to "Hash, displace, and compress" +// https://cmph.sourceforge.net/papers/esa09.pdf +HashFindResult minimalPerfectHash(const List& ss, HashParams& hashParams) +{ + // Check for uniqueness + for (Index i = 0; i < ss.getCount(); ++i) + { + for (Index j = i + 1; j < ss.getCount(); ++j) + { + if (ss[i] == ss[j]) + { + return HashFindResult::NonUniqueKeys; + } + } + } + + SLANG_ASSERT(UIndex(ss.getCount()) < std::numeric_limits::max()); + const UInt32 nBuckets = UInt32(ss.getCount()); + List> initialBuckets; + initialBuckets.setCount(nBuckets); + + const auto hash = [&](const String& s, const HashCode32 salt = 0) -> UInt32 + { + // + // The current getStableHashCode is susceptible to patterns of + // collisions causing the search to fail for the SPIR-V opnames; it + // performs poorly on short strings, taking over 300000 iterations to + // diverge on "Ceil" and "FMix" (and place them in already unoccupied + // slots)! + // + // Use FNV Hash here which seem perform much better on these short inputs + // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function + // + // If you change this, don't forget to also sync the version below in + // the printing code. + UInt32 h = salt; + for (const char c : s) + h = (h * 0x01000193) ^ c; + return h % nBuckets; + }; + + // Assign the inputs into their buckets according to the hash without salt. + // Sort the buckets according to size, so that later we can make these have + // unique destinations starting with the largest ones first as they are at + // most risk of collision. + for (const auto& s : ss) + { + initialBuckets[hash(s)].add(s); + } + initialBuckets.stableSort([](const List& a, const List& b) { return a.getCount() > b.getCount(); }); + + // These are our outputs, the salts are calculated such that for all input + // word, x, hash(x, salt[hash(x, 0)]) is unique + // + // We keep the final table as we need to detect when we've been given a + // word not in our language. + hashParams.saltTable.setCount(nBuckets); + for (auto& s : hashParams.saltTable) + s = 0; + hashParams.destTable.setCount(nBuckets); + for (auto& s : hashParams.destTable) + s.reduceLength(0); + + // This mask will, in each salt tryout, be used to prevent collisions + // within a single bucket. + List bucketDestinations = List::makeRepeated(false, nBuckets); + + for (const auto& b : initialBuckets) + { + // Break if we've reached the empty buckets + if (!b.getCount()) + { + break; + } + + // Try out all the salts until we get one which has no internal + // collisions for this bucket and also no collisions with the buckets + // we've processed so far. + UInt32 salt = 1; + while (true) + { + bool collision = false; + for (auto& d : bucketDestinations) + { + d = false; + } + + for (const auto& s : b) + { + const auto i = hash(s, salt); + if (hashParams.destTable[i].getLength() || bucketDestinations[i]) + { + collision = true; + break; + } + bucketDestinations[i] = true; + } + if (!collision) + { + break; + } + salt++; + + // If we fail to find a solution after some massive amount of tries + // it's almost certainly because of some property of the hash + // function and language causing an irresolvable collision. + if (salt > 10000 * nBuckets) + { + return HashFindResult::UnavoidableHashCollision; + } + } + for (const auto& s : b) + { + hashParams.saltTable[hash(s)] = salt; + hashParams.destTable[hash(s, salt)] = s; + } + } + return HashFindResult::Success; +} + +String perfectHashToEmbeddableCpp( + const HashParams& hashParams, + const UnownedStringSlice& valueType, + const UnownedStringSlice& funcName, + const List& values) +{ + SLANG_ASSERT(hashParams.saltTable.getCount() == hashParams.destTable.getCount()); + SLANG_ASSERT(hashParams.saltTable.getCount() == values.getCount()); + + StringBuilder sb; + StringWriter writer(&sb, WriterFlags(0)); + WriterHelper w(&writer); + const auto line = [&](const char* l){ + w.put(l); + w.put("\n"); + }; + + w.print("bool %s(const UnownedStringSlice& str, %s& value)\n", String(funcName).getBuffer(), String(valueType).getBuffer()); + line("{"); + + w.print(" static const unsigned tableSalt[%ld] = {\n", hashParams.saltTable.getCount()); + w.print(" "); + for (Index i = 0; i < hashParams.saltTable.getCount(); ++i) + { + const auto salt = hashParams.saltTable[i]; + if (i != hashParams.saltTable.getCount() - 1) + { + w.print(" %d,", salt); + if (i % 16 == 15) + { + w.print("\n "); + } + } + else + { + w.print(" %d", salt); + } + } + line("\n };"); + line(""); + + w.print(" using KV = std::pair;\n", String(valueType).getBuffer()); + line(""); + + w.print(" static const KV words[%ld] =\n", hashParams.destTable.getCount()); + line(" {"); + for (Index i = 0; i < hashParams.destTable.getCount(); ++i) + { + const auto& s = hashParams.destTable[i]; + const auto& v = values[i]; + w.print( + " {\"%s\", %s},\n", + s.getBuffer(), + v.getBuffer() + ); + } + line(" };"); + line(""); + + // Make sure to update the hash function in the search function above if + // you change this. + line(" static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){"); + line(" UInt32 h = salt;"); + line(" for (const char c : str)"); + line(" h = (h * 0x01000193) ^ c;"); + w.print(" return h %% %ld;\n", hashParams.saltTable.getCount()); + line(" };"); + line(""); + + line(" const auto i = hash(str, tableSalt[hash(str, 0)]);"); + line(" if(str == words[i].first)"); + line(" {"); + line(" value = words[i].second;"); + line(" return true;"); + line(" }"); + line(" else"); + line(" {"); + line(" return false;"); + line(" }"); + line("}"); + line(""); + + return sb; +} + +} diff --git a/source/compiler-core/slang-perfect-hash.h b/source/compiler-core/slang-perfect-hash.h new file mode 100644 index 000000000..1488c7a62 --- /dev/null +++ b/source/compiler-core/slang-perfect-hash.h @@ -0,0 +1,30 @@ +#pragma once + +#include "../core/slang-string.h" +#include "../core/slang-list.h" + +namespace Slang +{ + +struct HashParams +{ + List saltTable; + List destTable; +}; + +enum class HashFindResult { + Success, + NonUniqueKeys, + UnavoidableHashCollision, +}; + +// Calculate a minimal perfect hash of a list of input strings +HashFindResult minimalPerfectHash(const List& ss, HashParams& hashParams); + +String perfectHashToEmbeddableCpp( + const HashParams& hashParams, + const UnownedStringSlice& valueType, + const UnownedStringSlice& funcName, + const List& values); + +} diff --git a/source/compiler-core/slang-spirv-core-grammar.cpp b/source/compiler-core/slang-spirv-core-grammar.cpp new file mode 100644 index 000000000..8140d002a --- /dev/null +++ b/source/compiler-core/slang-spirv-core-grammar.cpp @@ -0,0 +1,340 @@ +#include "slang-spirv-core-grammar.h" + +#include "../core/slang-rtti-util.h" +#include "../core/slang-string-util.h" +#include "slang-json-native.h" +#include "slang-core-diagnostics.h" +#include + +namespace Slang +{ +using SpvWord = uint32_t; + +// +// Structs which mirror the structure of spirv.core.grammar.json +// +// Commented members are those which currently don't use +struct InstructionPrintingClass +{ + UnownedStringSlice tag; + UnownedStringSlice heading; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + InstructionPrintingClass, + SLANG_RTTI_FIELD(tag), + SLANG_OPTIONAL_RTTI_FIELD(heading) +); + +struct Operand +{ + UnownedStringSlice kind; + UnownedStringSlice quantifier; + // UnownedStringSlice name; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + Operand, + SLANG_RTTI_FIELD(kind), + SLANG_OPTIONAL_RTTI_FIELD(quantifier) + //SLANG_RTTI_FIELD(name), +); + +struct Instruction +{ + UnownedStringSlice opname; + UnownedStringSlice class_; + SpvWord opcode; + List capabilities; + List operands; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + Instruction, + SLANG_RTTI_FIELD(opname), + SLANG_RTTI_FIELD_IMPL(class_, "class", 0), + SLANG_RTTI_FIELD(opcode), + SLANG_OPTIONAL_RTTI_FIELD(capabilities), + SLANG_OPTIONAL_RTTI_FIELD(operands) +); + +struct Enumerant +{ + UnownedStringSlice enumerant; + JSONValue value; + List capabilities; + // List parameters; + // UnownedStringSlice version; + // UnownedStringSlice lastVersion; + // List extensions; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + Enumerant, + SLANG_RTTI_FIELD(enumerant), + SLANG_RTTI_FIELD(value), + SLANG_OPTIONAL_RTTI_FIELD(capabilities), + // SLANG_OPTIONAL_RTTI_FIELD(parameters), + // SLANG_OPTIONAL_RTTI_FIELD(version), + // SLANG_OPTIONAL_RTTI_FIELD(lastVersion), + // SLANG_OPTIONAL_RTTI_FIELD(extensions) +); + +struct OperandKind +{ + UnownedStringSlice category; + UnownedStringSlice kind; + List enumerants; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + OperandKind, + SLANG_RTTI_FIELD(category), + SLANG_RTTI_FIELD(kind), + SLANG_OPTIONAL_RTTI_FIELD(enumerants) +); + +struct SPIRVSpec +{ + // List copyright; + // UnownedStringSlice magic_number; + // UInt32 major_version; + // UInt32 minor_version; + // UInt32 revision; + List instruction_printing_class; + List instructions; + List operand_kinds; +}; +SLANG_MAKE_STRUCT_RTTI_INFO( + SPIRVSpec, + // SLANG_RTTI_FIELD(copyright), + // SLANG_RTTI_FIELD(magic_number), + // SLANG_RTTI_FIELD(major_version) + // SLANG_RTTI_FIELD(minor_version) + // SLANG_RTTI_FIELD(revision) + SLANG_RTTI_FIELD(instruction_printing_class), + SLANG_RTTI_FIELD(instructions), + SLANG_RTTI_FIELD(operand_kinds) +); + +static Dictionary operandKindToDict( + JSONContainer& container, + DiagnosticSink& sink, + const OperandKind& k) +{ + Dictionary dict; + dict.reserve(k.enumerants.getCount()); + for(const auto& e : k.enumerants) + { + SpvWord valueInt = 0; + switch(e.value.getKind()) + { + case JSONValue::Kind::Integer: + { + // TODO: Range check here? + valueInt = SpvWord(container.asInteger(e.value)); + break; + } + case JSONValue::Kind::String: + { + Int i = 0; + const auto str = container.getString(e.value); + if(SLANG_FAILED(StringUtil::parseInt(str, i))) + sink.diagnose( + e.value.loc, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "Expected an integer value" + ); + // TODO: Range check here? + valueInt = SpvWord(i); + break; + } + default: + sink.diagnose( + e.value.loc, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "Expected an integer value (or a string with an integer inside)" + ); + } + dict.add(e.enumerant, valueInt); + } + return dict; +} + +// +// +// +RefPtr SPIRVCoreGrammarInfo::loadFromJSON(SourceView& source, DiagnosticSink& sink) +{ + // + // Load the JSON + // + SLANG_ASSERT(source.getSourceManager() == sink.getSourceManager()); + JSONLexer lexer; + lexer.init(&source, &sink); + JSONParser parser; + JSONContainer container(sink.getSourceManager()); + JSONBuilder builder(&container); + RttiTypeFuncsMap typeMap; + typeMap = JSONNativeUtil::getTypeFuncsMap(); + SLANG_RETURN_NULL_ON_FAIL(parser.parse(&lexer, &source, &builder, &sink)); + JSONToNativeConverter converter(&container, &typeMap, &sink); + SPIRVSpec spec; + if(SLANG_FAILED(converter.convert(builder.getRootValue(), &spec))) + { + // TODO: not having a source loc here is not great... + sink.diagnoseWithoutSourceView( + SourceLoc{}, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "Failed to match SPIR-V grammar JSON to the expected schema" + ); + return nullptr; + } + + // + // Convert to the internal representation + // + RefPtr res{new SPIRVCoreGrammarInfo}; + + res->operandKinds.dict.reserve(spec.operand_kinds.getCount()); + uint32_t operandKindIndex = 0; + for(const auto& c : spec.operand_kinds) + { + if(operandKindIndex > std::numeric_limits::max()) + { + sink.diagnoseWithoutSourceView( + SourceLoc{}, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "Too many enum categories, expected fewer than 256" + ); + } + res->operandKinds.dict.add(c.kind, {static_cast(operandKindIndex)}); + operandKindIndex++; + } + + // It's important we reserve the memory now, as we require the iterators to + // be stable, as references to them are maintained by the OpInfo structs. + Index totalNumOperands = 0; + for(const auto& i : spec.instructions) + totalNumOperands += i.operands.getCapacity(); + res->operandTypesStorage.reserve(totalNumOperands); + + res->opcodes.dict.reserve(spec.instructions.getCount()); + for(const auto& i : spec.instructions) + { + res->opcodes.dict.add(i.opname, SpvOp(i.opcode)); + + const auto class_ = + i.class_ == "Type-Declaration" ? OpInfo::TypeDeclaration + : i.class_ == "Constant-Creation" ? OpInfo::ConstantCreation + : i.class_ == "Debug" ? OpInfo::Debug + : OpInfo::Other; + + const auto resultTypeIndex + = i.operands.findFirstIndex([](const auto& o){return o.kind == "IdResultType";}); + const auto resultIdIndex + = i.operands.findFirstIndex([](const auto& o){return o.kind == "IdResult";}); + SLANG_ASSERT(resultTypeIndex >= -1 || resultTypeIndex <= 0); + SLANG_ASSERT(resultIdIndex >= -1 || resultTypeIndex <= 1); + + uint16_t minOperandCount = 0; + uint16_t maxOperandCount = 0; + uint16_t numOperandTypes = 0; + const OperandKind* operandTypes = res->operandTypesStorage.end(); + for(const auto& o : i.operands) + { + if(maxOperandCount == 0xffff) + { + // We are about to overflow maxWordCount, either someone has + // put 2^16 operands in the json, or we have a "*" quantified + // operand not in the last position and should implement + // support for that + sink.diagnoseWithoutSourceView( + SourceLoc{}, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "\"*\"-qualified operand wasn't the last operand" + ); + } + + const auto catIndex = res->operandKinds.lookup(o.kind); + if(!catIndex) + { + sink.diagnoseWithoutSourceView( + SourceLoc{}, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "Operand references a kind which doesn't exist" + ); + continue; + } + + numOperandTypes++; + res->operandTypesStorage.add(*catIndex); + + if(o.quantifier == "") + { + // This catches the case where an "?" or "*" qualified operand + // appears before any unqualified operands + if(minOperandCount != maxOperandCount) + sink.diagnoseWithoutSourceView( + SourceLoc{}, + MiscDiagnostics::spirvCoreGrammarJSONParseFailure, + "\"*\" or \"?\" operand appeared before an unqualified operand" + ); + minOperandCount++; + maxOperandCount++; + } + else if(o.quantifier == "?") + { + maxOperandCount++; + } + else if(o.quantifier == "*") + { + maxOperandCount = 0xffff; + } + } + + // There are duplicate opcodes in the json (for renamed instructions, + // or the same instruction with different capabilities), for now just + // keep the first one. + res->opInfos.dict.addIfNotExists(SpvOp(i.opcode), { + class_, + static_cast(resultTypeIndex), + static_cast(resultIdIndex), + minOperandCount, + maxOperandCount, + numOperandTypes, + operandTypes + }); + res->opNames.dict.addIfNotExists(SpvOp(i.opcode), i.opname); + } + + for(const auto& k : spec.operand_kinds) + { + const auto kindIndex = res->operandKinds.dict.getValue(k.kind); + const auto d = operandKindToDict(container, sink, k); + for(const auto& [n, v] : d) + { + // Add the string to this slice pool as we'll be taking ownership + // of it shortly but don't want to invalidate it in the meantime. + const auto s = container.getStringSlicePool().addAndGetSlice(String(k.kind) + n); + res->allEnumsWithTypePrefix.dict.add(s, v); + res->allEnums.dict.add({kindIndex, n}, v); + res->allEnumNames.dict.addIfNotExists({kindIndex, v}, n); + } + + res->operandKindNames.dict.add(kindIndex, k.kind); + + if(k.kind == "Capability") + for(const auto& [n, v] : d) + res->capabilities.dict.add(n, SpvCapability(v)); + + // If this starts with Id, and the suffix is also an operand kind, + // assume that this is an Id wrapper + if(k.kind.startsWith("Id")) + { + const UnownedStringSlice underneathIdKind{k.kind.begin()+2, k.kind.end()}; + OperandKind targetIndex; + if(res->operandKinds.dict.tryGetValue(underneathIdKind, targetIndex)) + res->operandKindUnderneathIds.dict.add(kindIndex, targetIndex); + } + } + // Steal the strings from the JSON container before it dies + res->strings.swapWith(container.getStringSlicePool()); + return res; +} +} diff --git a/source/compiler-core/slang-spirv-core-grammar.h b/source/compiler-core/slang-spirv-core-grammar.h new file mode 100644 index 000000000..7fe8f6cd7 --- /dev/null +++ b/source/compiler-core/slang-spirv-core-grammar.h @@ -0,0 +1,145 @@ +#pragma once + +#include "../core/slang-smart-pointer.h" +#include "../core/slang-string.h" +#include "../core/slang-string-slice-pool.h" +#include "../core/slang-dictionary.h" +#include "../../external/spirv-headers/include/spirv/unified1/spirv.h" +#include + +namespace Slang +{ + using SpvWord = uint32_t; + class DiagnosticSink; + class SourceView; + + struct SPIRVCoreGrammarInfo : public RefObject + { + static RefPtr loadFromJSON(SourceView& source, DiagnosticSink& sink); + static RefPtr getEmbeddedVersion(); + + template + struct Lookup + { + std::optional lookup(const K& name) const + { + T ret; + if(embedded ? embedded(name, ret) : dict.tryGetValue(name, ret)) + return ret; + else + return std::nullopt; + } + + bool (*embedded)(const K&, T&) = nullptr; + Dictionary dict; + }; + + struct OperandKind + { + uint8_t index; + SLANG_COMPONENTWISE_HASHABLE_1; + SLANG_COMPONENTWISE_EQUALITY_1(OperandKind); + }; + + struct QualifiedEnumName + { + OperandKind kind; + UnownedStringSlice name; + SLANG_COMPONENTWISE_HASHABLE_2; + SLANG_COMPONENTWISE_EQUALITY_2(QualifiedEnumName); + }; + + struct QualifiedEnumValue + { + OperandKind kind; + SpvWord value; + SLANG_COMPONENTWISE_HASHABLE_2; + SLANG_COMPONENTWISE_EQUALITY_2(QualifiedEnumValue); + }; + + struct OpInfo + { + enum Class + { + // Unrecognized instructions go in here + Other, + + // Adding to this? Don't forget to update the embedding generator + Miscellaneous, + Debug, + Annotation, + Extension, + ModeSetting, + TypeDeclaration, + ConstantCreation, + Memory, + Function, + Image, + Conversion, + Composite, + Arithmetic, + Bit, + Relational_and_Logical, + Derivative, + ControlFlow, + Atomic, + Primitive, + Barrier, + Group, + DeviceSideEnqueue, + Pipe, + NonUniform, + Reserved, + }; + constexpr static int8_t kNoResultTypeId = -1; + constexpr static int8_t kNoResultId = -1; + + Class class_; + // -1 or 0 + int8_t resultTypeIndex = kNoResultTypeId; + // -1 or 0 or 1 + int8_t resultIdIndex = kNoResultId; + // The range of valid operand counts for this instruction, + // including any result type and id. Multi-word operands count as a + // single operand. + uint16_t minOperandCount; + uint16_t maxOperandCount; + // when looking up an operand type, clamp to this number-1 to + // account for variable length operands at the end + uint16_t numOperandTypes; + const OperandKind* operandTypes; + }; + + // + // Our tables: + // + + // Instruction name to opcode + Lookup opcodes; + // Capability name to value + Lookup capabilities; + // String-qualified enum name (one with the type prefix) to value + Lookup allEnumsWithTypePrefix; + // kind * enum name to value + Lookup allEnums; + // kine * enum value to unqualified name + Lookup allEnumNames; + // Any other information on instructions + Lookup opInfos; + // Opcode to instruction name + Lookup opNames; + // Operand kind string to numeric id + Lookup operandKinds; + // Operand kind id to string + Lookup operandKindNames; + // Operand kind to the "un-id" version of itself, for example IdMemorySemantics to MemorySemantics + Lookup operandKindUnderneathIds; + + private: + + // If this is loaded from JSON, we keep the strings around instead of + // copying them as dictionary keys + StringSlicePool strings = StringSlicePool(StringSlicePool::Style::Empty); + List operandTypesStorage; + }; +} diff --git a/source/core/slang-char-util.h b/source/core/slang-char-util.h index 1ed8f7f73..c65f676c4 100644 --- a/source/core/slang-char-util.h +++ b/source/core/slang-char-util.h @@ -50,6 +50,10 @@ struct CharUtil /// Given a value between 0-15 inclusive returns the hex digit. Uses lower case hex. SLANG_FORCE_INLINE static char getHexChar(Index i) { SLANG_ASSERT((i & ~Index(0xf)) == 0); return char(i >= 10 ? (i - 10 + 'a') : (i + '0')); } + /// Returns the value if c interpretted as a decimal digit + /// If c is not a valid digit returns -1 + inline static int getDecimalDigitValue(char c) { return isDigit(c) ? (c - '0') : -1; } + /// Returns the value if c interpretted as a hex digit /// If c is not a valid hex returns -1 inline static int getHexDigitValue(char c); diff --git a/source/core/slang-common.h b/source/core/slang-common.h index 62c73df08..9e73b50a9 100644 --- a/source/core/slang-common.h +++ b/source/core/slang-common.h @@ -84,6 +84,53 @@ namespace Slang } } +// +// Some macros for avoiding boilerplate +// TODO: could probably deduce the size with templates, and move the whole +// thing into a template +// +#if __cplusplus >= 202002L +#define SLANG_COMPONENTWISE_EQUALITY_1(type) bool operator==(const type& other) const = default; +#define SLANG_COMPONENTWISE_EQUALITY_2(type) bool operator==(const type& other) const = default; +#define SLANG_COMPONENTWISE_EQUALITY_3(type) bool operator==(const type& other) const = default; +#else +#define SLANG_COMPONENTWISE_EQUALITY_1(type) \ + bool operator==(const type& other) const \ + { \ + const auto& [m1] = *this; \ + const auto& [o1] = other; \ + return m1 == o1; \ + } \ + bool operator!=(const type& other) const \ + { \ + return !(*this == other); \ + } + +#define SLANG_COMPONENTWISE_EQUALITY_2(type) \ + bool operator==(const type& other) const \ + { \ + const auto& [m1, m2] = *this; \ + const auto& [o1, o2] = other; \ + return m1 == o1 && m2 == o2; \ + } \ + bool operator!=(const type& other) const \ + { \ + return !(*this == other); \ + } + +#define SLANG_COMPONENTWISE_EQUALITY_3(type) \ + bool operator==(const type& other) const \ + { \ + const auto& [m1, m2, m3] = *this; \ + const auto& [o1, o2, o3] = other; \ + return m1 == o1 && m2 == o2 && m3 == o3; \ + } \ + bool operator!=(const type& other) const \ + { \ + return !(*this == other); \ + } +#endif + // TODO: Shouldn't these be SLANG_ prefixed? #ifdef _MSC_VER #define UNREACHABLE_RETURN(x) diff --git a/source/core/slang-dictionary.h b/source/core/slang-dictionary.h index c7c0c8e05..ff7e201bf 100644 --- a/source/core/slang-dictionary.h +++ b/source/core/slang-dictionary.h @@ -9,6 +9,7 @@ #include "slang-math.h" #include "slang-hash.h" #include "../../external/unordered_dense/include/ankerl/unordered_dense.h" +#include namespace Slang { @@ -87,6 +88,16 @@ namespace Slang using ThisType = Dictionary; InnerMap map; public: + Dictionary() = default; + Dictionary(const Dictionary&) = default; + Dictionary(Dictionary&&) = default; + ThisType& operator=(const ThisType&) = default; + ThisType& operator=(ThisType&&) = default; + Dictionary(std::initializer_list inits) + : map(std::move(inits)) + { + } + // // Types // diff --git a/source/core/slang-hash.h b/source/core/slang-hash.h index 49685ee65..9a173c4f8 100644 --- a/source/core/slang-hash.h +++ b/source/core/slang-hash.h @@ -147,6 +147,20 @@ namespace Slang return ::Slang::hashObjectBytes(*this); \ } +# define SLANG_COMPONENTWISE_HASHABLE_1 \ + auto getHashCode() const \ + { \ + const auto& [m1] = *this; \ + return Slang::getHashCode(m1); \ + } + +# define SLANG_COMPONENTWISE_HASHABLE_2 \ + auto getHashCode() const \ + { \ + const auto& [m1, m2] = *this; \ + return combineHash(::Slang::getHashCode(m1), ::Slang::getHashCode(m2)); \ + } + inline HashCode64 combineHash(HashCode64 h) { return h; diff --git a/source/core/slang-rtti-util.h b/source/core/slang-rtti-util.h index cf513ecad..4807c5ea2 100644 --- a/source/core/slang-rtti-util.h +++ b/source/core/slang-rtti-util.h @@ -3,8 +3,53 @@ #include "slang-rtti-info.h" -namespace Slang { +// Some macros to help generate StructRttiInfo for structs without too much +// boilerplate, use as so: +// +// struct MyStruct +// { +// int an_optional_field; +// List a_list_of_strings_field; +// } +// SLANG_MAKE_STRUCT_RTTI_INFO( +// MyStruct, +// SLANG_OPTIONAL_RTTI_FIELD(an_optional_field), +// SLANG_RTTI_FIELD(a_list_of_strings_field) +// ); +// +// This allows parsing JSON objects like +// { +// "an_optional_field": 10, +// "a_list_of_strings_field": ["hello", "world"] +// } +// +// Convert from such JSON objects using JSONToNativeConverter::convert + +#define SLANG_MAKE_STRUCT_RTTI_INFO(S, ...) \ + template<> \ + struct GetRttiInfo \ + { \ + static const RttiInfo* get() \ + { \ + using S_ = S; \ + const static StructRttiInfo::Field fs[] = {__VA_ARGS__}; \ + const auto ignoreUnknownFields = true; \ + const static auto ret = StructRttiInfo{ \ + {{RttiInfo::Kind::Struct, alignof(S), sizeof(S)}, #S}, \ + nullptr, \ + SLANG_COUNT_OF(fs), \ + fs, \ + ignoreUnknownFields \ + }; \ + return &ret; \ + } \ + }; +#define SLANG_RTTI_FIELD_IMPL(m, name, flags) \ + {name, GetRttiInfo::get(), offsetof(S_, m), flags} +#define SLANG_RTTI_FIELD(m) SLANG_RTTI_FIELD_IMPL(m, #m, 0) +#define SLANG_OPTIONAL_RTTI_FIELD(m) SLANG_RTTI_FIELD_IMPL(m, #m, StructRttiInfo::Flag::Optional) +namespace Slang { struct RttiUtil { diff --git a/source/core/slang-string-slice-pool.cpp b/source/core/slang-string-slice-pool.cpp index 692bc2b9a..142952855 100644 --- a/source/core/slang-string-slice-pool.cpp +++ b/source/core/slang-string-slice-pool.cpp @@ -40,6 +40,9 @@ void StringSlicePool::_set(const ThisType& rhs) const Index startIndex = rhs.getFirstAddedIndex(); const Count count = rhs.m_slices.getCount(); + if (count == 0) + return; + // We need the same amount of slices m_slices.setCount(count); diff --git a/source/core/slang-string-util.cpp b/source/core/slang-string-util.cpp index ac8a176ad..fb062de76 100644 --- a/source/core/slang-string-util.cpp +++ b/source/core/slang-string-util.cpp @@ -593,22 +593,29 @@ ComPtr StringUtil::createStringBlob(const String& string) cur++; } + int radix = 10; + auto getDigit = CharUtil::getDecimalDigitValue; + if (cur+1 < end && *cur == '0' && (*(cur+1) == 'x' || *(cur+1) == 'X')) + { + radix = 16; + getDigit = CharUtil::getHexDigitValue; + cur += 2; + } + // We need at least one digit if (cur >= end || !CharUtil::isDigit(*cur)) { return SLANG_FAIL; } - Int value = *cur++ - '0'; - // Do the remaining digits + Int value = 0; + // Do the digits for (; cur < end; ++cur) { - const char c = *cur; - if (!CharUtil::isDigit(c)) - { + const auto d = getDigit(*cur); + if (d == -1) return SLANG_FAIL; - } - value = value * 10 + (c - '0'); + value = value * radix + d; } value = negate ? -value : value; diff --git a/source/slang/slang-ast-dump.cpp b/source/slang/slang-ast-dump.cpp index 7dba55c52..96a0afe6d 100644 --- a/source/slang/slang-ast-dump.cpp +++ b/source/slang/slang-ast-dump.cpp @@ -651,6 +651,9 @@ struct ASTDumpContext case SPIRVAsmOperand::Id: m_writer->emit("%"); break; + case SPIRVAsmOperand::ResultMarker: + m_writer->emit("result"); + break; case SPIRVAsmOperand::Literal: case SPIRVAsmOperand::NamedValue: break; diff --git a/source/slang/slang-ast-expr.h b/source/slang/slang-ast-expr.h index 36d304a1a..7b09c3334 100644 --- a/source/slang/slang-ast-expr.h +++ b/source/slang/slang-ast-expr.h @@ -6,6 +6,8 @@ namespace Slang { +using SpvWord = uint32_t; + // Syntax class definitions for expressions. // // A placeholder for where an Expr is expected but is missing from source. @@ -640,14 +642,38 @@ public: { Literal, // No prefix Id, // Prefixed with % - NamedValue, // An identifier + ResultMarker, // "result" (without quotes) + NamedValue, // Any other identifier SlangValue, SlangValueAddr, SlangType, }; + + // The flavour and token describes how this was parsed Flavor flavor; + // The single token this came from Token token; + + // If this was a SlangValue or SlangValueAddr or SlangType, then we also + // store the expression, which should be a single VarExpr because we only + // parse single idents at the moment Expr* expr = nullptr; + + // If this is part of a bitwise or expression, this will point to the + // remaining operands values in such an expression must be of flavour + // Literal or NamedValue + List bitwiseOrWith = List(); + + // If this is a named value then we calculate the value here during + // checking. If this is an opcode, then the parser will populate this too + // (or set it to 0xffffffff); + SpvWord knownValue = 0xffffffff; + // Although this might be a constant in the source we should actually pass + // it as an id created with OpConstant + bool wrapInId = false; + + // Once we've checked things, the SlangType flavour operands will have this + // type populated. TypeExp type = TypeExp(); }; diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 5266f02f6..43db85e3b 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -3898,44 +3898,114 @@ namespace Slang Expr* SemanticsExprVisitor::visitSPIRVAsmExpr(SPIRVAsmExpr* expr) { + // + // Firstly, get the info for this op, the opcode has already been + // discovered by the parser + // + const auto& spirvInfo = getSession()->spirvCoreGrammarInfo; + // We will iterate over all the operands in all the insts and check // them + bool failed = false; for(auto& inst : expr->insts) { + // It's not automatically a failure to not have info, we just won't + // be able to deduce types for operands + const auto opInfo = spirvInfo->opInfos.lookup(SpvOp(inst.opcode.knownValue)); + + if(opInfo->numOperandTypes == 0 && inst.operands.getCount()) + { + failed = true; + getSink()->diagnose(inst.opcode.token, Diagnostics::spirvInstructionWithTooManyOperands, inst.opcode.token, 0); + continue; + } + const bool isLast = &inst == &expr->insts.getLast(); - for(auto& operand : inst.operands) + for(Index operandIndex = 0; operandIndex < inst.operands.getCount(); ++operandIndex) { - if(operand.flavor == SPIRVAsmOperand::SlangType) - { - // This is a $$type operand, fill in the TypeExp member of the operand - TypeExp& typeExpr = operand.type; - typeExpr.exp = operand.expr; - typeExpr = CheckProperType(typeExpr); - operand.expr = typeExpr.exp; - } - else if(operand.flavor == SPIRVAsmOperand::SlangValue - || operand.flavor == SPIRVAsmOperand::SlangValueAddr) - { - // This is a $expr operand, check the expr - operand.expr = dispatch(operand.expr); - } - else if(operand.flavor == SPIRVAsmOperand::NamedValue - && operand.token.getContent() == "result") - { - // This is the marker, check that it only - // appears in the last instruction. + // Clamp to the end of the type info array, because the last one will be any variable operands + const auto operandType + = opInfo->operandTypes[std::min(operandIndex, Index(opInfo->numOperandTypes)-1)]; + const auto baseOperandType + = spirvInfo->operandKindUnderneathIds.lookup(operandType).value_or(operandType); + const auto needsIdWrapper = baseOperandType != operandType; - // TODO: We could consider relaxing this, because SPIR-V - // does have forward references for decorations and such - if (!isLast) + const auto check = [&](const auto& go, auto& operand) -> void { + if(operand.flavor == SPIRVAsmOperand::SlangType) { - getSink()->diagnose(operand.token, Diagnostics::misplacedResultIdMarker); - getSink()->diagnoseWithoutSourceView(expr, Diagnostics::considerOpCopyObject); + // This is a $$type operand, fill in the TypeExp member of the operand + TypeExp& typeExpr = operand.type; + typeExpr.exp = operand.expr; + typeExpr = CheckProperType(typeExpr); + operand.expr = typeExpr.exp; } - } + else if(operand.flavor == SPIRVAsmOperand::SlangValue + || operand.flavor == SPIRVAsmOperand::SlangValueAddr) + { + // This is a $expr operand, check the expr + operand.expr = dispatch(operand.expr); + } + else if(operand.flavor == SPIRVAsmOperand::ResultMarker) + { + // This is the marker, check that it only + // appears in the last instruction. + + // TODO: We could consider relaxing this, because SPIR-V + // does have forward references for decorations and such + if (!isLast) + { + getSink()->diagnose(operand.token, Diagnostics::misplacedResultIdMarker); + getSink()->diagnoseWithoutSourceView(expr, Diagnostics::considerOpCopyObject); + } + } + else if(operand.flavor == SPIRVAsmOperand::NamedValue) + { + // First try and look it up with the knowledge of this operand's type + auto enumValue + = spirvInfo->allEnums.lookup({baseOperandType, operand.token.getContent()}); + // Then fall back to with the type prefix + if(!enumValue) + enumValue = spirvInfo->allEnumsWithTypePrefix.lookup(operand.token.getContent()); + // Then see if it's an opcode (for OpSpecialize) + if(!enumValue) + enumValue = spirvInfo->opcodes.lookup(operand.token.getContent()); + + if(!enumValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvUnableToResolveName, operand.token.getContent()); + return; + } + + operand.knownValue = *enumValue; + operand.wrapInId = needsIdWrapper; + } + if(operand.bitwiseOrWith.getCount() + && operand.flavor != SPIRVAsmOperand::Literal + && operand.flavor != SPIRVAsmOperand::NamedValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvNonConstantBitwiseOr); + } + for(auto& o : operand.bitwiseOrWith) + { + if(o.flavor != SPIRVAsmOperand::Literal && o.flavor != SPIRVAsmOperand::NamedValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvNonConstantBitwiseOr); + } + go(go, o); + operand.knownValue |= o.knownValue; + } + }; + + check(check, inst.operands[operandIndex]); } } + if(failed) + return CreateErrorExpr(expr); + // Assign the type of this expression from the type of the last // instruction, otherwise void if(expr->insts.getCount()) @@ -3944,8 +4014,7 @@ namespace Slang const auto lastOperands = expr->insts.getLast().operands; if(lastOperands.getCount() >= 2 && lastOperands[0].flavor == SPIRVAsmOperand::SlangType - && lastOperands[1].flavor == SPIRVAsmOperand::NamedValue - && lastOperands[1].token.getContent() == "result") + && lastOperands[1].flavor == SPIRVAsmOperand::ResultMarker) { expr->type = lastOperands[0].type.type; } diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index d87b755c7..6e4d7ff17 100755 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -14,6 +14,8 @@ #include "../compiler-core/slang-source-embed-util.h" +#include "../compiler-core/slang-spirv-core-grammar.h" + #include "../core/slang-std-writers.h" #include "../core/slang-command-options.h" @@ -2995,7 +2997,9 @@ namespace Slang *outDownstreamTime = m_downstreamCompileTime; *outTotalTime = m_totalCompileTime; } - + + SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar(char const* jsonPath) override; + /// Get the downstream compiler for a transition IDownstreamCompiler* getDownstreamCompiler(CodeGenTarget source, CodeGenTarget target); @@ -3047,6 +3051,14 @@ namespace Slang RefPtr m_sharedASTBuilder; + SPIRVCoreGrammarInfo& getSPIRVCoreGrammarInfo() + { + if(!spirvCoreGrammarInfo) + setSPIRVCoreGrammar(nullptr); + SLANG_ASSERT(spirvCoreGrammarInfo); + return *spirvCoreGrammarInfo; + } + RefPtr spirvCoreGrammarInfo; // diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h index ac6e9a932..1b13ae636 100644 --- a/source/slang/slang-diagnostic-defs.h +++ b/source/slang/slang-diagnostic-defs.h @@ -245,6 +245,13 @@ DIAGNOSTIC(29100, Error, unrecognizedSPIRVOpcode, "unrecognized spirv opcode: $0 DIAGNOSTIC(29101, Error, misplacedResultIdMarker, "the result-id marker must only be used in the last instruction of a spriv_asm expression") DIAGNOSTIC(29102, Note, considerOpCopyObject, "consider adding an OpCopyObject instruction to the end of the spirv_asm expression") DIAGNOSTIC(29103, Note, noSuchAddress, "unable to take the address of this address-of asm operand") +DIAGNOSTIC(29104, Error, spirvInstructionWithoutResultId, "cannot use this 'x = $0...' syntax because $0 does not have a operand") +DIAGNOSTIC(29104, Error, spirvInstructionWithoutResultTypeId, "cannot use this 'x : = $0...' syntax because $0 does not have a operand") +// This is a warning because we trust that people using the spirv_asm block know what they're doing +DIAGNOSTIC(29104, Warning, spirvInstructionWithTooManyOperands, "too many operands for $0 (expected max $1), did you forget a semicolon?") +DIAGNOSTIC(29104, Error, spirvUnableToResolveName, "unknown SPIR-V identifier $0, it's not a known enumerator or opcode") +DIAGNOSTIC(29104, Error, spirvNonConstantBitwiseOr, "only integer literals and enum names can appear in a bitwise or expression") +DIAGNOSTIC(29104, Error, spirvOperandRange, "Literal ints must be in the range 0 to 0xffffffff") // diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp index 0022bdd85..c6aedbe3b 100644 --- a/source/slang/slang-emit-spirv.cpp +++ b/source/slang/slang-emit-spirv.cpp @@ -3808,25 +3808,34 @@ struct SPIRVEmitContext for(const auto spvInst : inst->getInsts()) { const bool isLast = spvInst == inst->getLastChild(); - const auto opcodeString = spvInst->getOpcodeString(); - SpvOp opcode; - const bool foundOpCode = lookupSpvOp(opcodeString, opcode) - || lookupSpvOp((String("Op") + opcodeString).getUnownedSlice(), opcode); - if(!foundOpCode) - { - m_sink->diagnose( - spvInst->getOpcode(), - Diagnostics::unrecognizedSPIRVOpcode, - opcodeString - ); - return nullptr; - } + const SpvOp opcode = SpvOp(spvInst->getOpcodeOperandWord()); - const auto parentForOpCode = [this](SpvOp opcode, SpvInstParent* defaultParent){ - return - opcode == SpvOpConstant ? getSection(SpvLogicalSectionID::ConstantsAndTypes) - : opcode == SpvOpName ? getSection(SpvLogicalSectionID::DebugNames) - : defaultParent; + const auto parentForOpCode = [this](SpvOp opcode, SpvInstParent* defaultParent) -> SpvInstParent*{ + const auto info = m_grammarInfo->opInfos.lookup(opcode); + SLANG_ASSERT(info.has_value()); + switch(info->class_) + { + case SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration: + case SPIRVCoreGrammarInfo::OpInfo::ConstantCreation: + return getSection(SpvLogicalSectionID::ConstantsAndTypes); + // Don't add this case, it's not correct as not all "Debug" + // instructions belong in this block + // case SPIRVCoreGrammarInfo::OpInfo::Debug: + // return getSection(SpvLogicalSectionID::DebugNames); + default: + switch(opcode) + { + case SpvOpName: + return getSection(SpvLogicalSectionID::DebugNames); + case SpvOpCapability: + return getSection(SpvLogicalSectionID::Capabilities); + case SpvOpExtension: + return getSection(SpvLogicalSectionID::Extensions); + default: + return defaultParent; + + } + } }; last = emitInstCustomOperandFunc( @@ -3843,24 +3852,48 @@ struct SPIRVEmitContext { switch(operand->getOp()) { + case kIROp_SPIRVAsmOperandEnum: case kIROp_SPIRVAsmOperandLiteral: { const auto v = as(operand->getValue()); SLANG_ASSERT(v); - switch(v->getOp()) + if(operand->getOperandCount() >= 2) { - case kIROp_StringLit: - emitOperand(SpvLiteralBits::fromUnownedStringSlice(v->getStringSlice())); - break; - case kIROp_IntLit: - { - // TODO: range checking - const auto i = cast(v)->getValue(); - emitOperand(SpvLiteralInteger::from32(uint32_t(i))); - break; + const auto constantType = cast(operand->getOperand(1)); + SpvInst* constant; + switch(v->getOp()) + { + case kIROp_IntLit: + { + // TODO: range checking + const auto i = cast(v)->getValue(); + constant = emitIntConstant(i, constantType); + break; + } + case kIROp_StringLit: + SLANG_UNIMPLEMENTED_X("String constants in SPIR-V emit"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + } + emitOperand(constant); } - default: - SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + else + { + switch(v->getOp()) + { + case kIROp_StringLit: + emitOperand(SpvLiteralBits::fromUnownedStringSlice(v->getStringSlice())); + break; + case kIROp_IntLit: + { + // TODO: range checking + const auto i = cast(v)->getValue(); + emitOperand(SpvLiteralInteger::from32(uint32_t(i))); + break; + } + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + } } break; } @@ -3868,18 +3901,13 @@ struct SPIRVEmitContext { const auto i = operand->getValue(); emitOperand(ensureInst(i)); + break; } - case kIROp_SPIRVAsmOperandEnum: + case kIROp_SPIRVAsmOperandResult: { - const auto s = cast(operand->getValue())->getStringSlice(); - if(s == "result") - { - SLANG_ASSERT(isLast); - emitOperand(kResultID); - } - else - SLANG_UNIMPLEMENTED_X("lookup enum operands in spirv_asm"); + SLANG_ASSERT(isLast); + emitOperand(kResultID); break; } case kIROp_SPIRVAsmOperandId: diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h index 980770be5..cab7e973d 100644 --- a/source/slang/slang-ir-inst-defs.h +++ b/source/slang/slang-ir-inst-defs.h @@ -1064,14 +1064,17 @@ INST(SPIRVAsmInst, SPIRVAsmInst, 1, 0) INST(SPIRVAsmOperandLiteral, SPIRVAsmOperandLiteral, 1, 0) // A reference to a slang IRInst, either a value or a type INST(SPIRVAsmOperandInst, SPIRVAsmOperandInst, 1, 0) - // A named enumerator, the value of which is determined in the backend - // It can also have the value "result", indicating that the result-id of - // the asm block should be used + // A named enumerator, the value is stored as a constant operand + // It may have a second operand, which if present is a type with which to + // construct a constant id to pass, instead of a literal constant INST(SPIRVAsmOperandEnum, SPIRVAsmOperandEnum, 1, 0) // A string which is given a unique ID in the backend, used to refer to // results of other instrucions in the same asm block INST(SPIRVAsmOperandId, SPIRVAsmOperandId, 1, 0) -INST_RANGE(SPIRVAsmOperand, SPIRVAsmOperandLiteral, SPIRVAsmOperandId) + // A special instruction which marks the place to insert the generated + // result operand + INST(SPIRVAsmOperandResult, SPIRVAsmOperandResult, 0, 0) +INST_RANGE(SPIRVAsmOperand, SPIRVAsmOperandLiteral, SPIRVAsmOperandResult) #undef PARENT #undef USE_OTHER diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h index e12306c54..82b123bd4 100644 --- a/source/slang/slang-ir-insts.h +++ b/source/slang/slang-ir-insts.h @@ -2888,6 +2888,8 @@ struct IRSPIRVAsmOperand : IRInst IR_PARENT_ISA(SPIRVAsmOperand); IRInst* getValue() { + if(getOp() == kIROp_SPIRVAsmOperandResult) + return nullptr; return getOperand(0); } }; @@ -2896,20 +2898,20 @@ struct IRSPIRVAsmInst : IRInst { IR_LEAF_ISA(SPIRVAsmInst); - IRSPIRVAsmOperand* getOpcode() + IRSPIRVAsmOperand* getOpcodeOperand() { - // TODO: This only supports known opcodes at the moment, eventually we'll want - // another child of IRSPIRVAsm which just stores raw words const auto opcodeOperand = cast(getOperand(0)); SLANG_ASSERT(opcodeOperand->getOp() == kIROp_SPIRVAsmOperandEnum); return opcodeOperand; } - UnownedStringSlice getOpcodeString() + SpvWord getOpcodeOperandWord() { - const auto opcodeOperand = getOpcode(); - const auto opcodeStringLit = cast(opcodeOperand->getValue()); - return opcodeStringLit->getStringSlice(); + const auto o = getOpcodeOperand(); + SLANG_ASSERT(o->getOp() != kIROp_SPIRVAsmOperandResult); + const auto v = o->getValue(); + const auto i = cast(v); + return SpvWord(i->getValue()); } IROperandList getSPIRVOperands() @@ -3916,7 +3918,9 @@ public: IRSPIRVAsmOperand* emitSPIRVAsmOperandLiteral(IRInst* literal); IRSPIRVAsmOperand* emitSPIRVAsmOperandInst(IRInst* inst); IRSPIRVAsmOperand* emitSPIRVAsmOperandId(IRInst* inst); + IRSPIRVAsmOperand* emitSPIRVAsmOperandResult(); IRSPIRVAsmOperand* emitSPIRVAsmOperandEnum(IRInst* inst); + IRSPIRVAsmOperand* emitSPIRVAsmOperandEnum(IRInst* inst, IRType* constantType); IRSPIRVAsmInst* emitSPIRVAsmInst(IRInst* opcode, List operands); IRSPIRVAsm* emitSPIRVAsm(IRType* type); diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp index fd23d1b5e..32386e53f 100644 --- a/source/slang/slang-ir-spirv-legalize.cpp +++ b/source/slang/slang-ir-spirv-legalize.cpp @@ -854,7 +854,7 @@ SpvSnippet* SPIRVEmitSharedContext::getParsedSpvSnippet(IRTargetIntrinsicDecorat { return snippet.Ptr(); } - snippet = SpvSnippet::parse(intrinsic->getDefinition()); + snippet = SpvSnippet::parse(*m_grammarInfo, intrinsic->getDefinition()); if(!snippet) { m_sink->diagnose(intrinsic, Diagnostics::snippetParsingFailed, intrinsic->getDefinition()); diff --git a/source/slang/slang-ir-spirv-legalize.h b/source/slang/slang-ir-spirv-legalize.h index 797745f88..b11cde72f 100644 --- a/source/slang/slang-ir-spirv-legalize.h +++ b/source/slang/slang-ir-spirv-legalize.h @@ -19,8 +19,12 @@ struct SPIRVEmitSharedContext TargetRequest* m_targetRequest; Dictionary> m_parsedSpvSnippets; DiagnosticSink* m_sink; + const SPIRVCoreGrammarInfo* m_grammarInfo; SPIRVEmitSharedContext(IRModule* module, TargetRequest* target, DiagnosticSink* sink) - : m_irModule(module), m_targetRequest(target), m_sink(sink) + : m_irModule(module), + m_targetRequest(target), + m_sink(sink), + m_grammarInfo(&module->getSession()->getSPIRVCoreGrammarInfo()) {} SpvSnippet* getParsedSpvSnippet(IRTargetIntrinsicDecoration* intrinsic); }; diff --git a/source/slang/slang-ir-spirv-snippet.cpp b/source/slang/slang-ir-spirv-snippet.cpp index 98466e8ff..055eb982b 100644 --- a/source/slang/slang-ir-spirv-snippet.cpp +++ b/source/slang/slang-ir-spirv-snippet.cpp @@ -3,6 +3,7 @@ #include "slang-ir-spirv-snippet.h" #include "slang-lookup-spirv.h" #include "../core/slang-token-reader.h" +#include "../compiler-core/slang-spirv-core-grammar.h" namespace Slang { @@ -85,7 +86,9 @@ SpvWord readWordOrWordLiteral(Misc::TokenReader& reader) return ret; } -RefPtr SpvSnippet::parse(UnownedStringSlice definition) +RefPtr SpvSnippet::parse( + const SPIRVCoreGrammarInfo& spirvGrammar, + UnownedStringSlice definition) { RefPtr snippet = new SpvSnippet(); try @@ -118,11 +121,13 @@ RefPtr SpvSnippet::parse(UnownedStringSlice definition) case Slang::Misc::TokenType::Identifier: { auto opName = tokenReader.ReadWord(); - if(!lookupSpvOp(opName.getUnownedSlice(), opCode)) + const auto opCodeMaybe = spirvGrammar.opcodes.lookup(opName.getUnownedSlice()); + if(!opCodeMaybe) { throw Misc::TextFormatException( "Text parsing error: Unrecognized SPIR-V opcode: " + opName); } + opCode = *opCodeMaybe; break; } default: diff --git a/source/slang/slang-ir-spirv-snippet.h b/source/slang/slang-ir-spirv-snippet.h index 4a509a230..2b1449ea9 100644 --- a/source/slang/slang-ir-spirv-snippet.h +++ b/source/slang/slang-ir-spirv-snippet.h @@ -5,6 +5,9 @@ namespace Slang { + +struct SPIRVCoreGrammarInfo; + // // [2.2: Terms] // @@ -137,7 +140,7 @@ struct SpvSnippet : public RefObject List constants; SpvStorageClass resultStorageClass = SpvStorageClassMax; - static RefPtr parse(UnownedStringSlice definition); + static RefPtr parse(const SPIRVCoreGrammarInfo& spirvGrammar, UnownedStringSlice definition); }; diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index 91a21754d..0b1e9c342 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -5703,6 +5703,18 @@ namespace Slang return i; } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandResult() + { + SLANG_ASSERT(as(m_insertLoc.getParent())); + const auto i = createInst( + this, + kIROp_SPIRVAsmOperandResult, + getVoidType() + ); + addInst(i); + return i; + } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandEnum(IRInst* inst) { SLANG_ASSERT(as(m_insertLoc.getParent())); @@ -5716,6 +5728,20 @@ namespace Slang return i; } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandEnum(IRInst* inst, IRType* constantType) + { + SLANG_ASSERT(as(m_insertLoc.getParent())); + const auto i = createInst( + this, + kIROp_SPIRVAsmOperandEnum, + inst->getFullType(), + inst, + constantType + ); + addInst(i); + return i; + } + IRSPIRVAsmInst* IRBuilder::emitSPIRVAsmInst(IRInst* opcode, List operands) { SLANG_ASSERT(as(m_insertLoc.getParent())); @@ -6566,6 +6592,9 @@ namespace Slang dump(context, "%"); dumpInstExpr(context, inst->getOperand(0)); return; + case kIROp_SPIRVAsmOperandResult: + dump(context, "result"); + return; } dump(context, opInfo.name); diff --git a/source/slang/slang-lookup-glslstd450.cpp b/source/slang/slang-lookup-glslstd450.cpp index cd9172cf0..2920335ec 100644 --- a/source/slang/slang-lookup-glslstd450.cpp +++ b/source/slang/slang-lookup-glslstd450.cpp @@ -12,120 +12,115 @@ namespace Slang { -static const unsigned tableSalt[81] ={ - 1, 1, 1, 1, 4, 0, 1, 0, 10, 0, 3, 0, 0, 13, 4, 1, - 5, 1, 5, 4, 0, 0, 0, 1, 0, 9, 1, 0, 0, 1, 1, 8, - 2, 0, 0, 2, 0, 1, 0, 0, 2, 1, 1, 0, 0, 0, 0, 1, - 4, 3, 9, 0, 26, 0, 0, 2, 0, 2, 8, 0, 0, 17, 20, 5, - 0, 0, 0, 5, 4, 9, 4, 23, 0, 1, 7, 0, 24, 43, 10, 41, - 6 -}; - -struct KV +bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value) { - const char* name; - GLSLstd450 value; -}; + static const unsigned tableSalt[81] = { + 1, 3, 0, 0, 6, 1, 2, 3, 0, 0, 0, 1, 4, 0, 1, 0, + 0, 0, 1, 3, 0, 0, 5, 0, 2, 0, 0, 0, 0, 0, 1, 0, + 2, 1, 1, 1, 8, 3, 1, 3, 0, 0, 3, 0, 3, 0, 9, 0, + 16, 0, 1, 0, 2, 0, 1, 1, 0, 0, 0, 2, 16, 15, 6, 1, + 1, 2, 2, 7, 7, 2, 24, 0, 16, 27, 1, 1, 176, 0, 11, 0, + 6 + }; -static const KV words[81] = -{ - {"FindSMsb", GLSLstd450FindSMsb}, - {"SClamp", GLSLstd450SClamp}, - {"UnpackHalf2x16", GLSLstd450UnpackHalf2x16}, - {"Normalize", GLSLstd450Normalize}, - {"Pow", GLSLstd450Pow}, - {"Ceil", GLSLstd450Ceil}, - {"PackUnorm4x8", GLSLstd450PackUnorm4x8}, - {"Cosh", GLSLstd450Cosh}, - {"Frexp", GLSLstd450Frexp}, - {"PackUnorm2x16", GLSLstd450PackUnorm2x16}, - {"Atan2", GLSLstd450Atan2}, - {"Exp", GLSLstd450Exp}, - {"Ldexp", GLSLstd450Ldexp}, - {"NClamp", GLSLstd450NClamp}, - {"PackHalf2x16", GLSLstd450PackHalf2x16}, - {"Trunc", GLSLstd450Trunc}, - {"UMin", GLSLstd450UMin}, - {"FClamp", GLSLstd450FClamp}, - {"SMin", GLSLstd450SMin}, - {"IMix", GLSLstd450IMix}, - {"FindUMsb", GLSLstd450FindUMsb}, - {"Cos", GLSLstd450Cos}, - {"UnpackUnorm4x8", GLSLstd450UnpackUnorm4x8}, - {"Fma", GLSLstd450Fma}, - {"RoundEven", GLSLstd450RoundEven}, - {"Log", GLSLstd450Log}, - {"Refract", GLSLstd450Refract}, - {"Distance", GLSLstd450Distance}, - {"UMax", GLSLstd450UMax}, - {"ModfStruct", GLSLstd450ModfStruct}, - {"PackSnorm4x8", GLSLstd450PackSnorm4x8}, - {"Determinant", GLSLstd450Determinant}, - {"SmoothStep", GLSLstd450SmoothStep}, - {"Reflect", GLSLstd450Reflect}, - {"Fract", GLSLstd450Fract}, - {"Asin", GLSLstd450Asin}, - {"Tanh", GLSLstd450Tanh}, - {"Degrees", GLSLstd450Degrees}, - {"Sqrt", GLSLstd450Sqrt}, - {"MatrixInverse", GLSLstd450MatrixInverse}, - {"Exp2", GLSLstd450Exp2}, - {"Cross", GLSLstd450Cross}, - {"FindILsb", GLSLstd450FindILsb}, - {"FMax", GLSLstd450FMax}, - {"NMin", GLSLstd450NMin}, - {"SMax", GLSLstd450SMax}, - {"InverseSqrt", GLSLstd450InverseSqrt}, - {"Length", GLSLstd450Length}, - {"SAbs", GLSLstd450SAbs}, - {"UClamp", GLSLstd450UClamp}, - {"FMix", GLSLstd450FMix}, - {"FaceForward", GLSLstd450FaceForward}, - {"Tan", GLSLstd450Tan}, - {"Modf", GLSLstd450Modf}, - {"PackSnorm2x16", GLSLstd450PackSnorm2x16}, - {"Round", GLSLstd450Round}, - {"UnpackUnorm2x16", GLSLstd450UnpackUnorm2x16}, - {"Atan", GLSLstd450Atan}, - {"FSign", GLSLstd450FSign}, - {"Sin", GLSLstd450Sin}, - {"UnpackSnorm2x16", GLSLstd450UnpackSnorm2x16}, - {"Radians", GLSLstd450Radians}, - {"PackDouble2x32", GLSLstd450PackDouble2x32}, - {"Sinh", GLSLstd450Sinh}, - {"UnpackSnorm4x8", GLSLstd450UnpackSnorm4x8}, - {"InterpolateAtCentroid", GLSLstd450InterpolateAtCentroid}, - {"NMax", GLSLstd450NMax}, - {"Acosh", GLSLstd450Acosh}, - {"Acos", GLSLstd450Acos}, - {"UnpackDouble2x32", GLSLstd450UnpackDouble2x32}, - {"FrexpStruct", GLSLstd450FrexpStruct}, - {"Atanh", GLSLstd450Atanh}, - {"Floor", GLSLstd450Floor}, - {"Asinh", GLSLstd450Asinh}, - {"InterpolateAtOffset", GLSLstd450InterpolateAtOffset}, - {"Step", GLSLstd450Step}, - {"FAbs", GLSLstd450FAbs}, - {"InterpolateAtSample", GLSLstd450InterpolateAtSample}, - {"Log2", GLSLstd450Log2}, - {"SSign", GLSLstd450SSign}, - {"FMin", GLSLstd450FMin}, -}; + using KV = std::pair; -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} + static const KV words[81] = + { + {"InterpolateAtOffset", GLSLstd450InterpolateAtOffset}, + {"Floor", GLSLstd450Floor}, + {"UnpackDouble2x32", GLSLstd450UnpackDouble2x32}, + {"Acosh", GLSLstd450Acosh}, + {"FindUMsb", GLSLstd450FindUMsb}, + {"Sinh", GLSLstd450Sinh}, + {"NMin", GLSLstd450NMin}, + {"Cos", GLSLstd450Cos}, + {"UMax", GLSLstd450UMax}, + {"Sqrt", GLSLstd450Sqrt}, + {"Frexp", GLSLstd450Frexp}, + {"Determinant", GLSLstd450Determinant}, + {"ModfStruct", GLSLstd450ModfStruct}, + {"PackSnorm4x8", GLSLstd450PackSnorm4x8}, + {"FrexpStruct", GLSLstd450FrexpStruct}, + {"Cross", GLSLstd450Cross}, + {"FClamp", GLSLstd450FClamp}, + {"Fract", GLSLstd450Fract}, + {"FaceForward", GLSLstd450FaceForward}, + {"MatrixInverse", GLSLstd450MatrixInverse}, + {"PackUnorm4x8", GLSLstd450PackUnorm4x8}, + {"Log2", GLSLstd450Log2}, + {"Reflect", GLSLstd450Reflect}, + {"Radians", GLSLstd450Radians}, + {"Round", GLSLstd450Round}, + {"InverseSqrt", GLSLstd450InverseSqrt}, + {"Exp", GLSLstd450Exp}, + {"Normalize", GLSLstd450Normalize}, + {"UnpackSnorm2x16", GLSLstd450UnpackSnorm2x16}, + {"InterpolateAtCentroid", GLSLstd450InterpolateAtCentroid}, + {"Refract", GLSLstd450Refract}, + {"Fma", GLSLstd450Fma}, + {"UClamp", GLSLstd450UClamp}, + {"FAbs", GLSLstd450FAbs}, + {"RoundEven", GLSLstd450RoundEven}, + {"FSign", GLSLstd450FSign}, + {"SSign", GLSLstd450SSign}, + {"Asinh", GLSLstd450Asinh}, + {"PackHalf2x16", GLSLstd450PackHalf2x16}, + {"Tan", GLSLstd450Tan}, + {"SMin", GLSLstd450SMin}, + {"Degrees", GLSLstd450Degrees}, + {"PackSnorm2x16", GLSLstd450PackSnorm2x16}, + {"FMix", GLSLstd450FMix}, + {"Atan2", GLSLstd450Atan2}, + {"PackUnorm2x16", GLSLstd450PackUnorm2x16}, + {"NMax", GLSLstd450NMax}, + {"NClamp", GLSLstd450NClamp}, + {"FindSMsb", GLSLstd450FindSMsb}, + {"Atanh", GLSLstd450Atanh}, + {"Atan", GLSLstd450Atan}, + {"Modf", GLSLstd450Modf}, + {"Cosh", GLSLstd450Cosh}, + {"Exp2", GLSLstd450Exp2}, + {"Tanh", GLSLstd450Tanh}, + {"UMin", GLSLstd450UMin}, + {"FMin", GLSLstd450FMin}, + {"Log", GLSLstd450Log}, + {"SAbs", GLSLstd450SAbs}, + {"IMix", GLSLstd450IMix}, + {"Step", GLSLstd450Step}, + {"InterpolateAtSample", GLSLstd450InterpolateAtSample}, + {"UnpackHalf2x16", GLSLstd450UnpackHalf2x16}, + {"PackDouble2x32", GLSLstd450PackDouble2x32}, + {"FMax", GLSLstd450FMax}, + {"Length", GLSLstd450Length}, + {"Distance", GLSLstd450Distance}, + {"SmoothStep", GLSLstd450SmoothStep}, + {"UnpackUnorm2x16", GLSLstd450UnpackUnorm2x16}, + {"SMax", GLSLstd450SMax}, + {"UnpackSnorm4x8", GLSLstd450UnpackSnorm4x8}, + {"Asin", GLSLstd450Asin}, + {"UnpackUnorm4x8", GLSLstd450UnpackUnorm4x8}, + {"Ldexp", GLSLstd450Ldexp}, + {"Ceil", GLSLstd450Ceil}, + {"SClamp", GLSLstd450SClamp}, + {"Trunc", GLSLstd450Trunc}, + {"Sin", GLSLstd450Sin}, + {"Pow", GLSLstd450Pow}, + {"FindILsb", GLSLstd450FindILsb}, + {"Acos", GLSLstd450Acos}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 81; + }; -bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value) -{ const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) + if(str == words[i].first) { - value = words[i].value; + value = words[i].second; return true; } else diff --git a/source/slang/slang-lookup-spirv.h b/source/slang/slang-lookup-spirv.h index 47cd5b277..75e75cd6d 100644 --- a/source/slang/slang-lookup-spirv.h +++ b/source/slang/slang-lookup-spirv.h @@ -5,7 +5,5 @@ namespace Slang { -bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value); bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value); -bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value); } diff --git a/source/slang/slang-lookup-spvcapability.cpp b/source/slang/slang-lookup-spvcapability.cpp deleted file mode 100644 index 5e7e18037..000000000 --- a/source/slang/slang-lookup-spvcapability.cpp +++ /dev/null @@ -1,303 +0,0 @@ -// Hash function for SpvCapability -// -// This file was thoughtfully generated by a machine, -// don't even think about modifying it yourself! -// - -#include "../core/slang-common.h" -#include "../core/slang-string.h" -#include "spirv/unified1/spirv.h" - - -namespace Slang -{ - -static const unsigned tableSalt[238] ={ - 4, 1, 0, 0, 0, 5, 1, 1, 1, 1, 0, 3, 4, 1, 0, 0, - 1, 6, 0, 1, 4, 0, 0, 1, 5, 0, 0, 1, 2, 0, 2, 2, - 0, 0, 0, 2, 3, 3, 7, 3, 0, 4, 0, 4, 5, 3, 1, 2, - 0, 6, 1, 4, 2, 1, 0, 1, 7, 3, 0, 0, 0, 1, 2, 2, - 0, 4, 1, 1, 5, 2, 0, 0, 1, 6, 4, 1, 0, 5, 1, 0, - 7, 1, 1, 2, 2, 1, 1, 0, 4, 0, 0, 2, 0, 4, 10, 0, - 0, 0, 1, 0, 4, 3, 1, 0, 0, 1, 4, 6, 2, 5, 1, 1, - 0, 3, 1, 4, 3, 1, 0, 2, 1, 0, 0, 0, 1, 1, 3, 3, - 9, 0, 0, 0, 0, 2, 5, 0, 0, 8, 0, 12, 0, 0, 0, 5, - 5, 4, 2, 1, 6, 1, 0, 0, 20, 3, 7, 1, 13, 0, 4, 14, - 5, 2, 0, 5, 0, 8, 3, 0, 1, 2, 1, 0, 3, 0, 18, 5, - 8, 0, 10, 0, 14, 0, 3, 0, 0, 0, 13, 0, 0, 2, 24, 6, - 4, 0, 3, 0, 1, 0, 0, 7, 4, 0, 0, 5, 2, 0, 35, 6, - 0, 0, 2, 5, 6, 34, 32, 29, 0, 10, 7, 0, 90, 0, 3, 36, - 73, 39, 193, 0, 1, 1, 0, 83, 8, 0, 0, 712, 2, 0 -}; - -struct KV -{ - const char* name; - SpvCapability value; -}; - -static const KV words[238] = -{ - {"ShaderViewportIndex", SpvCapabilityShaderViewportIndex}, - {"FragmentBarycentricNV", SpvCapabilityFragmentBarycentricNV}, - {"StorageImageWriteWithoutFormat", SpvCapabilityStorageImageWriteWithoutFormat}, - {"RayTracingMotionBlurNV", SpvCapabilityRayTracingMotionBlurNV}, - {"StorageImageArrayNonUniformIndexingEXT", SpvCapabilityStorageImageArrayNonUniformIndexingEXT}, - {"UnstructuredLoopControlsINTEL", SpvCapabilityUnstructuredLoopControlsINTEL}, - {"BlockingPipesINTEL", SpvCapabilityBlockingPipesINTEL}, - {"Image1D", SpvCapabilityImage1D}, - {"LiteralSampler", SpvCapabilityLiteralSampler}, - {"SubgroupAvcMotionEstimationINTEL", SpvCapabilitySubgroupAvcMotionEstimationINTEL}, - {"GroupNonUniformQuad", SpvCapabilityGroupNonUniformQuad}, - {"FunctionPointersINTEL", SpvCapabilityFunctionPointersINTEL}, - {"UniformTexelBufferArrayNonUniformIndexing", SpvCapabilityUniformTexelBufferArrayNonUniformIndexing}, - {"RayCullMaskKHR", SpvCapabilityRayCullMaskKHR}, - {"CoreBuiltinsARM", SpvCapabilityCoreBuiltinsARM}, - {"USMStorageClassesINTEL", SpvCapabilityUSMStorageClassesINTEL}, - {"ArbitraryPrecisionIntegersINTEL", SpvCapabilityArbitraryPrecisionIntegersINTEL}, - {"IOPipesINTEL", SpvCapabilityIOPipesINTEL}, - {"MultiView", SpvCapabilityMultiView}, - {"RayTracingNV", SpvCapabilityRayTracingNV}, - {"OptNoneINTEL", SpvCapabilityOptNoneINTEL}, - {"SubgroupBufferBlockIOINTEL", SpvCapabilitySubgroupBufferBlockIOINTEL}, - {"TessellationPointSize", SpvCapabilityTessellationPointSize}, - {"Vector16", SpvCapabilityVector16}, - {"RayQueryPositionFetchKHR", SpvCapabilityRayQueryPositionFetchKHR}, - {"GenericPointer", SpvCapabilityGenericPointer}, - {"UniformBufferArrayDynamicIndexing", SpvCapabilityUniformBufferArrayDynamicIndexing}, - {"ImageMSArray", SpvCapabilityImageMSArray}, - {"AtomicStorageOps", SpvCapabilityAtomicStorageOps}, - {"DotProductInputAll", SpvCapabilityDotProductInputAll}, - {"InputAttachmentArrayNonUniformIndexing", SpvCapabilityInputAttachmentArrayNonUniformIndexing}, - {"AsmINTEL", SpvCapabilityAsmINTEL}, - {"DotProductInput4x8BitPackedKHR", SpvCapabilityDotProductInput4x8BitPackedKHR}, - {"StorageTexelBufferArrayNonUniformIndexing", SpvCapabilityStorageTexelBufferArrayNonUniformIndexing}, - {"FPGADSPControlINTEL", SpvCapabilityFPGADSPControlINTEL}, - {"DotProduct", SpvCapabilityDotProduct}, - {"StorageImageMultisample", SpvCapabilityStorageImageMultisample}, - {"StorageTexelBufferArrayDynamicIndexingEXT", SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT}, - {"SampledImageArrayDynamicIndexing", SpvCapabilitySampledImageArrayDynamicIndexing}, - {"VulkanMemoryModelDeviceScopeKHR", SpvCapabilityVulkanMemoryModelDeviceScopeKHR}, - {"ShadingRateNV", SpvCapabilityShadingRateNV}, - {"DotProductInput4x8BitKHR", SpvCapabilityDotProductInput4x8BitKHR}, - {"ShaderNonUniformEXT", SpvCapabilityShaderNonUniformEXT}, - {"ShaderStereoViewNV", SpvCapabilityShaderStereoViewNV}, - {"UniformAndStorageBuffer16BitAccess", SpvCapabilityUniformAndStorageBuffer16BitAccess}, - {"RoundingModeRTE", SpvCapabilityRoundingModeRTE}, - {"TileImageColorReadAccessEXT", SpvCapabilityTileImageColorReadAccessEXT}, - {"TileImageDepthReadAccessEXT", SpvCapabilityTileImageDepthReadAccessEXT}, - {"PerViewAttributesNV", SpvCapabilityPerViewAttributesNV}, - {"DemoteToHelperInvocationEXT", SpvCapabilityDemoteToHelperInvocationEXT}, - {"AtomicFloat16MinMaxEXT", SpvCapabilityAtomicFloat16MinMaxEXT}, - {"GroupNonUniformArithmetic", SpvCapabilityGroupNonUniformArithmetic}, - {"ShaderLayer", SpvCapabilityShaderLayer}, - {"VariableLengthArrayINTEL", SpvCapabilityVariableLengthArrayINTEL}, - {"ImageReadWriteLodAMD", SpvCapabilityImageReadWriteLodAMD}, - {"ImageCubeArray", SpvCapabilityImageCubeArray}, - {"Float16Buffer", SpvCapabilityFloat16Buffer}, - {"VulkanMemoryModelDeviceScope", SpvCapabilityVulkanMemoryModelDeviceScope}, - {"ImageRect", SpvCapabilityImageRect}, - {"UniformDecoration", SpvCapabilityUniformDecoration}, - {"AtomicFloat64AddEXT", SpvCapabilityAtomicFloat64AddEXT}, - {"VectorComputeINTEL", SpvCapabilityVectorComputeINTEL}, - {"Float16", SpvCapabilityFloat16}, - {"DeviceEnqueue", SpvCapabilityDeviceEnqueue}, - {"MinLod", SpvCapabilityMinLod}, - {"Float16ImageAMD", SpvCapabilityFloat16ImageAMD}, - {"SubgroupImageMediaBlockIOINTEL", SpvCapabilitySubgroupImageMediaBlockIOINTEL}, - {"SparseResidency", SpvCapabilitySparseResidency}, - {"UniformTexelBufferArrayDynamicIndexing", SpvCapabilityUniformTexelBufferArrayDynamicIndexing}, - {"Pipes", SpvCapabilityPipes}, - {"InputAttachment", SpvCapabilityInputAttachment}, - {"FPGAMemoryAttributesINTEL", SpvCapabilityFPGAMemoryAttributesINTEL}, - {"RuntimeDescriptorArrayEXT", SpvCapabilityRuntimeDescriptorArrayEXT}, - {"GeometryPointSize", SpvCapabilityGeometryPointSize}, - {"Shader", SpvCapabilityShader}, - {"IntegerFunctions2INTEL", SpvCapabilityIntegerFunctions2INTEL}, - {"StorageImageArrayDynamicIndexing", SpvCapabilityStorageImageArrayDynamicIndexing}, - {"Int64Atomics", SpvCapabilityInt64Atomics}, - {"ImageFootprintNV", SpvCapabilityImageFootprintNV}, - {"IndirectReferencesINTEL", SpvCapabilityIndirectReferencesINTEL}, - {"ShaderSMBuiltinsNV", SpvCapabilityShaderSMBuiltinsNV}, - {"StoragePushConstant8", SpvCapabilityStoragePushConstant8}, - {"FPGAKernelAttributesINTEL", SpvCapabilityFPGAKernelAttributesINTEL}, - {"ImageBuffer", SpvCapabilityImageBuffer}, - {"ImageReadWrite", SpvCapabilityImageReadWrite}, - {"AtomicStorage", SpvCapabilityAtomicStorage}, - {"SignedZeroInfNanPreserve", SpvCapabilitySignedZeroInfNanPreserve}, - {"Groups", SpvCapabilityGroups}, - {"DebugInfoModuleINTEL", SpvCapabilityDebugInfoModuleINTEL}, - {"GroupUniformArithmeticKHR", SpvCapabilityGroupUniformArithmeticKHR}, - {"Int16", SpvCapabilityInt16}, - {"DenormFlushToZero", SpvCapabilityDenormFlushToZero}, - {"TransformFeedback", SpvCapabilityTransformFeedback}, - {"StencilExportEXT", SpvCapabilityStencilExportEXT}, - {"InputAttachmentArrayNonUniformIndexingEXT", SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT}, - {"DotProductKHR", SpvCapabilityDotProductKHR}, - {"FPGABufferLocationINTEL", SpvCapabilityFPGABufferLocationINTEL}, - {"DotProductInput4x8Bit", SpvCapabilityDotProductInput4x8Bit}, - {"ShaderInvocationReorderNV", SpvCapabilityShaderInvocationReorderNV}, - {"ImageMipmap", SpvCapabilityImageMipmap}, - {"FunctionFloatControlINTEL", SpvCapabilityFunctionFloatControlINTEL}, - {"AtomicFloat16AddEXT", SpvCapabilityAtomicFloat16AddEXT}, - {"RayQueryProvisionalKHR", SpvCapabilityRayQueryProvisionalKHR}, - {"GroupNonUniformVote", SpvCapabilityGroupNonUniformVote}, - {"StorageTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT}, - {"ArbitraryPrecisionFloatingPointINTEL", SpvCapabilityArbitraryPrecisionFloatingPointINTEL}, - {"StorageInputOutput16", SpvCapabilityStorageInputOutput16}, - {"SampledImageArrayNonUniformIndexing", SpvCapabilitySampledImageArrayNonUniformIndexing}, - {"SubgroupVoteKHR", SpvCapabilitySubgroupVoteKHR}, - {"Tessellation", SpvCapabilityTessellation}, - {"Geometry", SpvCapabilityGeometry}, - {"SubgroupAvcMotionEstimationChromaINTEL", SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL}, - {"StorageImageReadWithoutFormat", SpvCapabilityStorageImageReadWithoutFormat}, - {"Int64", SpvCapabilityInt64}, - {"DemoteToHelperInvocation", SpvCapabilityDemoteToHelperInvocation}, - {"MeshShadingEXT", SpvCapabilityMeshShadingEXT}, - {"UniformAndStorageBuffer8BitAccess", SpvCapabilityUniformAndStorageBuffer8BitAccess}, - {"RayTracingProvisionalKHR", SpvCapabilityRayTracingProvisionalKHR}, - {"UniformBufferArrayNonUniformIndexing", SpvCapabilityUniformBufferArrayNonUniformIndexing}, - {"VulkanMemoryModelKHR", SpvCapabilityVulkanMemoryModelKHR}, - {"SubgroupShuffleINTEL", SpvCapabilitySubgroupShuffleINTEL}, - {"SubgroupDispatch", SpvCapabilitySubgroupDispatch}, - {"MemoryAccessAliasingINTEL", SpvCapabilityMemoryAccessAliasingINTEL}, - {"StorageBuffer16BitAccess", SpvCapabilityStorageBuffer16BitAccess}, - {"RuntimeDescriptorArray", SpvCapabilityRuntimeDescriptorArray}, - {"StorageImageArrayNonUniformIndexing", SpvCapabilityStorageImageArrayNonUniformIndexing}, - {"Kernel", SpvCapabilityKernel}, - {"BitInstructions", SpvCapabilityBitInstructions}, - {"WorkgroupMemoryExplicitLayout8BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR}, - {"Sampled1D", SpvCapabilitySampled1D}, - {"StorageTexelBufferArrayDynamicIndexing", SpvCapabilityStorageTexelBufferArrayDynamicIndexing}, - {"ImageQuery", SpvCapabilityImageQuery}, - {"MultiViewport", SpvCapabilityMultiViewport}, - {"UniformTexelBufferArrayDynamicIndexingEXT", SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT}, - {"StorageUniform16", SpvCapabilityStorageUniform16}, - {"SubgroupImageBlockIOINTEL", SpvCapabilitySubgroupImageBlockIOINTEL}, - {"WorkgroupMemoryExplicitLayout16BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR}, - {"KernelAttributesINTEL", SpvCapabilityKernelAttributesINTEL}, - {"PipeStorage", SpvCapabilityPipeStorage}, - {"ShaderViewportMaskNV", SpvCapabilityShaderViewportMaskNV}, - {"Matrix", SpvCapabilityMatrix}, - {"GroupNonUniformShuffleRelative", SpvCapabilityGroupNonUniformShuffleRelative}, - {"RuntimeAlignedAttributeINTEL", SpvCapabilityRuntimeAlignedAttributeINTEL}, - {"CullDistance", SpvCapabilityCullDistance}, - {"Int8", SpvCapabilityInt8}, - {"RayTraversalPrimitiveCullingKHR", SpvCapabilityRayTraversalPrimitiveCullingKHR}, - {"SampleMaskPostDepthCoverage", SpvCapabilitySampleMaskPostDepthCoverage}, - {"GroupNonUniformShuffle", SpvCapabilityGroupNonUniformShuffle}, - {"ImageBasic", SpvCapabilityImageBasic}, - {"WorkgroupMemoryExplicitLayoutKHR", SpvCapabilityWorkgroupMemoryExplicitLayoutKHR}, - {"FPGAClusterAttributesINTEL", SpvCapabilityFPGAClusterAttributesINTEL}, - {"PhysicalStorageBufferAddresses", SpvCapabilityPhysicalStorageBufferAddresses}, - {"UniformTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT}, - {"StorageBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageBufferArrayNonUniformIndexingEXT}, - {"FragmentShaderSampleInterlockEXT", SpvCapabilityFragmentShaderSampleInterlockEXT}, - {"SampledImageArrayNonUniformIndexingEXT", SpvCapabilitySampledImageArrayNonUniformIndexingEXT}, - {"InterpolationFunction", SpvCapabilityInterpolationFunction}, - {"AtomicFloat32AddEXT", SpvCapabilityAtomicFloat32AddEXT}, - {"Int64ImageEXT", SpvCapabilityInt64ImageEXT}, - {"SubgroupBallotKHR", SpvCapabilitySubgroupBallotKHR}, - {"RoundToInfinityINTEL", SpvCapabilityRoundToInfinityINTEL}, - {"DrawParameters", SpvCapabilityDrawParameters}, - {"VariablePointers", SpvCapabilityVariablePointers}, - {"FragmentShaderShadingRateInterlockEXT", SpvCapabilityFragmentShaderShadingRateInterlockEXT}, - {"NamedBarrier", SpvCapabilityNamedBarrier}, - {"ComputeDerivativeGroupQuadsNV", SpvCapabilityComputeDerivativeGroupQuadsNV}, - {"SampledCubeArray", SpvCapabilitySampledCubeArray}, - {"Addresses", SpvCapabilityAddresses}, - {"LongConstantCompositeINTEL", SpvCapabilityLongConstantCompositeINTEL}, - {"ArbitraryPrecisionFixedPointINTEL", SpvCapabilityArbitraryPrecisionFixedPointINTEL}, - {"RayTracingKHR", SpvCapabilityRayTracingKHR}, - {"RayQueryKHR", SpvCapabilityRayQueryKHR}, - {"FragmentDensityEXT", SpvCapabilityFragmentDensityEXT}, - {"InputAttachmentArrayDynamicIndexingEXT", SpvCapabilityInputAttachmentArrayDynamicIndexingEXT}, - {"FPGAInvocationPipeliningAttributesINTEL", SpvCapabilityFPGAInvocationPipeliningAttributesINTEL}, - {"ShaderViewportIndexLayerEXT", SpvCapabilityShaderViewportIndexLayerEXT}, - {"PhysicalStorageBufferAddressesEXT", SpvCapabilityPhysicalStorageBufferAddressesEXT}, - {"SplitBarrierINTEL", SpvCapabilitySplitBarrierINTEL}, - {"ImageGatherExtended", SpvCapabilityImageGatherExtended}, - {"CooperativeMatrixNV", SpvCapabilityCooperativeMatrixNV}, - {"FloatingPointModeINTEL", SpvCapabilityFloatingPointModeINTEL}, - {"SubgroupAvcMotionEstimationIntraINTEL", SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL}, - {"DotProductInputAllKHR", SpvCapabilityDotProductInputAllKHR}, - {"AtomicFloat64MinMaxEXT", SpvCapabilityAtomicFloat64MinMaxEXT}, - {"DeviceGroup", SpvCapabilityDeviceGroup}, - {"RayTracingOpacityMicromapEXT", SpvCapabilityRayTracingOpacityMicromapEXT}, - {"GroupNonUniform", SpvCapabilityGroupNonUniform}, - {"BindlessTextureNV", SpvCapabilityBindlessTextureNV}, - {"GeometryShaderPassthroughNV", SpvCapabilityGeometryShaderPassthroughNV}, - {"FragmentFullyCoveredEXT", SpvCapabilityFragmentFullyCoveredEXT}, - {"ShaderNonUniform", SpvCapabilityShaderNonUniform}, - {"DotProductInput4x8BitPacked", SpvCapabilityDotProductInput4x8BitPacked}, - {"ShaderViewportIndexLayerNV", SpvCapabilityShaderViewportIndexLayerNV}, - {"RayTracingPositionFetchKHR", SpvCapabilityRayTracingPositionFetchKHR}, - {"VectorAnyINTEL", SpvCapabilityVectorAnyINTEL}, - {"FPFastMathModeINTEL", SpvCapabilityFPFastMathModeINTEL}, - {"AtomicFloat32MinMaxEXT", SpvCapabilityAtomicFloat32MinMaxEXT}, - {"SampleMaskOverrideCoverageNV", SpvCapabilitySampleMaskOverrideCoverageNV}, - {"FragmentShadingRateKHR", SpvCapabilityFragmentShadingRateKHR}, - {"GroupNonUniformPartitionedNV", SpvCapabilityGroupNonUniformPartitionedNV}, - {"StorageBufferArrayNonUniformIndexing", SpvCapabilityStorageBufferArrayNonUniformIndexing}, - {"ExpectAssumeKHR", SpvCapabilityExpectAssumeKHR}, - {"FPGAMemoryAccessesINTEL", SpvCapabilityFPGAMemoryAccessesINTEL}, - {"StorageImageExtendedFormats", SpvCapabilityStorageImageExtendedFormats}, - {"FPGAArgumentInterfacesINTEL", SpvCapabilityFPGAArgumentInterfacesINTEL}, - {"SampleRateShading", SpvCapabilitySampleRateShading}, - {"VariablePointersStorageBuffer", SpvCapabilityVariablePointersStorageBuffer}, - {"StoragePushConstant16", SpvCapabilityStoragePushConstant16}, - {"GeometryStreams", SpvCapabilityGeometryStreams}, - {"FPGARegINTEL", SpvCapabilityFPGARegINTEL}, - {"LoopFuseINTEL", SpvCapabilityLoopFuseINTEL}, - {"Linkage", SpvCapabilityLinkage}, - {"ComputeDerivativeGroupLinearNV", SpvCapabilityComputeDerivativeGroupLinearNV}, - {"DerivativeControl", SpvCapabilityDerivativeControl}, - {"StorageBufferArrayDynamicIndexing", SpvCapabilityStorageBufferArrayDynamicIndexing}, - {"SampledBuffer", SpvCapabilitySampledBuffer}, - {"StorageBuffer8BitAccess", SpvCapabilityStorageBuffer8BitAccess}, - {"FragmentBarycentricKHR", SpvCapabilityFragmentBarycentricKHR}, - {"GroupNonUniformClustered", SpvCapabilityGroupNonUniformClustered}, - {"MeshShadingNV", SpvCapabilityMeshShadingNV}, - {"RoundingModeRTZ", SpvCapabilityRoundingModeRTZ}, - {"StorageUniformBufferBlock16", SpvCapabilityStorageUniformBufferBlock16}, - {"DenormPreserve", SpvCapabilityDenormPreserve}, - {"FragmentShaderPixelInterlockEXT", SpvCapabilityFragmentShaderPixelInterlockEXT}, - {"Max", SpvCapabilityMax}, - {"GroupNonUniformBallot", SpvCapabilityGroupNonUniformBallot}, - {"InputAttachmentArrayDynamicIndexing", SpvCapabilityInputAttachmentArrayDynamicIndexing}, - {"GroupNonUniformRotateKHR", SpvCapabilityGroupNonUniformRotateKHR}, - {"ClipDistance", SpvCapabilityClipDistance}, - {"ShaderClockKHR", SpvCapabilityShaderClockKHR}, - {"FragmentMaskAMD", SpvCapabilityFragmentMaskAMD}, - {"FPGALoopControlsINTEL", SpvCapabilityFPGALoopControlsINTEL}, - {"Float64", SpvCapabilityFloat64}, - {"TileImageStencilReadAccessEXT", SpvCapabilityTileImageStencilReadAccessEXT}, - {"UniformBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformBufferArrayNonUniformIndexingEXT}, - {"ImageGatherBiasLodAMD", SpvCapabilityImageGatherBiasLodAMD}, - {"SampledRect", SpvCapabilitySampledRect}, - {"VulkanMemoryModel", SpvCapabilityVulkanMemoryModel}, -}; - -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} - -bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value) -{ - const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) - { - value = words[i].value; - return true; - } - else - { - return false; - } -} - -} diff --git a/source/slang/slang-lookup-spvop.cpp b/source/slang/slang-lookup-spvop.cpp deleted file mode 100644 index c10a25997..000000000 --- a/source/slang/slang-lookup-spvop.cpp +++ /dev/null @@ -1,813 +0,0 @@ -// Hash function for SpvOp -// -// This file was thoughtfully generated by a machine, -// don't even think about modifying it yourself! -// - -#include "../core/slang-common.h" -#include "../core/slang-string.h" -#include "spirv/unified1/spirv.h" - - -namespace Slang -{ - -static const unsigned tableSalt[718] ={ - 0, 0, 1, 5, 1, 0, 2, 0, 1, 6, 0, 1, 3, 0, 4, 1, - 1, 1, 1, 0, 0, 0, 0, 3, 2, 1, 2, 1, 1, 5, 0, 0, - 1, 1, 1, 1, 0, 0, 0, 0, 1, 9, 1, 0, 0, 1, 0, 2, - 1, 1, 0, 1, 3, 1, 3, 1, 1, 0, 0, 0, 0, 0, 2, 5, - 0, 1, 1, 0, 1, 1, 1, 1, 4, 1, 6, 2, 2, 6, 2, 1, - 1, 2, 1, 0, 1, 6, 4, 2, 0, 1, 0, 1, 1, 1, 4, 3, - 2, 4, 0, 0, 0, 2, 2, 1, 2, 0, 0, 2, 0, 5, 5, 0, - 6, 0, 0, 0, 8, 5, 2, 1, 5, 1, 0, 0, 10, 0, 0, 2, - 1, 0, 0, 2, 4, 0, 1, 2, 3, 0, 3, 0, 2, 5, 0, 2, - 0, 0, 2, 0, 2, 0, 0, 0, 1, 0, 0, 0, 6, 1, 0, 1, - 1, 2, 1, 0, 1, 1, 0, 1, 10, 2, 0, 6, 0, 0, 1, 6, - 0, 0, 9, 0, 4, 8, 0, 3, 3, 2, 0, 8, 2, 8, 0, 1, - 3, 0, 0, 0, 3, 4, 5, 6, 0, 6, 6, 2, 1, 0, 1, 1, - 5, 1, 1, 2, 2, 1, 2, 5, 1, 1, 4, 5, 1, 0, 0, 0, - 2, 0, 0, 3, 1, 4, 0, 10, 5, 1, 1, 0, 2, 4, 0, 3, - 5, 1, 1, 5, 4, 1, 7, 1, 0, 1, 0, 4, 5, 0, 0, 4, - 3, 4, 2, 0, 1, 0, 3, 4, 1, 3, 0, 0, 0, 1, 1, 0, - 0, 1, 0, 1, 0, 0, 2, 0, 3, 1, 1, 0, 0, 4, 0, 0, - 6, 0, 6, 0, 0, 2, 1, 29, 2, 0, 1, 6, 0, 0, 6, 6, - 1, 0, 0, 1, 13, 0, 2, 4, 3, 6, 1, 2, 2, 7, 0, 0, - 13, 0, 0, 2, 0, 0, 0, 0, 1, 1, 0, 2, 1, 5, 1, 0, - 2, 3, 0, 4, 5, 6, 0, 1, 2, 4, 2, 1, 1, 3, 0, 0, - 1, 1, 1, 2, 10, 0, 0, 0, 0, 0, 12, 0, 0, 6, 3, 0, - 6, 1, 6, 1, 4, 2, 1, 1, 0, 1, 0, 22, 0, 0, 15, 2, - 2, 0, 1, 10, 3, 3, 5, 1, 20, 0, 6, 3, 0, 5, 5, 0, - 0, 2, 0, 2, 0, 0, 6, 3, 1, 0, 0, 8, 0, 16, 8, 8, - 1, 1, 3, 3, 8, 5, 8, 13, 4, 0, 9, 5, 0, 0, 4, 5, - 14, 1, 0, 0, 0, 2, 0, 1, 2, 23, 0, 0, 6, 2, 2, 0, - 1, 7, 4, 0, 3, 0, 4, 1, 0, 4, 7, 0, 0, 6, 0, 4, - 0, 10, 3, 7, 18, 1, 7, 4, 2, 2, 8, 0, 0, 15, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 5, 1, 5, 0, 3, 1, - 0, 0, 3, 2, 3, 0, 0, 2, 0, 0, 3, 30, 15, 36, 1, 0, - 1, 1, 7, 19, 0, 2, 7, 8, 0, 0, 2, 49, 0, 13, 20, 7, - 10, 1, 5, 8, 4, 22, 4, 28, 0, 1, 11, 17, 1, 2, 4, 27, - 0, 0, 0, 1, 11, 8, 0, 3, 5, 3, 5, 1, 17, 1, 0, 0, - 5, 17, 0, 0, 14, 6, 0, 13, 0, 6, 21, 21, 2, 0, 0, 14, - 0, 0, 44, 5, 1, 12, 26, 6, 0, 6, 10, 0, 24, 0, 0, 7, - 5, 0, 0, 0, 0, 0, 0, 1, 2, 46, 0, 8, 0, 1, 66, 0, - 0, 15, 0, 0, 7, 0, 2, 2, 0, 0, 0, 0, 2, 0, 0, 0, - 0, 0, 0, 10, 0, 0, 0, 4, 0, 82, 4, 0, 26, 0, 0, 0, - 9, 5, 0, 0, 0, 0, 67, 0, 43, 2, 0, 0, 21, 0, 0, 0, - 2, 49, 1, 0, 0, 4, 10, 10, 11, 1, 0, 74, 5, 33, 46, 0, - 0, 169, 0, 12, 49, 3, 4, 0, 1, 38, 87, 0, 0, 16, 0, 127, - 0, 0, 0, 66, 101, 148, 0, 5, 0, 9, 0, 1, 103, 161, 122, 5, - 0, 22, 0, 0, 1, 0, 69, 0, 6, 0, 882, 0, 0, 34 -}; - -struct KV -{ - const char* name; - SpvOp value; -}; - -static const KV words[718] = -{ - {"OpImageGather", SpvOpImageGather}, - {"OpVectorInsertDynamic", SpvOpVectorInsertDynamic}, - {"OpSetUserEventStatus", SpvOpSetUserEventStatus}, - {"OpMatrixTimesScalar", SpvOpMatrixTimesScalar}, - {"OpTypePointer", SpvOpTypePointer}, - {"OpTypeBufferSurfaceINTEL", SpvOpTypeBufferSurfaceINTEL}, - {"OpSubgroupBlockReadINTEL", SpvOpSubgroupBlockReadINTEL}, - {"OpVectorTimesMatrix", SpvOpVectorTimesMatrix}, - {"OpCaptureEventProfilingInfo", SpvOpCaptureEventProfilingInfo}, - {"OpUDiv", SpvOpUDiv}, - {"OpBranch", SpvOpBranch}, - {"OpImageSampleWeightedQCOM", SpvOpImageSampleWeightedQCOM}, - {"OpAtomicFAddEXT", SpvOpAtomicFAddEXT}, - {"OpArbitraryFloatACosPiINTEL", SpvOpArbitraryFloatACosPiINTEL}, - {"OpSubgroupImageMediaBlockWriteINTEL", SpvOpSubgroupImageMediaBlockWriteINTEL}, - {"OpTypeOpaque", SpvOpTypeOpaque}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL}, - {"OpPhi", SpvOpPhi}, - {"OpRayQueryGetWorldRayDirectionKHR", SpvOpRayQueryGetWorldRayDirectionKHR}, - {"OpSizeOf", SpvOpSizeOf}, - {"OpConvertBF16ToFINTEL", SpvOpConvertBF16ToFINTEL}, - {"OpFOrdGreaterThan", SpvOpFOrdGreaterThan}, - {"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL}, - {"OpArbitraryFloatATanINTEL", SpvOpArbitraryFloatATanINTEL}, - {"OpSubgroupAvcMceSetInterShapePenaltyINTEL", SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL}, - {"OpHitObjectRecordEmptyNV", SpvOpHitObjectRecordEmptyNV}, - {"OpControlBarrier", SpvOpControlBarrier}, - {"OpFixedRecipINTEL", SpvOpFixedRecipINTEL}, - {"OpReorderThreadWithHitObjectNV", SpvOpReorderThreadWithHitObjectNV}, - {"OpTypeAvcImeResultDualReferenceStreamoutINTEL", SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL}, - {"OpSubgroupAvcSicConvertToMcePayloadINTEL", SpvOpSubgroupAvcSicConvertToMcePayloadINTEL}, - {"OpSLessThan", SpvOpSLessThan}, - {"OpFixedSqrtINTEL", SpvOpFixedSqrtINTEL}, - {"OpSatConvertSToU", SpvOpSatConvertSToU}, - {"OpReturn", SpvOpReturn}, - {"OpAssumeTrueKHR", SpvOpAssumeTrueKHR}, - {"OpTraceMotionNV", SpvOpTraceMotionNV}, - {"OpFOrdEqual", SpvOpFOrdEqual}, - {"OpSUDotAccSat", SpvOpSUDotAccSat}, - {"OpTypeMatrix", SpvOpTypeMatrix}, - {"OpTypeEvent", SpvOpTypeEvent}, - {"OpHitObjectGetGeometryIndexNV", SpvOpHitObjectGetGeometryIndexNV}, - {"OpDecorateId", SpvOpDecorateId}, - {"OpAliasScopeListDeclINTEL", SpvOpAliasScopeListDeclINTEL}, - {"OpGenericCastToPtrExplicit", SpvOpGenericCastToPtrExplicit}, - {"OpCompositeExtract", SpvOpCompositeExtract}, - {"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL}, - {"OpSelect", SpvOpSelect}, - {"OpGenericPtrMemSemantics", SpvOpGenericPtrMemSemantics}, - {"OpExtInst", SpvOpExtInst}, - {"OpLessOrGreater", SpvOpLessOrGreater}, - {"OpImageSampleDrefExplicitLod", SpvOpImageSampleDrefExplicitLod}, - {"OpTypeNamedBarrier", SpvOpTypeNamedBarrier}, - {"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL}, - {"OpImageQueryLod", SpvOpImageQueryLod}, - {"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR}, - {"OpConstantFalse", SpvOpConstantFalse}, - {"OpImageDrefGather", SpvOpImageDrefGather}, - {"OpReportIntersectionKHR", SpvOpReportIntersectionKHR}, - {"OpSUDot", SpvOpSUDot}, - {"OpConstant", SpvOpConstant}, - {"OpULessThan", SpvOpULessThan}, - {"OpConstantFunctionPointerINTEL", SpvOpConstantFunctionPointerINTEL}, - {"OpFOrdNotEqual", SpvOpFOrdNotEqual}, - {"OpConstantComposite", SpvOpConstantComposite}, - {"OpNamedBarrierInitialize", SpvOpNamedBarrierInitialize}, - {"OpSubgroupAvcMceGetInterMajorShapeINTEL", SpvOpSubgroupAvcMceGetInterMajorShapeINTEL}, - {"OpAtomicIIncrement", SpvOpAtomicIIncrement}, - {"OpImageBlockMatchSADQCOM", SpvOpImageBlockMatchSADQCOM}, - {"OpGroupNonUniformBroadcastFirst", SpvOpGroupNonUniformBroadcastFirst}, - {"OpArbitraryFloatSqrtINTEL", SpvOpArbitraryFloatSqrtINTEL}, - {"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL}, - {"OpSubgroupAvcMceConvertToImePayloadINTEL", SpvOpSubgroupAvcMceConvertToImePayloadINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL}, - {"OpFSub", SpvOpFSub}, - {"OpImageSparseFetch", SpvOpImageSparseFetch}, - {"OpSubgroupAvcMceGetInterMinorShapeINTEL", SpvOpSubgroupAvcMceGetInterMinorShapeINTEL}, - {"OpArbitraryFloatPowNINTEL", SpvOpArbitraryFloatPowNINTEL}, - {"OpGetNumPipePackets", SpvOpGetNumPipePackets}, - {"OpFwidth", SpvOpFwidth}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL}, - {"OpInBoundsPtrAccessChain", SpvOpInBoundsPtrAccessChain}, - {"OpArbitraryFloatATanPiINTEL", SpvOpArbitraryFloatATanPiINTEL}, - {"OpGroupNonUniformBallotBitCount", SpvOpGroupNonUniformBallotBitCount}, - {"OpDecorateString", SpvOpDecorateString}, - {"OpImageQueryOrder", SpvOpImageQueryOrder}, - {"OpImageSparseSampleProjImplicitLod", SpvOpImageSparseSampleProjImplicitLod}, - {"OpTypeAvcImeResultSingleReferenceStreamoutINTEL", SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL}, - {"OpCopyMemory", SpvOpCopyMemory}, - {"OpUnordered", SpvOpUnordered}, - {"OpGroupAsyncCopy", SpvOpGroupAsyncCopy}, - {"OpTraceRayKHR", SpvOpTraceRayKHR}, - {"OpBitReverse", SpvOpBitReverse}, - {"OpGroupNonUniformLogicalOr", SpvOpGroupNonUniformLogicalOr}, - {"OpIsValidEvent", SpvOpIsValidEvent}, - {"OpHitObjectGetRayTMaxNV", SpvOpHitObjectGetRayTMaxNV}, - {"OpTraceRayMotionNV", SpvOpTraceRayMotionNV}, - {"OpCapability", SpvOpCapability}, - {"OpGroupLogicalXorKHR", SpvOpGroupLogicalXorKHR}, - {"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL}, - {"OpSubgroupImageMediaBlockReadINTEL", SpvOpSubgroupImageMediaBlockReadINTEL}, - {"OpImageSparseRead", SpvOpImageSparseRead}, - {"OpSubgroupAvcImeSetWeightedSadINTEL", SpvOpSubgroupAvcImeSetWeightedSadINTEL}, - {"OpSubgroupShuffleUpINTEL", SpvOpSubgroupShuffleUpINTEL}, - {"OpExecutionMode", SpvOpExecutionMode}, - {"OpImageSparseGather", SpvOpImageSparseGather}, - {"OpSLessThanEqual", SpvOpSLessThanEqual}, - {"OpHitObjectGetShaderRecordBufferHandleNV", SpvOpHitObjectGetShaderRecordBufferHandleNV}, - {"OpImageFetch", SpvOpImageFetch}, - {"OpGroupAny", SpvOpGroupAny}, - {"OpUDotKHR", SpvOpUDotKHR}, - {"OpSubgroupAvcFmeInitializeINTEL", SpvOpSubgroupAvcFmeInitializeINTEL}, - {"OpRayQueryGenerateIntersectionKHR", SpvOpRayQueryGenerateIntersectionKHR}, - {"OpIsNormal", SpvOpIsNormal}, - {"OpSubgroupAvcImeConvertToMcePayloadINTEL", SpvOpSubgroupAvcImeConvertToMcePayloadINTEL}, - {"OpSourceContinued", SpvOpSourceContinued}, - {"OpAtomicStore", SpvOpAtomicStore}, - {"OpAtomicFlagTestAndSet", SpvOpAtomicFlagTestAndSet}, - {"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL}, - {"OpAtomicSMax", SpvOpAtomicSMax}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL}, - {"OpAtomicIAdd", SpvOpAtomicIAdd}, - {"OpGroupNonUniformShuffleXor", SpvOpGroupNonUniformShuffleXor}, - {"OpConstantNull", SpvOpConstantNull}, - {"OpArbitraryFloatATan2INTEL", SpvOpArbitraryFloatATan2INTEL}, - {"OpArbitraryFloatSinPiINTEL", SpvOpArbitraryFloatSinPiINTEL}, - {"OpTypeAccelerationStructureKHR", SpvOpTypeAccelerationStructureKHR}, - {"OpTypeVmeImageINTEL", SpvOpTypeVmeImageINTEL}, - {"OpTypeStructContinuedINTEL", SpvOpTypeStructContinuedINTEL}, - {"OpLogicalNot", SpvOpLogicalNot}, - {"OpCopyMemorySized", SpvOpCopyMemorySized}, - {"OpCompositeConstruct", SpvOpCompositeConstruct}, - {"OpRayQueryGetIntersectionInstanceIdKHR", SpvOpRayQueryGetIntersectionInstanceIdKHR}, - {"OpSubgroupAvcImeRefWindowSizeINTEL", SpvOpSubgroupAvcImeRefWindowSizeINTEL}, - {"OpEndStreamPrimitive", SpvOpEndStreamPrimitive}, - {"OpBranchConditional", SpvOpBranchConditional}, - {"OpOrdered", SpvOpOrdered}, - {"OpIAverageINTEL", SpvOpIAverageINTEL}, - {"OpConvertSampledImageToUNV", SpvOpConvertSampledImageToUNV}, - {"OpIEqual", SpvOpIEqual}, - {"OpFunctionCall", SpvOpFunctionCall}, - {"OpColorAttachmentReadEXT", SpvOpColorAttachmentReadEXT}, - {"OpHitObjectGetHitKindNV", SpvOpHitObjectGetHitKindNV}, - {"OpFUnordEqual", SpvOpFUnordEqual}, - {"OpFixedCosPiINTEL", SpvOpFixedCosPiINTEL}, - {"OpSource", SpvOpSource}, - {"OpGroupNonUniformAll", SpvOpGroupNonUniformAll}, - {"OpTypeBool", SpvOpTypeBool}, - {"OpSampledImage", SpvOpSampledImage}, - {"OpAtomicLoad", SpvOpAtomicLoad}, - {"OpTypeAvcSicResultINTEL", SpvOpTypeAvcSicResultINTEL}, - {"OpSubgroupAvcImeSetDualReferenceINTEL", SpvOpSubgroupAvcImeSetDualReferenceINTEL}, - {"OpGroupFAdd", SpvOpGroupFAdd}, - {"OpSpecConstantTrue", SpvOpSpecConstantTrue}, - {"OpArbitraryFloatRecipINTEL", SpvOpArbitraryFloatRecipINTEL}, - {"OpBitwiseXor", SpvOpBitwiseXor}, - {"OpRayQueryGetIntersectionInstanceCustomIndexKHR", SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR}, - {"OpStencilAttachmentReadEXT", SpvOpStencilAttachmentReadEXT}, - {"OpFUnordLessThanEqual", SpvOpFUnordLessThanEqual}, - {"OpAsmCallINTEL", SpvOpAsmCallINTEL}, - {"OpInBoundsAccessChain", SpvOpInBoundsAccessChain}, - {"OpAbsISubINTEL", SpvOpAbsISubINTEL}, - {"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL}, - {"OpFUnordNotEqual", SpvOpFUnordNotEqual}, - {"OpSubgroupImageBlockWriteINTEL", SpvOpSubgroupImageBlockWriteINTEL}, - {"OpCommitReadPipe", SpvOpCommitReadPipe}, - {"OpSubgroupAvcSicConfigureSkcINTEL", SpvOpSubgroupAvcSicConfigureSkcINTEL}, - {"OpTypeSampledImage", SpvOpTypeSampledImage}, - {"OpCompositeInsert", SpvOpCompositeInsert}, - {"OpSubgroupAvcImeGetBorderReachedINTEL", SpvOpSubgroupAvcImeGetBorderReachedINTEL}, - {"OpGroupNonUniformRotateKHR", SpvOpGroupNonUniformRotateKHR}, - {"OpArbitraryFloatExp2INTEL", SpvOpArbitraryFloatExp2INTEL}, - {"OpGetKernelNDrangeMaxSubGroupSize", SpvOpGetKernelNDrangeMaxSubGroupSize}, - {"OpSubgroupAvcMceConvertToImeResultINTEL", SpvOpSubgroupAvcMceConvertToImeResultINTEL}, - {"OpBitwiseAnd", SpvOpBitwiseAnd}, - {"OpUMul32x16INTEL", SpvOpUMul32x16INTEL}, - {"OpConstantCompositeContinuedINTEL", SpvOpConstantCompositeContinuedINTEL}, - {"OpImageQuerySizeLod", SpvOpImageQuerySizeLod}, - {"OpArrayLength", SpvOpArrayLength}, - {"OpTypeAvcImeResultINTEL", SpvOpTypeAvcImeResultINTEL}, - {"OpTypeHitObjectNV", SpvOpTypeHitObjectNV}, - {"OpImageSampleImplicitLod", SpvOpImageSampleImplicitLod}, - {"OpMemoryNamedBarrier", SpvOpMemoryNamedBarrier}, - {"OpReportIntersectionNV", SpvOpReportIntersectionNV}, - {"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL}, - {"OpGroupNonUniformLogicalAnd", SpvOpGroupNonUniformLogicalAnd}, - {"OpArbitraryFloatGEINTEL", SpvOpArbitraryFloatGEINTEL}, - {"OpINotEqual", SpvOpINotEqual}, - {"OpUndef", SpvOpUndef}, - {"OpGroupNonUniformShuffleDown", SpvOpGroupNonUniformShuffleDown}, - {"OpSubgroupAvcMceGetBestInterDistortionsINTEL", SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL}, - {"OpSDotKHR", SpvOpSDotKHR}, - {"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL}, - {"OpArbitraryFloatMulINTEL", SpvOpArbitraryFloatMulINTEL}, - {"OpWritePipe", SpvOpWritePipe}, - {"OpGroupNonUniformSMax", SpvOpGroupNonUniformSMax}, - {"OpAtomicExchange", SpvOpAtomicExchange}, - {"OpSubgroupAvcSicGetInterRawSadsINTEL", SpvOpSubgroupAvcSicGetInterRawSadsINTEL}, - {"OpAliasDomainDeclINTEL", SpvOpAliasDomainDeclINTEL}, - {"OpRayQueryGetIntersectionObjectRayDirectionKHR", SpvOpRayQueryGetIntersectionObjectRayDirectionKHR}, - {"OpConvertImageToUNV", SpvOpConvertImageToUNV}, - {"OpGroupLogicalAndKHR", SpvOpGroupLogicalAndKHR}, - {"OpImageWrite", SpvOpImageWrite}, - {"OpArbitraryFloatAddINTEL", SpvOpArbitraryFloatAddINTEL}, - {"OpHitObjectRecordHitMotionNV", SpvOpHitObjectRecordHitMotionNV}, - {"OpImageSampleProjDrefExplicitLod", SpvOpImageSampleProjDrefExplicitLod}, - {"OpGroupSMin", SpvOpGroupSMin}, - {"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL}, - {"OpRayQueryTerminateKHR", SpvOpRayQueryTerminateKHR}, - {"OpConvertUToSamplerNV", SpvOpConvertUToSamplerNV}, - {"OpConvertFToBF16INTEL", SpvOpConvertFToBF16INTEL}, - {"OpGroupNonUniformBallotFindMSB", SpvOpGroupNonUniformBallotFindMSB}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL}, - {"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL}, - {"OpShiftLeftLogical", SpvOpShiftLeftLogical}, - {"OpIsValidReserveId", SpvOpIsValidReserveId}, - {"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR}, - {"OpArbitraryFloatACosINTEL", SpvOpArbitraryFloatACosINTEL}, - {"OpGroupNonUniformBitwiseOr", SpvOpGroupNonUniformBitwiseOr}, - {"OpGroupNonUniformSMin", SpvOpGroupNonUniformSMin}, - {"OpBitFieldUExtract", SpvOpBitFieldUExtract}, - {"OpGroupNonUniformBallot", SpvOpGroupNonUniformBallot}, - {"OpSubgroupFirstInvocationKHR", SpvOpSubgroupFirstInvocationKHR}, - {"OpLoad", SpvOpLoad}, - {"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL}, - {"OpAtomicCompareExchange", SpvOpAtomicCompareExchange}, - {"OpSubgroupAvcImeGetDualReferenceStreaminINTEL", SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL}, - {"OpHitObjectRecordMissMotionNV", SpvOpHitObjectRecordMissMotionNV}, - {"OpAtomicUMin", SpvOpAtomicUMin}, - {"OpGroupCommitWritePipe", SpvOpGroupCommitWritePipe}, - {"OpFunctionParameter", SpvOpFunctionParameter}, - {"OpSubgroupShuffleXorINTEL", SpvOpSubgroupShuffleXorINTEL}, - {"OpArbitraryFloatLTINTEL", SpvOpArbitraryFloatLTINTEL}, - {"OpTranspose", SpvOpTranspose}, - {"OpSubgroupAvcSicConvertToMceResultINTEL", SpvOpSubgroupAvcSicConvertToMceResultINTEL}, - {"OpTypeCooperativeMatrixKHR", SpvOpTypeCooperativeMatrixKHR}, - {"OpTypeAvcRefResultINTEL", SpvOpTypeAvcRefResultINTEL}, - {"OpArbitraryFloatCosINTEL", SpvOpArbitraryFloatCosINTEL}, - {"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL}, - {"OpIgnoreIntersectionNV", SpvOpIgnoreIntersectionNV}, - {"OpArbitraryFloatCbrtINTEL", SpvOpArbitraryFloatCbrtINTEL}, - {"OpSUDotAccSatKHR", SpvOpSUDotAccSatKHR}, - {"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL}, - {"OpSubgroupAvcSicInitializeINTEL", SpvOpSubgroupAvcSicInitializeINTEL}, - {"OpISub", SpvOpISub}, - {"OpSwitch", SpvOpSwitch}, - {"OpReorderThreadWithHintNV", SpvOpReorderThreadWithHintNV}, - {"OpArbitraryFloatDivINTEL", SpvOpArbitraryFloatDivINTEL}, - {"OpArbitraryFloatEQINTEL", SpvOpArbitraryFloatEQINTEL}, - {"OpFunctionEnd", SpvOpFunctionEnd}, - {"OpSubgroupAvcSicGetMotionVectorMaskINTEL", SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL}, - {"OpKill", SpvOpKill}, - {"OpIsInf", SpvOpIsInf}, - {"OpIAdd", SpvOpIAdd}, - {"OpSubgroupAvcMceConvertToSicResultINTEL", SpvOpSubgroupAvcMceConvertToSicResultINTEL}, - {"OpIgnoreIntersectionKHR", SpvOpIgnoreIntersectionKHR}, - {"OpGetKernelMaxNumSubgroups", SpvOpGetKernelMaxNumSubgroups}, - {"OpModuleProcessed", SpvOpModuleProcessed}, - {"OpTypeArray", SpvOpTypeArray}, - {"OpUDot", SpvOpUDot}, - {"OpArbitraryFloatExp10INTEL", SpvOpArbitraryFloatExp10INTEL}, - {"OpEmitVertex", SpvOpEmitVertex}, - {"OpTypeRuntimeArray", SpvOpTypeRuntimeArray}, - {"OpImageSparseSampleDrefExplicitLod", SpvOpImageSparseSampleDrefExplicitLod}, - {"OpImageQuerySize", SpvOpImageQuerySize}, - {"OpGroupBitwiseAndKHR", SpvOpGroupBitwiseAndKHR}, - {"OpTypeAvcImeSingleReferenceStreaminINTEL", SpvOpTypeAvcImeSingleReferenceStreaminINTEL}, - {"OpHitObjectTraceRayMotionNV", SpvOpHitObjectTraceRayMotionNV}, - {"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL}, - {"OpGroupNonUniformShuffleUp", SpvOpGroupNonUniformShuffleUp}, - {"OpFConvert", SpvOpFConvert}, - {"OpImageTexelPointer", SpvOpImageTexelPointer}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL}, - {"OpGroupNonUniformBitwiseAnd", SpvOpGroupNonUniformBitwiseAnd}, - {"OpArbitraryFloatASinINTEL", SpvOpArbitraryFloatASinINTEL}, - {"OpRayQueryGetIntersectionFrontFaceKHR", SpvOpRayQueryGetIntersectionFrontFaceKHR}, - {"OpImageBlockMatchSSDQCOM", SpvOpImageBlockMatchSSDQCOM}, - {"OpGroupIAddNonUniformAMD", SpvOpGroupIAddNonUniformAMD}, - {"OpCreatePipeFromPipeStorage", SpvOpCreatePipeFromPipeStorage}, - {"OpGroupNonUniformQuadBroadcast", SpvOpGroupNonUniformQuadBroadcast}, - {"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL}, - {"OpGroupAll", SpvOpGroupAll}, - {"OpAtomicSMin", SpvOpAtomicSMin}, - {"OpAll", SpvOpAll}, - {"OpFixedRsqrtINTEL", SpvOpFixedRsqrtINTEL}, - {"OpHitObjectRecordHitNV", SpvOpHitObjectRecordHitNV}, - {"OpRayQueryGetIntersectionWorldToObjectKHR", SpvOpRayQueryGetIntersectionWorldToObjectKHR}, - {"OpSubgroupBlockWriteINTEL", SpvOpSubgroupBlockWriteINTEL}, - {"OpSubgroupAvcBmeInitializeINTEL", SpvOpSubgroupAvcBmeInitializeINTEL}, - {"OpHitObjectGetInstanceIdNV", SpvOpHitObjectGetInstanceIdNV}, - {"OpGetDefaultQueue", SpvOpGetDefaultQueue}, - {"OpCopyLogical", SpvOpCopyLogical}, - {"OpDepthAttachmentReadEXT", SpvOpDepthAttachmentReadEXT}, - {"OpSubgroupAvcSicSetBilinearFilterEnableINTEL", SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL}, - {"OpGroupWaitEvents", SpvOpGroupWaitEvents}, - {"OpIsHelperInvocationEXT", SpvOpIsHelperInvocationEXT}, - {"OpSGreaterThan", SpvOpSGreaterThan}, - {"OpHitObjectGetPrimitiveIndexNV", SpvOpHitObjectGetPrimitiveIndexNV}, - {"OpGetKernelWorkGroupSize", SpvOpGetKernelWorkGroupSize}, - {"OpArbitraryFloatExpm1INTEL", SpvOpArbitraryFloatExpm1INTEL}, - {"OpConstantSampler", SpvOpConstantSampler}, - {"OpArbitraryFloatPowRINTEL", SpvOpArbitraryFloatPowRINTEL}, - {"OpSDiv", SpvOpSDiv}, - {"OpCooperativeMatrixStoreNV", SpvOpCooperativeMatrixStoreNV}, - {"OpImageSparseTexelsResident", SpvOpImageSparseTexelsResident}, - {"OpEntryPoint", SpvOpEntryPoint}, - {"OpUConvert", SpvOpUConvert}, - {"OpArbitraryFloatSubINTEL", SpvOpArbitraryFloatSubINTEL}, - {"OpSubgroupAvcSicGetIpeChromaModeINTEL", SpvOpSubgroupAvcSicGetIpeChromaModeINTEL}, - {"OpSubgroupShuffleINTEL", SpvOpSubgroupShuffleINTEL}, - {"OpShiftRightLogical", SpvOpShiftRightLogical}, - {"OpSubgroupAvcSicConfigureIpeLumaINTEL", SpvOpSubgroupAvcSicConfigureIpeLumaINTEL}, - {"OpBitCount", SpvOpBitCount}, - {"OpTypeAvcImeDualReferenceStreaminINTEL", SpvOpTypeAvcImeDualReferenceStreaminINTEL}, - {"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL}, - {"OpImageSampleDrefImplicitLod", SpvOpImageSampleDrefImplicitLod}, - {"OpSubgroupAvcMceGetMotionVectorsINTEL", SpvOpSubgroupAvcMceGetMotionVectorsINTEL}, - {"OpArbitraryFloatLog10INTEL", SpvOpArbitraryFloatLog10INTEL}, - {"OpMatrixTimesVector", SpvOpMatrixTimesVector}, - {"OpSNegate", SpvOpSNegate}, - {"OpMemberDecorate", SpvOpMemberDecorate}, - {"OpEndPrimitive", SpvOpEndPrimitive}, - {"OpExecuteCallableKHR", SpvOpExecuteCallableKHR}, - {"OpFwidthFine", SpvOpFwidthFine}, - {"OpAbsUSubINTEL", SpvOpAbsUSubINTEL}, - {"OpGetKernelLocalSizeForSubgroupCount", SpvOpGetKernelLocalSizeForSubgroupCount}, - {"OpPtrCastToCrossWorkgroupINTEL", SpvOpPtrCastToCrossWorkgroupINTEL}, - {"OpHitObjectGetRayTMinNV", SpvOpHitObjectGetRayTMinNV}, - {"OpFOrdGreaterThanEqual", SpvOpFOrdGreaterThanEqual}, - {"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL}, - {"OpUAddSatINTEL", SpvOpUAddSatINTEL}, - {"OpAsmINTEL", SpvOpAsmINTEL}, - {"OpGroupNonUniformFMin", SpvOpGroupNonUniformFMin}, - {"OpCooperativeMatrixMulAddKHR", SpvOpCooperativeMatrixMulAddKHR}, - {"OpGroupIAdd", SpvOpGroupIAdd}, - {"OpTypeVector", SpvOpTypeVector}, - {"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL}, - {"OpArbitraryFloatCastFromIntINTEL", SpvOpArbitraryFloatCastFromIntINTEL}, - {"OpHitObjectGetObjectRayDirectionNV", SpvOpHitObjectGetObjectRayDirectionNV}, - {"OpSubgroupAvcMceGetInterDistortionsINTEL", SpvOpSubgroupAvcMceGetInterDistortionsINTEL}, - {"OpBitFieldSExtract", SpvOpBitFieldSExtract}, - {"OpSignBitSet", SpvOpSignBitSet}, - {"OpFunctionPointerCallINTEL", SpvOpFunctionPointerCallINTEL}, - {"OpConvertUToAccelerationStructureKHR", SpvOpConvertUToAccelerationStructureKHR}, - {"OpGenericCastToPtr", SpvOpGenericCastToPtr}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL}, - {"OpAliasScopeDeclINTEL", SpvOpAliasScopeDeclINTEL}, - {"OpFMod", SpvOpFMod}, - {"OpUMod", SpvOpUMod}, - {"OpGroupFMulKHR", SpvOpGroupFMulKHR}, - {"OpSubgroupAvcMceGetInterDirectionsINTEL", SpvOpSubgroupAvcMceGetInterDirectionsINTEL}, - {"OpFragmentFetchAMD", SpvOpFragmentFetchAMD}, - {"OpGroupDecorate", SpvOpGroupDecorate}, - {"OpCrossWorkgroupCastToPtrINTEL", SpvOpCrossWorkgroupCastToPtrINTEL}, - {"OpConstantPipeStorage", SpvOpConstantPipeStorage}, - {"OpGroupNonUniformFMul", SpvOpGroupNonUniformFMul}, - {"OpNot", SpvOpNot}, - {"OpArbitraryFloatLEINTEL", SpvOpArbitraryFloatLEINTEL}, - {"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL}, - {"OpCooperativeMatrixLengthNV", SpvOpCooperativeMatrixLengthNV}, - {"OpTypeImage", SpvOpTypeImage}, - {"OpIAddSatINTEL", SpvOpIAddSatINTEL}, - {"OpArbitraryFloatGTINTEL", SpvOpArbitraryFloatGTINTEL}, - {"OpSMod", SpvOpSMod}, - {"OpEnqueueKernel", SpvOpEnqueueKernel}, - {"OpExtension", SpvOpExtension}, - {"OpHitObjectIsEmptyNV", SpvOpHitObjectIsEmptyNV}, - {"OpSubgroupAvcRefConvertToMceResultINTEL", SpvOpSubgroupAvcRefConvertToMceResultINTEL}, - {"OpHitObjectIsMissNV", SpvOpHitObjectIsMissNV}, - {"OpFMul", SpvOpFMul}, - {"OpStore", SpvOpStore}, - {"OpFunction", SpvOpFunction}, - {"OpSubgroupShuffleDownINTEL", SpvOpSubgroupShuffleDownINTEL}, - {"OpRayQueryGetIntersectionTriangleVertexPositionsKHR", SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR}, - {"OpFixedSinINTEL", SpvOpFixedSinINTEL}, - {"OpTypeVoid", SpvOpTypeVoid}, - {"OpFRem", SpvOpFRem}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL}, - {"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL}, - {"OpQuantizeToF16", SpvOpQuantizeToF16}, - {"OpReadClockKHR", SpvOpReadClockKHR}, - {"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL}, - {"OpImageSparseDrefGather", SpvOpImageSparseDrefGather}, - {"OpSpecConstantOp", SpvOpSpecConstantOp}, - {"OpImageSparseSampleProjExplicitLod", SpvOpImageSparseSampleProjExplicitLod}, - {"OpSubgroupAvcMceConvertToRefPayloadINTEL", SpvOpSubgroupAvcMceConvertToRefPayloadINTEL}, - {"OpEmitStreamVertex", SpvOpEmitStreamVertex}, - {"OpArbitraryFloatCosPiINTEL", SpvOpArbitraryFloatCosPiINTEL}, - {"OpArbitraryFloatExpINTEL", SpvOpArbitraryFloatExpINTEL}, - {"OpGroupBitwiseXorKHR", SpvOpGroupBitwiseXorKHR}, - {"OpArbitraryFloatSinCosINTEL", SpvOpArbitraryFloatSinCosINTEL}, - {"OpSubgroupAvcImeAdjustRefOffsetINTEL", SpvOpSubgroupAvcImeAdjustRefOffsetINTEL}, - {"OpRayQueryInitializeKHR", SpvOpRayQueryInitializeKHR}, - {"OpTerminateInvocation", SpvOpTerminateInvocation}, - {"OpFUnordLessThan", SpvOpFUnordLessThan}, - {"OpMemoryModel", SpvOpMemoryModel}, - {"OpWritePackedPrimitiveIndices4x8NV", SpvOpWritePackedPrimitiveIndices4x8NV}, - {"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL}, - {"OpMemoryBarrier", SpvOpMemoryBarrier}, - {"OpAtomicUMax", SpvOpAtomicUMax}, - {"OpVmeImageINTEL", SpvOpVmeImageINTEL}, - {"OpSubgroupAllKHR", SpvOpSubgroupAllKHR}, - {"OpOuterProduct", SpvOpOuterProduct}, - {"OpArbitraryFloatSinINTEL", SpvOpArbitraryFloatSinINTEL}, - {"OpSpecConstant", SpvOpSpecConstant}, - {"OpGroupUMinNonUniformAMD", SpvOpGroupUMinNonUniformAMD}, - {"OpArbitraryFloatHypotINTEL", SpvOpArbitraryFloatHypotINTEL}, - {"OpVectorTimesScalar", SpvOpVectorTimesScalar}, - {"OpHitObjectGetObjectRayOriginNV", SpvOpHitObjectGetObjectRayOriginNV}, - {"OpLogicalEqual", SpvOpLogicalEqual}, - {"OpSubgroupReadInvocationKHR", SpvOpSubgroupReadInvocationKHR}, - {"OpLabel", SpvOpLabel}, - {"OpImageSparseSampleExplicitLod", SpvOpImageSparseSampleExplicitLod}, - {"OpBuildNDRange", SpvOpBuildNDRange}, - {"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL}, - {"OpGroupNonUniformBroadcast", SpvOpGroupNonUniformBroadcast}, - {"OpCooperativeMatrixLoadKHR", SpvOpCooperativeMatrixLoadKHR}, - {"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL}, - {"OpGroupNonUniformInverseBallot", SpvOpGroupNonUniformInverseBallot}, - {"OpImageQueryFormat", SpvOpImageQueryFormat}, - {"OpRayQueryProceedKHR", SpvOpRayQueryProceedKHR}, - {"OpAtomicIDecrement", SpvOpAtomicIDecrement}, - {"OpCooperativeMatrixLengthKHR", SpvOpCooperativeMatrixLengthKHR}, - {"OpHitObjectGetWorldRayDirectionNV", SpvOpHitObjectGetWorldRayDirectionNV}, - {"OpGroupFMin", SpvOpGroupFMin}, - {"OpAtomicFMaxEXT", SpvOpAtomicFMaxEXT}, - {"OpImageSampleFootprintNV", SpvOpImageSampleFootprintNV}, - {"OpConvertUToPtr", SpvOpConvertUToPtr}, - {"OpGroupNonUniformPartitionNV", SpvOpGroupNonUniformPartitionNV}, - {"OpPtrCastToGeneric", SpvOpPtrCastToGeneric}, - {"OpAtomicFMinEXT", SpvOpAtomicFMinEXT}, - {"OpLifetimeStart", SpvOpLifetimeStart}, - {"OpHitObjectRecordMissNV", SpvOpHitObjectRecordMissNV}, - {"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL}, - {"OpReadPipe", SpvOpReadPipe}, - {"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL}, - {"OpImageSampleProjDrefImplicitLod", SpvOpImageSampleProjDrefImplicitLod}, - {"OpAny", SpvOpAny}, - {"OpIMul32x16INTEL", SpvOpIMul32x16INTEL}, - {"OpImageRead", SpvOpImageRead}, - {"OpEndInvocationInterlockEXT", SpvOpEndInvocationInterlockEXT}, - {"OpUSubSatINTEL", SpvOpUSubSatINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL}, - {"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL}, - {"OpPtrEqual", SpvOpPtrEqual}, - {"OpArbitraryFloatLog2INTEL", SpvOpArbitraryFloatLog2INTEL}, - {"OpSConvert", SpvOpSConvert}, - {"OpSubgroupAvcImeInitializeINTEL", SpvOpSubgroupAvcImeInitializeINTEL}, - {"OpDPdx", SpvOpDPdx}, - {"OpGroupNonUniformUMin", SpvOpGroupNonUniformUMin}, - {"OpUnreachable", SpvOpUnreachable}, - {"OpTypePipeStorage", SpvOpTypePipeStorage}, - {"OpRayQueryConfirmIntersectionKHR", SpvOpRayQueryConfirmIntersectionKHR}, - {"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL}, - {"OpGroupUMin", SpvOpGroupUMin}, - {"OpGroupFMax", SpvOpGroupFMax}, - {"OpLogicalAnd", SpvOpLogicalAnd}, - {"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL}, - {"OpFixedCosINTEL", SpvOpFixedCosINTEL}, - {"OpFUnordGreaterThanEqual", SpvOpFUnordGreaterThanEqual}, - {"OpMemberDecorateString", SpvOpMemberDecorateString}, - {"OpGroupNonUniformIAdd", SpvOpGroupNonUniformIAdd}, - {"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL}, - {"OpLoopMerge", SpvOpLoopMerge}, - {"OpSubgroupAvcMceConvertToSicPayloadINTEL", SpvOpSubgroupAvcMceConvertToSicPayloadINTEL}, - {"OpTypeAvcImePayloadINTEL", SpvOpTypeAvcImePayloadINTEL}, - {"OpImageSampleExplicitLod", SpvOpImageSampleExplicitLod}, - {"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL}, - {"OpReservedWritePipe", SpvOpReservedWritePipe}, - {"OpGroupMemberDecorate", SpvOpGroupMemberDecorate}, - {"OpPtrAccessChain", SpvOpPtrAccessChain}, - {"OpConvertUToF", SpvOpConvertUToF}, - {"OpRayQueryGetIntersectionTKHR", SpvOpRayQueryGetIntersectionTKHR}, - {"OpCooperativeMatrixMulAddNV", SpvOpCooperativeMatrixMulAddNV}, - {"OpTypeAvcMcePayloadINTEL", SpvOpTypeAvcMcePayloadINTEL}, - {"OpCooperativeMatrixLoadNV", SpvOpCooperativeMatrixLoadNV}, - {"OpExecutionModeId", SpvOpExecutionModeId}, - {"OpSRem", SpvOpSRem}, - {"OpImageQueryLevels", SpvOpImageQueryLevels}, - {"OpSubgroupAvcRefConvertToMcePayloadINTEL", SpvOpSubgroupAvcRefConvertToMcePayloadINTEL}, - {"OpGroupReserveWritePipePackets", SpvOpGroupReserveWritePipePackets}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL}, - {"OpSMulExtended", SpvOpSMulExtended}, - {"OpISubSatINTEL", SpvOpISubSatINTEL}, - {"OpDPdyFine", SpvOpDPdyFine}, - {"OpGroupSMinNonUniformAMD", SpvOpGroupSMinNonUniformAMD}, - {"OpGroupNonUniformBallotFindLSB", SpvOpGroupNonUniformBallotFindLSB}, - {"OpImageQuerySamples", SpvOpImageQuerySamples}, - {"OpGroupBroadcast", SpvOpGroupBroadcast}, - {"OpImage", SpvOpImage}, - {"OpTypePipe", SpvOpTypePipe}, - {"OpFixedSinCosINTEL", SpvOpFixedSinCosINTEL}, - {"OpRayQueryGetIntersectionObjectToWorldKHR", SpvOpRayQueryGetIntersectionObjectToWorldKHR}, - {"OpRayQueryGetIntersectionBarycentricsKHR", SpvOpRayQueryGetIntersectionBarycentricsKHR}, - {"OpLogicalOr", SpvOpLogicalOr}, - {"OpNop", SpvOpNop}, - {"OpImageSparseSampleProjDrefExplicitLod", SpvOpImageSparseSampleProjDrefExplicitLod}, - {"OpTypeReserveId", SpvOpTypeReserveId}, - {"OpImageSparseSampleImplicitLod", SpvOpImageSparseSampleImplicitLod}, - {"OpImageSparseSampleProjDrefImplicitLod", SpvOpImageSparseSampleProjDrefImplicitLod}, - {"OpImageSampleProjImplicitLod", SpvOpImageSampleProjImplicitLod}, - {"OpLifetimeStop", SpvOpLifetimeStop}, - {"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL}, - {"OpGetKernelNDrangeSubGroupCount", SpvOpGetKernelNDrangeSubGroupCount}, - {"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL}, - {"OpGroupNonUniformAllEqual", SpvOpGroupNonUniformAllEqual}, - {"OpSGreaterThanEqual", SpvOpSGreaterThanEqual}, - {"OpRayQueryGetIntersectionTypeKHR", SpvOpRayQueryGetIntersectionTypeKHR}, - {"OpDPdxFine", SpvOpDPdxFine}, - {"OpIsFinite", SpvOpIsFinite}, - {"OpName", SpvOpName}, - {"OpHitObjectGetObjectToWorldNV", SpvOpHitObjectGetObjectToWorldNV}, - {"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL}, - {"OpEmitMeshTasksEXT", SpvOpEmitMeshTasksEXT}, - {"OpGroupSMaxNonUniformAMD", SpvOpGroupSMaxNonUniformAMD}, - {"OpUGreaterThanEqual", SpvOpUGreaterThanEqual}, - {"OpUCountLeadingZerosINTEL", SpvOpUCountLeadingZerosINTEL}, - {"OpAccessChain", SpvOpAccessChain}, - {"OpCommitWritePipe", SpvOpCommitWritePipe}, - {"OpFPGARegINTEL", SpvOpFPGARegINTEL}, - {"OpUDotAccSat", SpvOpUDotAccSat}, - {"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL}, - {"OpGroupNonUniformFAdd", SpvOpGroupNonUniformFAdd}, - {"OpGroupNonUniformAny", SpvOpGroupNonUniformAny}, - {"OpHitObjectRecordHitWithIndexNV", SpvOpHitObjectRecordHitWithIndexNV}, - {"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL}, - {"OpGroupNonUniformShuffle", SpvOpGroupNonUniformShuffle}, - {"OpExtInstImport", SpvOpExtInstImport}, - {"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL}, - {"OpGetMaxPipePackets", SpvOpGetMaxPipePackets}, - {"OpSubgroupAvcMceGetInterReferenceIdsINTEL", SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL}, - {"OpTypeAvcSicPayloadINTEL", SpvOpTypeAvcSicPayloadINTEL}, - {"OpAtomicAnd", SpvOpAtomicAnd}, - {"OpGroupUMax", SpvOpGroupUMax}, - {"OpEnqueueMarker", SpvOpEnqueueMarker}, - {"OpRestoreMemoryINTEL", SpvOpRestoreMemoryINTEL}, - {"OpRayQueryGetIntersectionObjectRayOriginKHR", SpvOpRayQueryGetIntersectionObjectRayOriginKHR}, - {"OpFAdd", SpvOpFAdd}, - {"OpDecorationGroup", SpvOpDecorationGroup}, - {"OpSUDotKHR", SpvOpSUDotKHR}, - {"OpGroupUMaxNonUniformAMD", SpvOpGroupUMaxNonUniformAMD}, - {"OpReleaseEvent", SpvOpReleaseEvent}, - {"OpArbitraryFloatLogINTEL", SpvOpArbitraryFloatLogINTEL}, - {"OpUDotAccSatKHR", SpvOpUDotAccSatKHR}, - {"OpBitFieldInsert", SpvOpBitFieldInsert}, - {"OpConvertSamplerToUNV", SpvOpConvertSamplerToUNV}, - {"OpHitObjectRecordHitWithIndexMotionNV", SpvOpHitObjectRecordHitWithIndexMotionNV}, - {"OpGroupNonUniformElect", SpvOpGroupNonUniformElect}, - {"OpRayQueryGetRayFlagsKHR", SpvOpRayQueryGetRayFlagsKHR}, - {"OpAtomicXor", SpvOpAtomicXor}, - {"OpBitwiseOr", SpvOpBitwiseOr}, - {"OpSatConvertUToS", SpvOpSatConvertUToS}, - {"OpArbitraryFloatCastToIntINTEL", SpvOpArbitraryFloatCastToIntINTEL}, - {"OpTypeQueue", SpvOpTypeQueue}, - {"OpDecorateStringGOOGLE", SpvOpDecorateStringGOOGLE}, - {"OpISubBorrow", SpvOpISubBorrow}, - {"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL}, - {"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL}, - {"OpGroupNonUniformBallotBitExtract", SpvOpGroupNonUniformBallotBitExtract}, - {"OpFOrdLessThan", SpvOpFOrdLessThan}, - {"OpFixedLogINTEL", SpvOpFixedLogINTEL}, - {"OpVectorShuffle", SpvOpVectorShuffle}, - {"OpArbitraryFloatRSqrtINTEL", SpvOpArbitraryFloatRSqrtINTEL}, - {"OpHitObjectGetShaderBindingTableRecordIndexNV", SpvOpHitObjectGetShaderBindingTableRecordIndexNV}, - {"OpTypeFunction", SpvOpTypeFunction}, - {"OpReservedReadPipe", SpvOpReservedReadPipe}, - {"OpImageSparseSampleDrefImplicitLod", SpvOpImageSparseSampleDrefImplicitLod}, - {"OpDemoteToHelperInvocation", SpvOpDemoteToHelperInvocation}, - {"OpSpecConstantComposite", SpvOpSpecConstantComposite}, - {"OpFOrdLessThanEqual", SpvOpFOrdLessThanEqual}, - {"OpGroupBitwiseOrKHR", SpvOpGroupBitwiseOrKHR}, - {"OpMemberName", SpvOpMemberName}, - {"OpGroupNonUniformBitwiseXor", SpvOpGroupNonUniformBitwiseXor}, - {"OpGroupFAddNonUniformAMD", SpvOpGroupFAddNonUniformAMD}, - {"OpMatrixTimesMatrix", SpvOpMatrixTimesMatrix}, - {"OpSubgroupAvcRefSetBilinearFilterEnableINTEL", SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL}, - {"OpTypeSampler", SpvOpTypeSampler}, - {"OpGroupLogicalOrKHR", SpvOpGroupLogicalOrKHR}, - {"OpHitObjectGetWorldToObjectNV", SpvOpHitObjectGetWorldToObjectNV}, - {"OpMemberDecorateStringGOOGLE", SpvOpMemberDecorateStringGOOGLE}, - {"OpTypeInt", SpvOpTypeInt}, - {"OpSDotAccSatKHR", SpvOpSDotAccSatKHR}, - {"OpUMulExtended", SpvOpUMulExtended}, - {"OpRayQueryGetIntersectionGeometryIndexKHR", SpvOpRayQueryGetIntersectionGeometryIndexKHR}, - {"OpGroupReserveReadPipePackets", SpvOpGroupReserveReadPipePackets}, - {"OpDemoteToHelperInvocationEXT", SpvOpDemoteToHelperInvocationEXT}, - {"OpTerminateRayKHR", SpvOpTerminateRayKHR}, - {"OpCreateUserEvent", SpvOpCreateUserEvent}, - {"OpFDiv", SpvOpFDiv}, - {"OpSubgroupAvcMceGetInterMotionVectorCountINTEL", SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL}, - {"OpSDot", SpvOpSDot}, - {"OpArbitraryFloatCastINTEL", SpvOpArbitraryFloatCastINTEL}, - {"OpImageBoxFilterQCOM", SpvOpImageBoxFilterQCOM}, - {"OpSubgroupBallotKHR", SpvOpSubgroupBallotKHR}, - {"OpSelectionMerge", SpvOpSelectionMerge}, - {"OpConvertUToSampledImageNV", SpvOpConvertUToSampledImageNV}, - {"OpConvertFToU", SpvOpConvertFToU}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL}, - {"OpRetainEvent", SpvOpRetainEvent}, - {"OpULessThanEqual", SpvOpULessThanEqual}, - {"OpUAverageINTEL", SpvOpUAverageINTEL}, - {"OpSDotAccSat", SpvOpSDotAccSat}, - {"OpShiftRightArithmetic", SpvOpShiftRightArithmetic}, - {"OpArbitraryFloatPowINTEL", SpvOpArbitraryFloatPowINTEL}, - {"OpSubgroupAvcMceSetAcOnlyHaarINTEL", SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL}, - {"OpTraceNV", SpvOpTraceNV}, - {"OpArbitraryFloatSinCosPiINTEL", SpvOpArbitraryFloatSinCosPiINTEL}, - {"OpSubgroupAvcSicGetIpeLumaShapeINTEL", SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL}, - {"OpReadPipeBlockingINTEL", SpvOpReadPipeBlockingINTEL}, - {"OpVariableLengthArrayINTEL", SpvOpVariableLengthArrayINTEL}, - {"OpArbitraryFloatASinPiINTEL", SpvOpArbitraryFloatASinPiINTEL}, - {"OpSubgroupImageBlockReadINTEL", SpvOpSubgroupImageBlockReadINTEL}, - {"OpVectorExtractDynamic", SpvOpVectorExtractDynamic}, - {"OpReserveReadPipePackets", SpvOpReserveReadPipePackets}, - {"OpReserveWritePipePackets", SpvOpReserveWritePipePackets}, - {"OpGroupNonUniformUMax", SpvOpGroupNonUniformUMax}, - {"OpBeginInvocationInterlockEXT", SpvOpBeginInvocationInterlockEXT}, - {"OpLoopControlINTEL", SpvOpLoopControlINTEL}, - {"OpFixedSinCosPiINTEL", SpvOpFixedSinCosPiINTEL}, - {"OpReturnValue", SpvOpReturnValue}, - {"OpHitObjectGetAttributesNV", SpvOpHitObjectGetAttributesNV}, - {"OpExpectKHR", SpvOpExpectKHR}, - {"OpIsNan", SpvOpIsNan}, - {"OpGroupIMulKHR", SpvOpGroupIMulKHR}, - {"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL}, - {"OpPtrNotEqual", SpvOpPtrNotEqual}, - {"OpSpecConstantFalse", SpvOpSpecConstantFalse}, - {"OpFixedExpINTEL", SpvOpFixedExpINTEL}, - {"OpTerminateRayNV", SpvOpTerminateRayNV}, - {"OpUCountTrailingZerosINTEL", SpvOpUCountTrailingZerosINTEL}, - {"OpAsmTargetINTEL", SpvOpAsmTargetINTEL}, - {"OpSaveMemoryINTEL", SpvOpSaveMemoryINTEL}, - {"OpRayQueryGetRayTMinKHR", SpvOpRayQueryGetRayTMinKHR}, - {"OpTypeRayQueryKHR", SpvOpTypeRayQueryKHR}, - {"OpSpecConstantCompositeContinuedINTEL", SpvOpSpecConstantCompositeContinuedINTEL}, - {"OpConvertSToF", SpvOpConvertSToF}, - {"OpCooperativeMatrixStoreKHR", SpvOpCooperativeMatrixStoreKHR}, - {"OpRayQueryGetIntersectionPrimitiveIndexKHR", SpvOpRayQueryGetIntersectionPrimitiveIndexKHR}, - {"OpHitObjectGetCurrentTimeNV", SpvOpHitObjectGetCurrentTimeNV}, - {"OpRayQueryGetWorldRayOriginKHR", SpvOpRayQueryGetWorldRayOriginKHR}, - {"OpHitObjectGetInstanceCustomIndexNV", SpvOpHitObjectGetInstanceCustomIndexNV}, - {"OpSubgroupAnyKHR", SpvOpSubgroupAnyKHR}, - {"OpTypeFloat", SpvOpTypeFloat}, - {"OpIAddCarry", SpvOpIAddCarry}, - {"OpSubgroupAvcImeSetSingleReferenceINTEL", SpvOpSubgroupAvcImeSetSingleReferenceINTEL}, - {"OpAtomicISub", SpvOpAtomicISub}, - {"OpAtomicOr", SpvOpAtomicOr}, - {"OpGroupCommitReadPipe", SpvOpGroupCommitReadPipe}, - {"OpSetMeshOutputsEXT", SpvOpSetMeshOutputsEXT}, - {"OpDPdy", SpvOpDPdy}, - {"OpDPdxCoarse", SpvOpDPdxCoarse}, - {"OpLogicalNotEqual", SpvOpLogicalNotEqual}, - {"OpTypeStruct", SpvOpTypeStruct}, - {"OpIAverageRoundedINTEL", SpvOpIAverageRoundedINTEL}, - {"OpHitObjectExecuteShaderNV", SpvOpHitObjectExecuteShaderNV}, - {"OpTypeCooperativeMatrixNV", SpvOpTypeCooperativeMatrixNV}, - {"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL}, - {"OpTypeDeviceEvent", SpvOpTypeDeviceEvent}, - {"OpSubgroupAvcImeConvertToMceResultINTEL", SpvOpSubgroupAvcImeConvertToMceResultINTEL}, - {"OpFragmentMaskFetchAMD", SpvOpFragmentMaskFetchAMD}, - {"OpSamplerImageAddressingModeNV", SpvOpSamplerImageAddressingModeNV}, - {"OpConvertUToImageNV", SpvOpConvertUToImageNV}, - {"OpConvertFToS", SpvOpConvertFToS}, - {"OpFUnordGreaterThan", SpvOpFUnordGreaterThan}, - {"OpSourceExtension", SpvOpSourceExtension}, - {"OpGroupSMax", SpvOpGroupSMax}, - {"OpFixedSinPiINTEL", SpvOpFixedSinPiINTEL}, - {"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL}, - {"OpGroupNonUniformIMul", SpvOpGroupNonUniformIMul}, - {"OpNoLine", SpvOpNoLine}, - {"OpDPdyCoarse", SpvOpDPdyCoarse}, - {"OpControlBarrierArriveINTEL", SpvOpControlBarrierArriveINTEL}, - {"OpFNegate", SpvOpFNegate}, - {"OpTypeAvcRefPayloadINTEL", SpvOpTypeAvcRefPayloadINTEL}, - {"OpCopyObject", SpvOpCopyObject}, - {"OpTypeAvcMceResultINTEL", SpvOpTypeAvcMceResultINTEL}, - {"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL}, - {"OpSubgroupAvcMceConvertToRefResultINTEL", SpvOpSubgroupAvcMceConvertToRefResultINTEL}, - {"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL}, - {"OpExecuteCallableNV", SpvOpExecuteCallableNV}, - {"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL}, - {"OpControlBarrierWaitINTEL", SpvOpControlBarrierWaitINTEL}, - {"OpHitObjectTraceRayNV", SpvOpHitObjectTraceRayNV}, - {"OpDot", SpvOpDot}, - {"OpUGreaterThan", SpvOpUGreaterThan}, - {"OpArbitraryFloatLog1pINTEL", SpvOpArbitraryFloatLog1pINTEL}, - {"OpVariable", SpvOpVariable}, - {"OpDecorate", SpvOpDecorate}, - {"OpFwidthCoarse", SpvOpFwidthCoarse}, - {"OpGroupNonUniformFMax", SpvOpGroupNonUniformFMax}, - {"OpTypeForwardPointer", SpvOpTypeForwardPointer}, - {"OpBitcast", SpvOpBitcast}, - {"OpPtrDiff", SpvOpPtrDiff}, - {"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL}, - {"OpAtomicFlagClear", SpvOpAtomicFlagClear}, - {"OpTypeAccelerationStructureNV", SpvOpTypeAccelerationStructureNV}, - {"OpLine", SpvOpLine}, - {"OpWritePipeBlockingINTEL", SpvOpWritePipeBlockingINTEL}, - {"OpGroupNonUniformQuadSwap", SpvOpGroupNonUniformQuadSwap}, - {"OpGroupNonUniformLogicalXor", SpvOpGroupNonUniformLogicalXor}, - {"OpGroupFMinNonUniformAMD", SpvOpGroupFMinNonUniformAMD}, - {"OpString", SpvOpString}, - {"OpImageSampleProjExplicitLod", SpvOpImageSampleProjExplicitLod}, - {"OpHitObjectIsHitNV", SpvOpHitObjectIsHitNV}, - {"OpSubgroupAllEqualKHR", SpvOpSubgroupAllEqualKHR}, - {"OpUAverageRoundedINTEL", SpvOpUAverageRoundedINTEL}, - {"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL}, - {"OpAtomicCompareExchangeWeak", SpvOpAtomicCompareExchangeWeak}, - {"OpSubgroupAvcSicEvaluateIpeINTEL", SpvOpSubgroupAvcSicEvaluateIpeINTEL}, - {"OpConvertPtrToU", SpvOpConvertPtrToU}, - {"OpConstantTrue", SpvOpConstantTrue}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL}, - {"OpHitObjectGetWorldRayOriginNV", SpvOpHitObjectGetWorldRayOriginNV}, - {"OpIMul", SpvOpIMul}, - {"OpGroupFMaxNonUniformAMD", SpvOpGroupFMaxNonUniformAMD}, - {"OpGetKernelPreferredWorkGroupSizeMultiple", SpvOpGetKernelPreferredWorkGroupSizeMultiple}, -}; - -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} - -bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value) -{ - const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) - { - value = words[i].value; - return true; - } - else - { - return false; - } -} - -} diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 854485185..1b97414fb 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -3263,11 +3263,10 @@ struct ExprLoweringVisitorBase : ExprVisitor { if(operand.token.type == TokenType::IntegerLiteral) { - const auto v = getIntegerLiteralValue(operand.token); // TODO: we should sign-extend these where appropriate, // difficult because it requires information on usage... return builder->emitSPIRVAsmOperandLiteral( - builder->getIntValue(builder->getUIntType(), v)); + builder->getIntValue(builder->getUIntType(), operand.knownValue)); } else if(operand.token.type == TokenType::StringLiteral) { @@ -3283,11 +3282,18 @@ struct ExprLoweringVisitorBase : ExprVisitor return builder->emitSPIRVAsmOperandId( builder->getStringValue(id)); } + case SPIRVAsmOperand::ResultMarker: + { + return builder->emitSPIRVAsmOperandResult(); + } case SPIRVAsmOperand::NamedValue: { - const auto id = operand.token.getContent(); - return builder->emitSPIRVAsmOperandEnum( - builder->getStringValue(id)); + const auto v = operand.knownValue; + const auto i = builder->getIntValue(builder->getIntType(), v); + if(operand.wrapInId) + return builder->emitSPIRVAsmOperandEnum(i, builder->getIntType()); + else + return builder->emitSPIRVAsmOperandEnum(i); } case SPIRVAsmOperand::SlangValue: { diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index 5d3f7e015..545f222de 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -102,6 +102,7 @@ enum class OptionKind EmitSpirvViaGLSL, EmitSpirvDirectly, + SPIRVCoreGrammarJSON, // Downstream @@ -518,6 +519,8 @@ void initCommandOptions(CommandOptions& options) "Generate SPIR-V output by compiling generated GLSL with glslang (default)" }, { OptionKind::EmitSpirvDirectly, "-emit-spirv-directly", nullptr, "Generate SPIR-V output direclty rather than by compiling generated GLSL with glslang" }, + { OptionKind::SPIRVCoreGrammarJSON, "-spirv-core-grammar", nullptr, + "A path to a specific spirv.core.grammar.json to use when generating SPIR-V output" }, #endif }; @@ -889,6 +892,8 @@ struct OptionsParser slang::CompileStdLibFlags m_compileStdLibFlags = 0; bool m_hasLoadedRepro = false; + String m_spirvCoreGrammarJSONPath; + CommandLineReader m_reader; CommandOptionsWriter::Style m_helpStyle = CommandOptionsWriter::Style::Text; @@ -2300,6 +2305,13 @@ SlangResult OptionsParser::_parse( getCurrentTarget()->targetFlags |= SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY; } break; + case OptionKind::SPIRVCoreGrammarJSON: + { + CommandLineArg path; + SLANG_RETURN_ON_FAIL(m_reader.expectArg(path)); + m_spirvCoreGrammarJSONPath = path.value; + } + break; case OptionKind::DefaultDownstreamCompiler: { @@ -2843,6 +2855,11 @@ SlangResult OptionsParser::_parse( m_compileRequest->setMatrixLayoutMode(m_defaultMatrixLayoutMode); } + if(m_spirvCoreGrammarJSONPath.getLength()) + { + m_session->setSPIRVCoreGrammar(m_spirvCoreGrammarJSONPath.getBuffer()); + } + // Next we need to sort out the output files specified with `-o`, and // figure out which entry point and/or target they apply to. // diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 442ddbce6..580215fc7 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -6160,14 +6160,27 @@ namespace Slang return SPIRVAsmOperand{flavor, tok, varExpr}; }; + // The result marker + if(parser->LookAheadToken("result")) + { + return SPIRVAsmOperand{SPIRVAsmOperand::ResultMarker, parser->ReadToken()}; + } // A regular identifier - if(parser->LookAheadToken(TokenType::Identifier)) + else if(parser->LookAheadToken(TokenType::Identifier)) { return SPIRVAsmOperand{SPIRVAsmOperand::NamedValue, parser->ReadToken()}; } - // A literal integer or string - else if(parser->LookAheadToken(TokenType::IntegerLiteral) - || parser->LookAheadToken(TokenType::StringLiteral)) + // A literal integer + else if(parser->LookAheadToken(TokenType::IntegerLiteral)) + { + const auto tok = parser->ReadToken(); + const auto v = getIntegerLiteralValue(tok); + if(v < 0 || v > 0xffffffff) + parser->diagnose(tok, Diagnostics::spirvOperandRange); + return SPIRVAsmOperand{SPIRVAsmOperand::Literal, tok, nullptr, {}, SpvWord(v)}; + } + // A literal string + else if(parser->LookAheadToken(TokenType::StringLiteral)) { return SPIRVAsmOperand{SPIRVAsmOperand::Literal, parser->ReadToken()}; } @@ -6202,37 +6215,120 @@ namespace Slang static std::optional parseSPIRVAsmInst(Parser* parser) { + const auto& spirvInfo = parser->astBuilder->getGlobalSession()->spirvCoreGrammarInfo; + SPIRVAsmInst ret; + // We don't yet know if this is "OpFoo a b c" or "a = OpFoo b c" const auto resultOrOpcode = parseSPIRVAsmOperand(parser); if(!resultOrOpcode) return std::nullopt; - // We can enable this when we have a way of determining the index of - // the result id operand to each instruction, otherwise we don't know - // at which position in the operand list to insert this. -#if 0 - if(AdvanceIf(parser, TokenType::OpEql)) + // If this is the latter, "assignment", syntax then we'll fill these in + std::optional resultTypeOperand; + std::optional resultOperand; + + // If we see a colon, then this `%foo : %type = OpFoo`? + if(AdvanceIf(parser, TokenType::Colon)) + { + resultTypeOperand = parseSPIRVAsmOperand(parser); + if(!resultTypeOperand) + return std::nullopt; + parser->ReadToken(TokenType::OpAssign); + } + + // If we have seen a type, then insist on this syntax, otherwise allow + // skipping this if + if(resultTypeOperand || AdvanceIf(parser, TokenType::OpAssign)) { const auto opcode = parseSPIRVAsmOperand(parser); if(!opcode) return std::nullopt; ret.opcode = *opcode; - ret.operands.insert(???, *resultOrOpcode); + resultOperand = *resultOrOpcode; } else -#endif { ret.opcode = *resultOrOpcode; } - // TODO: diagnose wrong opcode flavor here + const auto& opcodeWord = spirvInfo->opcodes.lookup(ret.opcode.token.getContent()); + const auto& opInfo = opcodeWord + ? spirvInfo->opInfos.lookup(*opcodeWord) + : std::nullopt; + ret.opcode.knownValue = opcodeWord.value_or(SpvOp(0xffffffff)); + + // If we couldn't find any info, but used this assignment syntax, raise + // an error + if(!opInfo && resultOperand) + { + parser->diagnose( + resultOperand->token, + Diagnostics::unrecognizedSPIRVOpcode, + ret.opcode.token + ); + return std::nullopt; + } + + // If we have an explicit result operand (because this was a `x = + // OpFoo` instruction) then diagnose if we don't know where to put it + if(resultOperand && opInfo && opInfo->resultIdIndex == -1) + { + parser->diagnose( + resultOperand->token, + Diagnostics::spirvInstructionWithoutResultId, + ret.opcode.token + ); + return std::nullopt; + } + + // Likewise for the type + if(resultTypeOperand && opInfo && opInfo->resultTypeIndex == -1) + { + parser->diagnose( + resultTypeOperand->token, + Diagnostics::spirvInstructionWithoutResultTypeId, + ret.opcode.token + ); + return std::nullopt; + } + // + // Now we've parsed the tricky preamble, grab the rest of the operands + // At this point we can also parse bitwise or expressions + // while(!(parser->LookAheadToken(TokenType::RBrace) || parser->LookAheadToken(TokenType::Semicolon))) { - if(const auto operand = parseSPIRVAsmOperand(parser)) + if(ret.operands.getCount() == opInfo->maxOperandCount) + { + parser->diagnose( + parser->tokenReader.peekLoc(), + Diagnostics::spirvInstructionWithTooManyOperands, + ret.opcode.token, + opInfo->maxOperandCount + ); + } + + // Insert the LHS result-type operand + if(ret.operands.getCount() == opInfo->resultTypeIndex && resultTypeOperand) + ret.operands.add(*resultTypeOperand); + + // Insert the LHS result operand + if(ret.operands.getCount() == opInfo->resultIdIndex && resultOperand) + ret.operands.add(*resultOperand); + + if(auto operand = parseSPIRVAsmOperand(parser)) + { + while(AdvanceIf(parser, TokenType::OpBitOr)) + { + if(const auto next = parseSPIRVAsmOperand(parser)) + operand->bitwiseOrWith.add(*next); + else + return std::nullopt; + } ret.operands.add(*operand); + } else return std::nullopt; } @@ -6245,6 +6341,7 @@ namespace Slang SPIRVAsmExpr* asmExpr = parser->astBuilder->create(); parser->ReadToken(TokenType::LBrace); + bool failed = false; while(!parser->tokenReader.isAtEnd()) { if(parser->LookAheadToken(TokenType::RBrace)) @@ -6252,14 +6349,21 @@ namespace Slang if(const auto inst = parseSPIRVAsmInst(parser)) asmExpr->insts.add(*inst); else - return nullptr; + { + failed = true; + // Recover to the semi or brace + while(!(parser->LookAheadToken(TokenType::Semicolon) + || parser->LookAheadToken(TokenType::RBrace) + || parser->LookAheadToken(TokenType::EndOfFile))) + parser->ReadToken(); + } if(parser->LookAheadToken(TokenType::RBrace)) break; parser->ReadToken(TokenType::Semicolon); } - parser->ReadToken(TokenType::RBrace); + parser->ReadMatchingToken(TokenType::RBrace); - return asmExpr; + return failed ? nullptr : asmExpr; } static Expr* parsePrefixExpr(Parser* parser) @@ -6655,10 +6759,15 @@ namespace Slang Token token; token = parser->ReadToken(); auto modifier = parser->astBuilder->create(); - SpvCapability cap; - if (!lookupSpvCapability(token.getContent(), cap)) + const SPIRVCoreGrammarInfo& spirvInfo = + parser->astBuilder->getGlobalSession()->getSPIRVCoreGrammarInfo(); + const auto cap = spirvInfo.capabilities.lookup(token.getContent()); + if (!cap) + { parser->sink->diagnose(token, Diagnostics::unknownSPIRVCapability, token); - modifier->capability = (int32_t)cap; + return nullptr; + } + modifier->capability = int32_t(*cap); return modifier; } diff --git a/source/slang/slang-spirv-core-grammar-embed.cpp b/source/slang/slang-spirv-core-grammar-embed.cpp new file mode 100644 index 000000000..ee409dad0 --- /dev/null +++ b/source/slang/slang-spirv-core-grammar-embed.cpp @@ -0,0 +1,12451 @@ +// Source embedding for SPIR-V core grammar +// +// This file was carefully generated by a machine, +// don't even think about modifying it yourself! +// + +#include "../core/slang-smart-pointer.h" +#include "../compiler-core/slang-spirv-core-grammar.h" +namespace Slang +{ +using OperandKind = SPIRVCoreGrammarInfo::OperandKind; +using QualifiedEnumName = SPIRVCoreGrammarInfo::QualifiedEnumName; +using QualifiedEnumValue = SPIRVCoreGrammarInfo::QualifiedEnumValue; +static bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value) +{ + static const unsigned tableSalt[718] = { + 0, 8, 0, 1, 0, 2, 0, 0, 1, 0, 1, 0, 0, 0, 2, 1, + 1, 0, 0, 4, 1, 2, 1, 0, 3, 3, 0, 1, 1, 0, 4, 10, + 4, 2, 0, 0, 2, 0, 2, 9, 1, 3, 0, 5, 0, 0, 0, 0, + 2, 0, 3, 0, 0, 1, 3, 0, 5, 1, 0, 1, 0, 5, 1, 0, + 1, 0, 4, 2, 0, 2, 0, 3, 0, 2, 2, 2, 0, 0, 0, 0, + 5, 0, 0, 8, 2, 8, 1, 2, 0, 2, 0, 6, 0, 3, 0, 2, + 0, 1, 0, 0, 7, 0, 0, 0, 1, 4, 1, 0, 1, 1, 1, 0, + 1, 2, 2, 1, 0, 4, 3, 1, 0, 0, 3, 3, 1, 1, 1, 3, + 1, 1, 0, 1, 1, 1, 0, 2, 0, 2, 0, 0, 2, 3, 4, 5, + 4, 0, 1, 0, 5, 0, 0, 7, 10, 7, 0, 1, 3, 1, 1, 1, + 0, 0, 0, 1, 3, 0, 0, 4, 0, 0, 5, 7, 0, 5, 0, 0, + 1, 1, 0, 0, 0, 1, 5, 11, 2, 2, 0, 1, 1, 2, 0, 0, + 5, 3, 3, 1, 2, 2, 1, 4, 2, 0, 2, 7, 6, 0, 3, 0, + 3, 3, 0, 4, 3, 3, 6, 1, 6, 0, 0, 0, 6, 2, 1, 1, + 6, 0, 2, 0, 2, 2, 4, 2, 11, 0, 2, 0, 6, 2, 0, 15, + 5, 4, 0, 7, 10, 1, 5, 1, 3, 0, 0, 1, 0, 5, 1, 2, + 5, 3, 0, 12, 1, 0, 1, 0, 1, 1, 0, 1, 4, 2, 4, 4, + 1, 0, 0, 0, 0, 1, 1, 0, 1, 7, 0, 0, 1, 2, 11, 0, + 8, 1, 7, 1, 4, 5, 3, 5, 2, 9, 0, 4, 0, 7, 0, 4, + 4, 1, 1, 1, 0, 4, 1, 8, 0, 0, 0, 0, 3, 5, 0, 0, + 1, 0, 1, 7, 4, 5, 8, 4, 0, 0, 0, 0, 2, 1, 0, 5, + 0, 2, 2, 8, 5, 0, 0, 7, 0, 1, 12, 0, 0, 1, 0, 4, + 0, 5, 0, 0, 0, 11, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, + 0, 0, 25, 9, 3, 9, 0, 24, 0, 1, 2, 2, 0, 2, 0, 0, + 21, 4, 0, 0, 1, 4, 0, 3, 0, 1, 1, 1, 13, 0, 0, 0, + 0, 0, 0, 1, 4, 1, 0, 0, 5, 8, 0, 0, 1, 0, 6, 4, + 0, 1, 0, 0, 0, 1, 6, 3, 6, 9, 5, 0, 3, 5, 12, 4, + 0, 34, 7, 1, 2, 2, 3, 0, 1, 13, 3, 0, 3, 5, 1, 1, + 1, 7, 0, 0, 0, 0, 6, 6, 6, 0, 0, 5, 0, 0, 9, 0, + 0, 5, 0, 0, 2, 9, 0, 0, 0, 27, 0, 32, 8, 0, 5, 9, + 7, 0, 0, 28, 0, 0, 13, 1, 7, 0, 3, 0, 0, 2, 4, 0, + 31, 0, 0, 2, 0, 1, 14, 0, 7, 3, 0, 0, 2, 10, 1, 1, + 4, 0, 18, 0, 2, 0, 0, 0, 22, 0, 18, 13, 0, 0, 1, 0, + 0, 6, 21, 17, 7, 0, 17, 5, 0, 70, 0, 0, 1, 27, 3, 14, + 0, 0, 39, 9, 3, 2, 11, 17, 0, 2, 0, 21, 5, 1, 0, 3, + 0, 2, 10, 5, 0, 2, 11, 0, 0, 2, 0, 15, 6, 0, 0, 1, + 0, 5, 12, 11, 0, 8, 9, 2, 4, 0, 7, 0, 12, 0, 5, 21, + 3, 0, 1, 0, 8, 0, 0, 1, 13, 0, 7, 12, 0, 0, 6, 1, + 2, 0, 0, 36, 6, 0, 21, 0, 0, 3, 0, 3, 2, 0, 12, 0, + 0, 25, 11, 1, 2, 0, 10, 0, 0, 0, 0, 3, 0, 40, 0, 2, + 58, 2, 17, 39, 13, 2, 1, 0, 7, 0, 5, 22, 42, 36, 23, 0, + 0, 50, 19, 0, 5, 0, 15, 3, 17, 0, 0, 9, 32, 23, 21, 0, + 4, 1, 1, 0, 2, 11, 0, 0, 0, 14, 9, 0, 0, 35, 0, 75, + 0, 4, 26, 0, 0, 232, 15, 83, 8, 401, 14, 2, 0, 0, 1, 0, + 0, 16, 43, 7, 0, 3, 11, 246, 112, 40, 44, 676, 104, 4 + }; + + using KV = std::pair; + + static const KV words[718] = + { + {"OpIsValidEvent", static_cast(300)}, + {"OpTypeBufferSurfaceINTEL", static_cast(6086)}, + {"OpReservedWritePipe", static_cast(277)}, + {"OpFUnordGreaterThan", static_cast(187)}, + {"OpMemoryBarrier", static_cast(225)}, + {"OpTraceRayKHR", static_cast(4445)}, + {"OpIsFinite", static_cast(158)}, + {"OpReorderThreadWithHitObjectNV", static_cast(5279)}, + {"OpLifetimeStop", static_cast(257)}, + {"OpImage", static_cast(100)}, + {"OpSubgroupAvcImeConvertToMcePayloadINTEL", static_cast(5752)}, + {"OpImageQuerySizeLod", static_cast(103)}, + {"OpNamedBarrierInitialize", static_cast(328)}, + {"OpRayQueryGenerateIntersectionKHR", static_cast(4475)}, + {"OpGroupUMax", static_cast(270)}, + {"OpHitObjectRecordMissNV", static_cast(5263)}, + {"OpFOrdEqual", static_cast(180)}, + {"OpSUDot", static_cast(4452)}, + {"OpConvertSamplerToUNV", static_cast(5394)}, + {"OpImageSparseSampleProjImplicitLod", static_cast(309)}, + {"OpGroupNonUniformLogicalOr", static_cast(363)}, + {"OpArbitraryFloatSinCosINTEL", static_cast(5870)}, + {"OpImageFetch", static_cast(95)}, + {"OpSpecConstantCompositeContinuedINTEL", static_cast(6092)}, + {"OpSubgroupAvcImeRefWindowSizeINTEL", static_cast(5750)}, + {"OpGroupNonUniformBroadcastFirst", static_cast(338)}, + {"OpImageSampleProjImplicitLod", static_cast(91)}, + {"OpBitCount", static_cast(205)}, + {"OpSubgroupAvcMceGetInterMotionVectorCountINTEL", static_cast(5744)}, + {"OpAsmCallINTEL", static_cast(5611)}, + {"OpImageSparseSampleProjExplicitLod", static_cast(310)}, + {"OpFUnordNotEqual", static_cast(183)}, + {"OpGroupBitwiseAndKHR", static_cast(6403)}, + {"OpSpecConstantComposite", static_cast(51)}, + {"OpTypeCooperativeMatrixKHR", static_cast(4456)}, + {"OpGroupNonUniformRotateKHR", static_cast(4431)}, + {"OpFixedSqrtINTEL", static_cast(5923)}, + {"OpTerminateInvocation", static_cast(4416)}, + {"OpBitwiseOr", static_cast(197)}, + {"OpDecorationGroup", static_cast(73)}, + {"OpSpecConstantFalse", static_cast(49)}, + {"OpAccessChain", static_cast(65)}, + {"OpLoopMerge", static_cast(246)}, + {"OpImageSampleWeightedQCOM", static_cast(4480)}, + {"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", static_cast(5714)}, + {"OpSDotAccSat", static_cast(4453)}, + {"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", static_cast(5755)}, + {"OpSubgroupAvcMceGetBestInterDistortionsINTEL", static_cast(5740)}, + {"OpMemberDecorateStringGOOGLE", static_cast(5633)}, + {"OpUAverageINTEL", static_cast(5592)}, + {"OpVectorTimesMatrix", static_cast(144)}, + {"OpShiftRightLogical", static_cast(194)}, + {"OpAssumeTrueKHR", static_cast(5630)}, + {"OpGroupCommitWritePipe", static_cast(288)}, + {"OpGroupAsyncCopy", static_cast(259)}, + {"OpHitObjectTraceRayNV", static_cast(5260)}, + {"OpAliasDomainDeclINTEL", static_cast(5911)}, + {"OpUSubSatINTEL", static_cast(5596)}, + {"OpHitObjectGetWorldToObjectNV", static_cast(5252)}, + {"OpArbitraryFloatSinCosPiINTEL", static_cast(5840)}, + {"OpArbitraryFloatPowRINTEL", static_cast(5881)}, + {"OpSubgroupAvcMceGetMotionVectorsINTEL", static_cast(5738)}, + {"OpFwidth", static_cast(209)}, + {"OpLogicalNot", static_cast(168)}, + {"OpGenericPtrMemSemantics", static_cast(69)}, + {"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", static_cast(5715)}, + {"OpImageSparseSampleExplicitLod", static_cast(306)}, + {"OpArbitraryFloatExpINTEL", static_cast(5864)}, + {"OpPhi", static_cast(245)}, + {"OpUConvert", static_cast(113)}, + {"OpConstantCompositeContinuedINTEL", static_cast(6091)}, + {"OpUDotKHR", static_cast(4451)}, + {"OpGetDefaultQueue", static_cast(303)}, + {"OpFOrdGreaterThan", static_cast(186)}, + {"OpSUDotAccSat", static_cast(4455)}, + {"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", static_cast(5719)}, + {"OpTypeAvcMceResultINTEL", static_cast(5705)}, + {"OpImageQueryLod", static_cast(105)}, + {"OpControlBarrierWaitINTEL", static_cast(6143)}, + {"OpMemberDecorateString", static_cast(5633)}, + {"OpFUnordEqual", static_cast(181)}, + {"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", static_cast(6021)}, + {"OpTypeAvcImeResultINTEL", static_cast(5706)}, + {"OpSDiv", static_cast(135)}, + {"OpSubgroupAvcMceGetInterDirectionsINTEL", static_cast(5743)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", static_cast(5764)}, + {"OpDecorateStringGOOGLE", static_cast(5632)}, + {"OpEndStreamPrimitive", static_cast(221)}, + {"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", static_cast(5724)}, + {"OpHitObjectRecordMissMotionNV", static_cast(5251)}, + {"OpConvertUToSamplerNV", static_cast(5392)}, + {"OpGroupNonUniformSMin", static_cast(353)}, + {"OpTypePipeStorage", static_cast(322)}, + {"OpDecorate", static_cast(71)}, + {"OpArbitraryFloatDivINTEL", static_cast(5849)}, + {"OpCooperativeMatrixLoadKHR", static_cast(4457)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", static_cast(5772)}, + {"OpImageQueryOrder", static_cast(102)}, + {"OpArbitraryFloatExp2INTEL", static_cast(5865)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", static_cast(5774)}, + {"OpINotEqual", static_cast(171)}, + {"OpGroupFMin", static_cast(266)}, + {"OpDot", static_cast(148)}, + {"OpArbitraryFloatLEINTEL", static_cast(5853)}, + {"OpGroupNonUniformFMin", static_cast(355)}, + {"OpFixedCosINTEL", static_cast(5927)}, + {"OpDPdx", static_cast(207)}, + {"OpDPdy", static_cast(208)}, + {"OpVectorShuffle", static_cast(79)}, + {"OpSubgroupBlockWriteINTEL", static_cast(5576)}, + {"OpFunction", static_cast(54)}, + {"OpCommitWritePipe", static_cast(281)}, + {"OpImageBlockMatchSADQCOM", static_cast(4483)}, + {"OpImageQuerySize", static_cast(104)}, + {"OpImageTexelPointer", static_cast(60)}, + {"OpBranchConditional", static_cast(250)}, + {"OpEmitVertex", static_cast(218)}, + {"OpAtomicFlagTestAndSet", static_cast(318)}, + {"OpTypeAccelerationStructureNV", static_cast(5341)}, + {"OpGenericCastToPtr", static_cast(122)}, + {"OpSubgroupAvcRefConvertToMcePayloadINTEL", static_cast(5783)}, + {"OpBitReverse", static_cast(204)}, + {"OpSLessThan", static_cast(177)}, + {"OpGroupNonUniformElect", static_cast(333)}, + {"OpHitObjectGetGeometryIndexNV", static_cast(5269)}, + {"OpGroupNonUniformFMax", static_cast(358)}, + {"OpTypeEvent", static_cast(34)}, + {"OpSubgroupAvcSicConfigureSkcINTEL", static_cast(5792)}, + {"OpMatrixTimesScalar", static_cast(143)}, + {"OpISub", static_cast(130)}, + {"OpAtomicUMin", static_cast(237)}, + {"OpBitFieldSExtract", static_cast(202)}, + {"OpGroupFMulKHR", static_cast(6402)}, + {"OpGroupIAdd", static_cast(264)}, + {"OpAtomicStore", static_cast(228)}, + {"OpIMul", static_cast(132)}, + {"OpDPdyCoarse", static_cast(214)}, + {"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", static_cast(5787)}, + {"OpGroupNonUniformBitwiseOr", static_cast(360)}, + {"OpEmitMeshTasksEXT", static_cast(5294)}, + {"OpConvertUToImageNV", static_cast(5391)}, + {"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", static_cast(5725)}, + {"OpQuantizeToF16", static_cast(116)}, + {"OpSUDotKHR", static_cast(4452)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", static_cast(5775)}, + {"OpSubgroupFirstInvocationKHR", static_cast(4422)}, + {"OpSGreaterThanEqual", static_cast(175)}, + {"OpString", static_cast(7)}, + {"OpUDiv", static_cast(134)}, + {"OpGetKernelNDrangeMaxSubGroupSize", static_cast(294)}, + {"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", static_cast(5746)}, + {"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", static_cast(5784)}, + {"OpRayQueryTerminateKHR", static_cast(4474)}, + {"OpSConvert", static_cast(114)}, + {"OpArbitraryFloatATanINTEL", static_cast(5877)}, + {"OpReturnValue", static_cast(254)}, + {"OpSLessThanEqual", static_cast(179)}, + {"OpSNegate", static_cast(126)}, + {"OpTypeStruct", static_cast(30)}, + {"OpPtrDiff", static_cast(403)}, + {"OpFixedCosPiINTEL", static_cast(5930)}, + {"OpReportIntersectionKHR", static_cast(5334)}, + {"OpCopyLogical", static_cast(400)}, + {"OpLogicalOr", static_cast(166)}, + {"OpSubgroupAvcRefSetBilinearFilterEnableINTEL", static_cast(5785)}, + {"OpEntryPoint", static_cast(15)}, + {"OpRayQueryGetIntersectionFrontFaceKHR", static_cast(6025)}, + {"OpHitObjectGetObjectRayOriginNV", static_cast(5255)}, + {"OpLessOrGreater", static_cast(161)}, + {"OpBuildNDRange", static_cast(304)}, + {"OpSMulExtended", static_cast(152)}, + {"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", static_cast(5794)}, + {"OpReserveReadPipePackets", static_cast(278)}, + {"OpExtInst", static_cast(12)}, + {"OpArbitraryFloatPowINTEL", static_cast(5880)}, + {"OpSubgroupReadInvocationKHR", static_cast(4432)}, + {"OpGroupFAddNonUniformAMD", static_cast(5001)}, + {"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", static_cast(5726)}, + {"OpHitObjectGetHitKindNV", static_cast(5267)}, + {"OpSubgroupAvcImeGetDualReferenceStreaminINTEL", static_cast(5767)}, + {"OpShiftRightArithmetic", static_cast(195)}, + {"OpSUDotAccSatKHR", static_cast(4455)}, + {"OpArbitraryFloatPowNINTEL", static_cast(5882)}, + {"OpDecorateString", static_cast(5632)}, + {"OpReservedReadPipe", static_cast(276)}, + {"OpBitcast", static_cast(124)}, + {"OpSubgroupImageBlockWriteINTEL", static_cast(5578)}, + {"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", static_cast(5802)}, + {"OpSubgroupShuffleUpINTEL", static_cast(5573)}, + {"OpArrayLength", static_cast(68)}, + {"OpRayQueryProceedKHR", static_cast(4477)}, + {"OpAbsUSubINTEL", static_cast(5588)}, + {"OpGroupNonUniformBallotBitCount", static_cast(342)}, + {"OpFunctionPointerCallINTEL", static_cast(5601)}, + {"OpArbitraryFloatHypotINTEL", static_cast(5858)}, + {"OpGetKernelNDrangeSubGroupCount", static_cast(293)}, + {"OpFunctionParameter", static_cast(55)}, + {"OpFwidthCoarse", static_cast(215)}, + {"OpUDotAccSatKHR", static_cast(4454)}, + {"OpFOrdLessThanEqual", static_cast(188)}, + {"OpAtomicISub", static_cast(235)}, + {"OpHitObjectGetWorldRayDirectionNV", static_cast(5272)}, + {"OpNoLine", static_cast(317)}, + {"OpConvertFToBF16INTEL", static_cast(6116)}, + {"OpFMul", static_cast(133)}, + {"OpLogicalEqual", static_cast(164)}, + {"OpExecutionModeId", static_cast(331)}, + {"OpArbitraryFloatLog10INTEL", static_cast(5862)}, + {"OpIAdd", static_cast(128)}, + {"OpColorAttachmentReadEXT", static_cast(4160)}, + {"OpGroupFMaxNonUniformAMD", static_cast(5005)}, + {"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", static_cast(5729)}, + {"OpReorderThreadWithHintNV", static_cast(5280)}, + {"OpULessThan", static_cast(176)}, + {"OpSubgroupAvcMceGetInterMajorShapeINTEL", static_cast(5741)}, + {"OpLine", static_cast(8)}, + {"OpArbitraryFloatLTINTEL", static_cast(5852)}, + {"OpAtomicIDecrement", static_cast(233)}, + {"OpArbitraryFloatSqrtINTEL", static_cast(5859)}, + {"OpPtrNotEqual", static_cast(402)}, + {"OpHitObjectRecordHitMotionNV", static_cast(5249)}, + {"OpStore", static_cast(62)}, + {"OpArbitraryFloatATan2INTEL", static_cast(5879)}, + {"OpGroupNonUniformQuadBroadcast", static_cast(365)}, + {"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", static_cast(5730)}, + {"OpUMulExtended", static_cast(151)}, + {"OpGroupFAdd", static_cast(265)}, + {"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", static_cast(5727)}, + {"OpCopyObject", static_cast(83)}, + {"OpVectorExtractDynamic", static_cast(77)}, + {"OpEnqueueKernel", static_cast(292)}, + {"OpTypeQueue", static_cast(37)}, + {"OpSubgroupAvcImeSetWeightedSadINTEL", static_cast(5756)}, + {"OpTypeAvcMcePayloadINTEL", static_cast(5704)}, + {"OpRayQueryInitializeKHR", static_cast(4473)}, + {"OpArbitraryFloatGEINTEL", static_cast(5851)}, + {"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", static_cast(5814)}, + {"OpFSub", static_cast(131)}, + {"OpHitObjectRecordHitWithIndexNV", static_cast(5262)}, + {"OpSpecConstantOp", static_cast(52)}, + {"OpGroupNonUniformFMul", static_cast(352)}, + {"OpHitObjectGetInstanceIdNV", static_cast(5270)}, + {"OpSubgroupAvcMceConvertToRefPayloadINTEL", static_cast(5734)}, + {"OpFunctionEnd", static_cast(56)}, + {"OpGroupFMinNonUniformAMD", static_cast(5002)}, + {"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", static_cast(5815)}, + {"OpArbitraryFloatCbrtINTEL", static_cast(5857)}, + {"OpImageBlockMatchSSDQCOM", static_cast(4482)}, + {"OpEndPrimitive", static_cast(219)}, + {"OpIsHelperInvocationEXT", static_cast(5381)}, + {"OpImageWrite", static_cast(99)}, + {"OpGetNumPipePackets", static_cast(283)}, + {"OpConstant", static_cast(43)}, + {"OpGenericCastToPtrExplicit", static_cast(123)}, + {"OpSubgroupAvcMceGetInterDistortionsINTEL", static_cast(5739)}, + {"OpCooperativeMatrixStoreNV", static_cast(5360)}, + {"OpGroupDecorate", static_cast(74)}, + {"OpAbsISubINTEL", static_cast(5587)}, + {"OpVariable", static_cast(59)}, + {"OpDPdxCoarse", static_cast(213)}, + {"OpSDotAccSatKHR", static_cast(4453)}, + {"OpDemoteToHelperInvocation", static_cast(5380)}, + {"OpHitObjectRecordHitNV", static_cast(5261)}, + {"OpSubgroupAvcSicConvertToMcePayloadINTEL", static_cast(5796)}, + {"OpRayQueryGetIntersectionPrimitiveIndexKHR", static_cast(6023)}, + {"OpTypeArray", static_cast(28)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", static_cast(5761)}, + {"OpRayQueryGetIntersectionInstanceIdKHR", static_cast(6020)}, + {"OpCrossWorkgroupCastToPtrINTEL", static_cast(5938)}, + {"OpTypeAvcImeResultSingleReferenceStreamoutINTEL", static_cast(5707)}, + {"OpArbitraryFloatLogINTEL", static_cast(5860)}, + {"OpGroupNonUniformQuadSwap", static_cast(366)}, + {"OpVmeImageINTEL", static_cast(5699)}, + {"OpFixedRsqrtINTEL", static_cast(5925)}, + {"OpUCountLeadingZerosINTEL", static_cast(5585)}, + {"OpAtomicFMaxEXT", static_cast(5615)}, + {"OpControlBarrier", static_cast(224)}, + {"OpSatConvertSToU", static_cast(118)}, + {"OpTypeAvcRefResultINTEL", static_cast(5711)}, + {"OpArbitraryFloatLog2INTEL", static_cast(5861)}, + {"OpGroupSMax", static_cast(271)}, + {"OpTypePipe", static_cast(38)}, + {"OpAtomicUMax", static_cast(239)}, + {"OpTypeImage", static_cast(25)}, + {"OpReadPipe", static_cast(274)}, + {"OpGroupNonUniformBroadcast", static_cast(337)}, + {"OpTypeFunction", static_cast(33)}, + {"OpTypeAvcImePayloadINTEL", static_cast(5701)}, + {"OpCreateUserEvent", static_cast(299)}, + {"OpSubgroupAvcBmeInitializeINTEL", static_cast(5782)}, + {"OpAtomicCompareExchangeWeak", static_cast(231)}, + {"OpSampledImage", static_cast(86)}, + {"OpConvertBF16ToFINTEL", static_cast(6117)}, + {"OpSubgroupAvcSicEvaluateIpeINTEL", static_cast(5803)}, + {"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", static_cast(5780)}, + {"OpAsmINTEL", static_cast(5610)}, + {"OpKill", static_cast(252)}, + {"OpGroupNonUniformShuffleDown", static_cast(348)}, + {"OpArbitraryFloatRecipINTEL", static_cast(5855)}, + {"OpIAverageRoundedINTEL", static_cast(5593)}, + {"OpUAddSatINTEL", static_cast(5590)}, + {"OpGroupNonUniformShuffle", static_cast(345)}, + {"OpDecorateId", static_cast(332)}, + {"OpArbitraryFloatExpm1INTEL", static_cast(5867)}, + {"OpGroupBitwiseXorKHR", static_cast(6405)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", static_cast(5763)}, + {"OpArbitraryFloatASinPiINTEL", static_cast(5874)}, + {"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", static_cast(5797)}, + {"OpIsNormal", static_cast(159)}, + {"OpIEqual", static_cast(170)}, + {"OpArbitraryFloatACosPiINTEL", static_cast(5876)}, + {"OpGroupNonUniformIMul", static_cast(351)}, + {"OpMatrixTimesVector", static_cast(145)}, + {"OpSetMeshOutputsEXT", static_cast(5295)}, + {"OpFragmentFetchAMD", static_cast(5012)}, + {"OpShiftLeftLogical", static_cast(196)}, + {"OpSubgroupAvcRefConvertToMceResultINTEL", static_cast(5790)}, + {"OpDemoteToHelperInvocationEXT", static_cast(5380)}, + {"OpInBoundsAccessChain", static_cast(66)}, + {"OpCooperativeMatrixMulAddKHR", static_cast(4459)}, + {"OpAtomicIAdd", static_cast(234)}, + {"OpCopyMemorySized", static_cast(64)}, + {"OpSubgroupAvcMceGetInterMinorShapeINTEL", static_cast(5742)}, + {"OpImageSparseRead", static_cast(320)}, + {"OpTypeAvcRefPayloadINTEL", static_cast(5702)}, + {"OpArbitraryFloatExp10INTEL", static_cast(5866)}, + {"OpTypeAvcSicPayloadINTEL", static_cast(5703)}, + {"OpConvertFToS", static_cast(110)}, + {"OpISubSatINTEL", static_cast(5595)}, + {"OpVariableLengthArrayINTEL", static_cast(5818)}, + {"OpRayQueryGetIntersectionTriangleVertexPositionsKHR", static_cast(5340)}, + {"OpGroupNonUniformAllEqual", static_cast(336)}, + {"OpIsInf", static_cast(157)}, + {"OpIgnoreIntersectionKHR", static_cast(4448)}, + {"OpImageGather", static_cast(96)}, + {"OpRayQueryGetRayFlagsKHR", static_cast(6017)}, + {"OpGroupNonUniformShuffleUp", static_cast(347)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", static_cast(5760)}, + {"OpRayQueryGetIntersectionTKHR", static_cast(6018)}, + {"OpHitObjectGetAttributesNV", static_cast(5266)}, + {"OpFUnordLessThanEqual", static_cast(189)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", static_cast(5757)}, + {"OpHitObjectGetObjectRayDirectionNV", static_cast(5254)}, + {"OpCooperativeMatrixStoreKHR", static_cast(4458)}, + {"OpSubgroupAvcMceSetInterShapePenaltyINTEL", static_cast(5716)}, + {"OpModuleProcessed", static_cast(330)}, + {"OpEmitStreamVertex", static_cast(220)}, + {"OpMemoryModel", static_cast(14)}, + {"OpDepthAttachmentReadEXT", static_cast(4161)}, + {"OpGroupNonUniformUMax", static_cast(357)}, + {"OpFwidthFine", static_cast(212)}, + {"OpImageSampleExplicitLod", static_cast(88)}, + {"OpUGreaterThanEqual", static_cast(174)}, + {"OpSubgroupShuffleDownINTEL", static_cast(5572)}, + {"OpHitObjectRecordHitWithIndexMotionNV", static_cast(5250)}, + {"OpIAverageINTEL", static_cast(5591)}, + {"OpFRem", static_cast(140)}, + {"OpSubgroupAvcImeAdjustRefOffsetINTEL", static_cast(5751)}, + {"OpSwitch", static_cast(251)}, + {"OpBitwiseAnd", static_cast(199)}, + {"OpUMod", static_cast(137)}, + {"OpAtomicXor", static_cast(242)}, + {"OpFAdd", static_cast(129)}, + {"OpRestoreMemoryINTEL", static_cast(5820)}, + {"OpPtrCastToCrossWorkgroupINTEL", static_cast(5934)}, + {"OpImageRead", static_cast(98)}, + {"OpTypeAvcImeResultDualReferenceStreamoutINTEL", static_cast(5708)}, + {"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", static_cast(5805)}, + {"OpCompositeExtract", static_cast(81)}, + {"OpSubgroupBlockReadINTEL", static_cast(5575)}, + {"OpSubgroupAvcMceConvertToImeResultINTEL", static_cast(5733)}, + {"OpSubgroupAvcMceConvertToRefResultINTEL", static_cast(5735)}, + {"OpGroupCommitReadPipe", static_cast(287)}, + {"OpConvertFToU", static_cast(109)}, + {"OpConvertUToF", static_cast(112)}, + {"OpCommitReadPipe", static_cast(280)}, + {"OpLabel", static_cast(248)}, + {"OpGroupUMinNonUniformAMD", static_cast(5003)}, + {"OpTypeNamedBarrier", static_cast(327)}, + {"OpConvertPtrToU", static_cast(117)}, + {"OpTypeVmeImageINTEL", static_cast(5700)}, + {"OpTypeVector", static_cast(23)}, + {"OpGroupNonUniformLogicalXor", static_cast(364)}, + {"OpSignBitSet", static_cast(160)}, + {"OpGetMaxPipePackets", static_cast(284)}, + {"OpSubgroupImageMediaBlockReadINTEL", static_cast(5580)}, + {"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", static_cast(5778)}, + {"OpArbitraryFloatCosPiINTEL", static_cast(5872)}, + {"OpReturn", static_cast(253)}, + {"OpFixedSinPiINTEL", static_cast(5929)}, + {"OpGetKernelMaxNumSubgroups", static_cast(326)}, + {"OpTypeDeviceEvent", static_cast(35)}, + {"OpSubgroupAvcSicConfigureIpeLumaINTEL", static_cast(5793)}, + {"OpArbitraryFloatASinINTEL", static_cast(5873)}, + {"OpArbitraryFloatSinINTEL", static_cast(5868)}, + {"OpArbitraryFloatATanPiINTEL", static_cast(5878)}, + {"OpArbitraryFloatCastFromIntINTEL", static_cast(5842)}, + {"OpHitObjectGetCurrentTimeNV", static_cast(5265)}, + {"OpFMod", static_cast(141)}, + {"OpAtomicSMax", static_cast(238)}, + {"OpGroupNonUniformBitwiseXor", static_cast(361)}, + {"OpUDotAccSat", static_cast(4454)}, + {"OpGroupSMinNonUniformAMD", static_cast(5004)}, + {"OpSubgroupAvcImeSetDualReferenceINTEL", static_cast(5749)}, + {"OpGroupAny", static_cast(262)}, + {"OpTypeStructContinuedINTEL", static_cast(6090)}, + {"OpTraceRayMotionNV", static_cast(5339)}, + {"OpHitObjectGetObjectToWorldNV", static_cast(5253)}, + {"OpGetKernelWorkGroupSize", static_cast(295)}, + {"OpFConvert", static_cast(115)}, + {"OpArbitraryFloatEQINTEL", static_cast(5854)}, + {"OpSubgroupAvcImeSetSingleReferenceINTEL", static_cast(5748)}, + {"OpGroupAll", static_cast(261)}, + {"OpCooperativeMatrixLengthKHR", static_cast(4460)}, + {"OpSMod", static_cast(139)}, + {"OpConvertSToF", static_cast(111)}, + {"OpImageQuerySamples", static_cast(107)}, + {"OpInBoundsPtrAccessChain", static_cast(70)}, + {"OpNot", static_cast(200)}, + {"OpUGreaterThan", static_cast(172)}, + {"OpSubgroupAvcMceConvertToSicPayloadINTEL", static_cast(5736)}, + {"OpSubgroupAvcSicSetBilinearFilterEnableINTEL", static_cast(5800)}, + {"OpRayQueryGetIntersectionTypeKHR", static_cast(4479)}, + {"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", static_cast(5801)}, + {"OpImageSampleImplicitLod", static_cast(87)}, + {"OpHitObjectGetRayTMinNV", static_cast(5275)}, + {"OpGroupNonUniformBallotFindLSB", static_cast(343)}, + {"OpName", static_cast(5)}, + {"OpConvertUToPtr", static_cast(120)}, + {"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", static_cast(5720)}, + {"OpAtomicOr", static_cast(241)}, + {"OpSubgroupAnyKHR", static_cast(4429)}, + {"OpSelect", static_cast(169)}, + {"OpImageSparseSampleProjDrefImplicitLod", static_cast(311)}, + {"OpFOrdLessThan", static_cast(184)}, + {"OpSDotKHR", static_cast(4450)}, + {"OpGroupReserveReadPipePackets", static_cast(285)}, + {"OpLogicalNotEqual", static_cast(165)}, + {"OpControlBarrierArriveINTEL", static_cast(6142)}, + {"OpDPdxFine", static_cast(210)}, + {"OpGroupNonUniformPartitionNV", static_cast(5296)}, + {"OpImageBoxFilterQCOM", static_cast(4481)}, + {"OpRayQueryGetIntersectionWorldToObjectKHR", static_cast(6032)}, + {"OpSubgroupAvcSicGetInterRawSadsINTEL", static_cast(5816)}, + {"OpSRem", static_cast(138)}, + {"OpSizeOf", static_cast(321)}, + {"OpUDot", static_cast(4451)}, + {"OpReleaseEvent", static_cast(298)}, + {"OpIgnoreIntersectionNV", static_cast(5335)}, + {"OpFOrdNotEqual", static_cast(182)}, + {"OpFOrdGreaterThanEqual", static_cast(190)}, + {"OpAll", static_cast(155)}, + {"OpExpectKHR", static_cast(5631)}, + {"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", static_cast(5731)}, + {"OpCompositeInsert", static_cast(82)}, + {"OpImageSparseSampleImplicitLod", static_cast(305)}, + {"OpFixedLogINTEL", static_cast(5932)}, + {"OpMatrixTimesMatrix", static_cast(146)}, + {"OpTypeOpaque", static_cast(31)}, + {"OpCooperativeMatrixLengthNV", static_cast(5362)}, + {"OpExecuteCallableKHR", static_cast(4446)}, + {"OpImageDrefGather", static_cast(97)}, + {"OpFUnordLessThan", static_cast(185)}, + {"OpPtrAccessChain", static_cast(67)}, + {"OpTypeForwardPointer", static_cast(39)}, + {"OpAtomicCompareExchange", static_cast(230)}, + {"OpCooperativeMatrixLoadNV", static_cast(5359)}, + {"OpSubgroupAvcMceConvertToSicResultINTEL", static_cast(5737)}, + {"OpFragmentMaskFetchAMD", static_cast(5011)}, + {"OpImageSparseFetch", static_cast(313)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", static_cast(5759)}, + {"OpReadClockKHR", static_cast(5056)}, + {"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", static_cast(5789)}, + {"OpSubgroupAllEqualKHR", static_cast(4430)}, + {"OpFNegate", static_cast(127)}, + {"OpArbitraryFloatGTINTEL", static_cast(5850)}, + {"OpReportIntersectionNV", static_cast(5334)}, + {"OpUCountTrailingZerosINTEL", static_cast(5586)}, + {"OpBitFieldUExtract", static_cast(203)}, + {"OpCompositeConstruct", static_cast(80)}, + {"OpImageSparseGather", static_cast(314)}, + {"OpImageSparseSampleDrefExplicitLod", static_cast(308)}, + {"OpGetKernelLocalSizeForSubgroupCount", static_cast(325)}, + {"OpNop", static_cast(0)}, + {"OpTypeAvcSicResultINTEL", static_cast(5712)}, + {"OpAtomicSMin", static_cast(236)}, + {"OpLoad", static_cast(61)}, + {"OpIsNan", static_cast(156)}, + {"OpAny", static_cast(154)}, + {"OpIAddCarry", static_cast(149)}, + {"OpExtInstImport", static_cast(11)}, + {"OpLoopControlINTEL", static_cast(5887)}, + {"OpSubgroupAvcImeConvertToMceResultINTEL", static_cast(5765)}, + {"OpGroupNonUniformSMax", static_cast(356)}, + {"OpGroupSMin", static_cast(268)}, + {"OpConstantPipeStorage", static_cast(323)}, + {"OpIsValidReserveId", static_cast(282)}, + {"OpAliasScopeListDeclINTEL", static_cast(5913)}, + {"OpConvertUToAccelerationStructureKHR", static_cast(4447)}, + {"OpArbitraryFloatCastINTEL", static_cast(5841)}, + {"OpHitObjectGetShaderBindingTableRecordIndexNV", static_cast(5258)}, + {"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", static_cast(5768)}, + {"OpSubgroupBallotKHR", static_cast(4421)}, + {"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", static_cast(5810)}, + {"OpGroupNonUniformBallotFindMSB", static_cast(344)}, + {"OpTypeMatrix", static_cast(24)}, + {"OpTraceMotionNV", static_cast(5338)}, + {"OpGroupLogicalXorKHR", static_cast(6408)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", static_cast(5771)}, + {"OpRayQueryConfirmIntersectionKHR", static_cast(4476)}, + {"OpArbitraryFloatRSqrtINTEL", static_cast(5856)}, + {"OpRayQueryGetRayTMinKHR", static_cast(6016)}, + {"OpUMul32x16INTEL", static_cast(5598)}, + {"OpReadPipeBlockingINTEL", static_cast(5946)}, + {"OpHitObjectIsEmptyNV", static_cast(5276)}, + {"OpImageSampleFootprintNV", static_cast(5283)}, + {"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", static_cast(5798)}, + {"OpGroupLogicalOrKHR", static_cast(6407)}, + {"OpAtomicFlagClear", static_cast(319)}, + {"OpBeginInvocationInterlockEXT", static_cast(5364)}, + {"OpVectorInsertDynamic", static_cast(78)}, + {"OpRayQueryGetIntersectionBarycentricsKHR", static_cast(6024)}, + {"OpArbitraryFloatSubINTEL", static_cast(5847)}, + {"OpConvertSampledImageToUNV", static_cast(5396)}, + {"OpTypeAvcImeDualReferenceStreaminINTEL", static_cast(5710)}, + {"OpVectorTimesScalar", static_cast(142)}, + {"OpImageSampleProjDrefImplicitLod", static_cast(93)}, + {"OpTypeAvcImeSingleReferenceStreaminINTEL", static_cast(5709)}, + {"OpImageSparseSampleProjDrefExplicitLod", static_cast(312)}, + {"OpAtomicLoad", static_cast(227)}, + {"OpTypeFloat", static_cast(22)}, + {"OpGroupNonUniformUMin", static_cast(354)}, + {"OpSubgroupAvcMceSetAcOnlyHaarINTEL", static_cast(5728)}, + {"OpTypeSampler", static_cast(26)}, + {"OpTypeAccelerationStructureKHR", static_cast(5341)}, + {"OpGroupIAddNonUniformAMD", static_cast(5000)}, + {"OpFixedSinCosINTEL", static_cast(5928)}, + {"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", static_cast(5723)}, + {"OpGroupNonUniformAll", static_cast(334)}, + {"OpArbitraryFloatCastToIntINTEL", static_cast(5843)}, + {"OpGroupNonUniformShuffleXor", static_cast(346)}, + {"OpGroupUMin", static_cast(267)}, + {"OpUndef", static_cast(1)}, + {"OpTerminateRayNV", static_cast(5336)}, + {"OpTypeVoid", static_cast(19)}, + {"OpRayQueryGetIntersectionObjectToWorldKHR", static_cast(6031)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", static_cast(5773)}, + {"OpTypePointer", static_cast(32)}, + {"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", static_cast(5807)}, + {"OpTranspose", static_cast(84)}, + {"OpGroupSMaxNonUniformAMD", static_cast(5007)}, + {"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", static_cast(5769)}, + {"OpSubgroupAvcFmeInitializeINTEL", static_cast(5781)}, + {"OpPtrCastToGeneric", static_cast(121)}, + {"OpRetainEvent", static_cast(297)}, + {"OpConstantNull", static_cast(46)}, + {"OpImageSparseSampleDrefImplicitLod", static_cast(307)}, + {"OpArbitraryFloatACosINTEL", static_cast(5875)}, + {"OpExecuteCallableNV", static_cast(5344)}, + {"OpTerminateRayKHR", static_cast(4449)}, + {"OpImageSampleDrefImplicitLod", static_cast(89)}, + {"OpImageSampleProjExplicitLod", static_cast(92)}, + {"OpGroupNonUniformInverseBallot", static_cast(340)}, + {"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", static_cast(5717)}, + {"OpMemberDecorate", static_cast(72)}, + {"OpHitObjectRecordEmptyNV", static_cast(5259)}, + {"OpImageQueryLevels", static_cast(106)}, + {"OpSDot", static_cast(4450)}, + {"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", static_cast(5766)}, + {"OpFixedExpINTEL", static_cast(5933)}, + {"OpHitObjectGetPrimitiveIndexNV", static_cast(5268)}, + {"OpTypeRuntimeArray", static_cast(29)}, + {"OpHitObjectGetShaderRecordBufferHandleNV", static_cast(5257)}, + {"OpSubgroupAvcMceConvertToImePayloadINTEL", static_cast(5732)}, + {"OpCaptureEventProfilingInfo", static_cast(302)}, + {"OpRayQueryGetWorldRayDirectionKHR", static_cast(6029)}, + {"OpConstantFalse", static_cast(42)}, + {"OpArbitraryFloatLog1pINTEL", static_cast(5863)}, + {"OpHitObjectIsMissNV", static_cast(5278)}, + {"OpWritePipeBlockingINTEL", static_cast(5947)}, + {"OpTypeCooperativeMatrixNV", static_cast(5358)}, + {"OpSubgroupShuffleXorINTEL", static_cast(5574)}, + {"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", static_cast(5753)}, + {"OpTypeInt", static_cast(21)}, + {"OpSubgroupAvcImeInitializeINTEL", static_cast(5747)}, + {"OpMemoryNamedBarrier", static_cast(329)}, + {"OpConstantComposite", static_cast(44)}, + {"OpHitObjectGetInstanceCustomIndexNV", static_cast(5271)}, + {"OpGroupWaitEvents", static_cast(260)}, + {"OpSubgroupAllKHR", static_cast(4428)}, + {"OpSubgroupImageMediaBlockWriteINTEL", static_cast(5581)}, + {"OpSatConvertUToS", static_cast(119)}, + {"OpArbitraryFloatCosINTEL", static_cast(5869)}, + {"OpSetUserEventStatus", static_cast(301)}, + {"OpGroupNonUniformIAdd", static_cast(349)}, + {"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", static_cast(5804)}, + {"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", static_cast(5788)}, + {"OpGroupUMaxNonUniformAMD", static_cast(5006)}, + {"OpRayQueryGetIntersectionObjectRayOriginKHR", static_cast(6028)}, + {"OpGetKernelPreferredWorkGroupSizeMultiple", static_cast(296)}, + {"OpSubgroupAvcSicGetMotionVectorMaskINTEL", static_cast(5795)}, + {"OpConstantFunctionPointerINTEL", static_cast(5600)}, + {"OpAsmTargetINTEL", static_cast(5609)}, + {"OpOrdered", static_cast(162)}, + {"OpFPGARegINTEL", static_cast(5949)}, + {"OpFixedSinINTEL", static_cast(5926)}, + {"OpRayQueryGetIntersectionGeometryIndexKHR", static_cast(6022)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", static_cast(5762)}, + {"OpUnreachable", static_cast(255)}, + {"OpSource", static_cast(3)}, + {"OpSamplerImageAddressingModeNV", static_cast(5397)}, + {"OpExtension", static_cast(10)}, + {"OpBitFieldInsert", static_cast(201)}, + {"OpCreatePipeFromPipeStorage", static_cast(324)}, + {"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", static_cast(5786)}, + {"OpReserveWritePipePackets", static_cast(279)}, + {"OpTypeHitObjectNV", static_cast(5281)}, + {"OpTypeRayQueryKHR", static_cast(4472)}, + {"OpAtomicIIncrement", static_cast(232)}, + {"OpGroupIMulKHR", static_cast(6401)}, + {"OpExecutionMode", static_cast(16)}, + {"OpTypeReserveId", static_cast(36)}, + {"OpImageQueryFormat", static_cast(101)}, + {"OpBitwiseXor", static_cast(198)}, + {"OpSpecConstant", static_cast(50)}, + {"OpSGreaterThan", static_cast(173)}, + {"OpIAddSatINTEL", static_cast(5589)}, + {"OpSourceExtension", static_cast(4)}, + {"OpFUnordGreaterThanEqual", static_cast(191)}, + {"OpEndInvocationInterlockEXT", static_cast(5365)}, + {"OpSourceContinued", static_cast(2)}, + {"OpCooperativeMatrixMulAddNV", static_cast(5361)}, + {"OpAtomicExchange", static_cast(229)}, + {"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", static_cast(5721)}, + {"OpUAverageRoundedINTEL", static_cast(5594)}, + {"OpSubgroupAvcSicGetIpeChromaModeINTEL", static_cast(5813)}, + {"OpUnordered", static_cast(163)}, + {"OpWritePipe", static_cast(275)}, + {"OpSelectionMerge", static_cast(247)}, + {"OpPtrEqual", static_cast(401)}, + {"OpTypeBool", static_cast(20)}, + {"OpRayQueryGetIntersectionObjectRayDirectionKHR", static_cast(6027)}, + {"OpGroupNonUniformFAdd", static_cast(350)}, + {"OpTypeSampledImage", static_cast(27)}, + {"OpSubgroupAvcSicInitializeINTEL", static_cast(5791)}, + {"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", static_cast(5779)}, + {"OpGroupBroadcast", static_cast(263)}, + {"OpSaveMemoryINTEL", static_cast(5819)}, + {"OpConstantTrue", static_cast(41)}, + {"OpImageSampleDrefExplicitLod", static_cast(90)}, + {"OpHitObjectTraceRayMotionNV", static_cast(5256)}, + {"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", static_cast(6026)}, + {"OpSpecConstantTrue", static_cast(48)}, + {"OpBranch", static_cast(249)}, + {"OpStencilAttachmentReadEXT", static_cast(4162)}, + {"OpHitObjectExecuteShaderNV", static_cast(5264)}, + {"OpGroupNonUniformBallot", static_cast(339)}, + {"OpGroupReserveWritePipePackets", static_cast(286)}, + {"OpImageSparseTexelsResident", static_cast(316)}, + {"OpGroupFMax", static_cast(269)}, + {"OpWritePackedPrimitiveIndices4x8NV", static_cast(5299)}, + {"OpImageSparseDrefGather", static_cast(315)}, + {"OpIMul32x16INTEL", static_cast(5597)}, + {"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", static_cast(5811)}, + {"OpISubBorrow", static_cast(150)}, + {"OpArbitraryFloatSinPiINTEL", static_cast(5871)}, + {"OpCopyMemory", static_cast(63)}, + {"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", static_cast(5812)}, + {"OpGroupNonUniformLogicalAnd", static_cast(362)}, + {"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", static_cast(5722)}, + {"OpFunctionCall", static_cast(57)}, + {"OpImageSampleProjDrefExplicitLod", static_cast(94)}, + {"OpAtomicFMinEXT", static_cast(5614)}, + {"OpSubgroupAvcMceGetInterReferenceIdsINTEL", static_cast(5745)}, + {"OpFixedRecipINTEL", static_cast(5924)}, + {"OpLogicalAnd", static_cast(167)}, + {"OpConvertImageToUNV", static_cast(5393)}, + {"OpCapability", static_cast(17)}, + {"OpSubgroupAvcSicConvertToMceResultINTEL", static_cast(5808)}, + {"OpArbitraryFloatAddINTEL", static_cast(5846)}, + {"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", static_cast(5806)}, + {"OpMemberName", static_cast(6)}, + {"OpSubgroupShuffleINTEL", static_cast(5571)}, + {"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", static_cast(5713)}, + {"OpHitObjectGetRayTMaxNV", static_cast(5274)}, + {"OpGroupNonUniformBitwiseAnd", static_cast(359)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", static_cast(5758)}, + {"OpTraceNV", static_cast(5337)}, + {"OpFDiv", static_cast(136)}, + {"OpAtomicAnd", static_cast(240)}, + {"OpDPdyFine", static_cast(211)}, + {"OpULessThanEqual", static_cast(178)}, + {"OpGroupNonUniformAny", static_cast(335)}, + {"OpRayQueryGetIntersectionInstanceCustomIndexKHR", static_cast(6019)}, + {"OpGroupLogicalAndKHR", static_cast(6406)}, + {"OpHitObjectIsHitNV", static_cast(5277)}, + {"OpSubgroupImageBlockReadINTEL", static_cast(5577)}, + {"OpHitObjectGetWorldRayOriginNV", static_cast(5273)}, + {"OpAliasScopeDeclINTEL", static_cast(5912)}, + {"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", static_cast(5799)}, + {"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", static_cast(5777)}, + {"OpOuterProduct", static_cast(147)}, + {"OpEnqueueMarker", static_cast(291)}, + {"OpSubgroupAvcSicGetIpeLumaShapeINTEL", static_cast(5809)}, + {"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", static_cast(5718)}, + {"OpFixedSinCosPiINTEL", static_cast(5931)}, + {"OpArbitraryFloatMulINTEL", static_cast(5848)}, + {"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", static_cast(5754)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", static_cast(5770)}, + {"OpGroupMemberDecorate", static_cast(75)}, + {"OpConstantSampler", static_cast(45)}, + {"OpGroupNonUniformBallotBitExtract", static_cast(341)}, + {"OpRayQueryGetWorldRayOriginKHR", static_cast(6030)}, + {"OpGroupBitwiseOrKHR", static_cast(6404)}, + {"OpSubgroupAvcImeGetBorderReachedINTEL", static_cast(5776)}, + {"OpLifetimeStart", static_cast(256)}, + {"OpConvertUToSampledImageNV", static_cast(5395)}, + {"OpAtomicFAddEXT", static_cast(6035)}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 718; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value) +{ + static const unsigned tableSalt[245] = { + 1, 2, 0, 1, 1, 1, 0, 0, 2, 2, 0, 0, 0, 8, 0, 5, + 0, 0, 0, 0, 3, 2, 0, 1, 7, 3, 5, 3, 1, 2, 1, 0, + 0, 0, 0, 0, 4, 0, 0, 2, 1, 23, 1, 0, 5, 2, 0, 1, + 19, 0, 3, 0, 4, 1, 0, 1, 0, 4, 0, 8, 4, 3, 1, 2, + 2, 1, 0, 3, 2, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 15, + 0, 0, 8, 2, 1, 0, 1, 2, 1, 1, 2, 0, 2, 1, 0, 9, + 0, 3, 2, 4, 2, 7, 1, 0, 5, 0, 0, 0, 1, 6, 0, 0, + 1, 6, 2, 5, 1, 0, 2, 0, 7, 0, 0, 2, 4, 1, 14, 6, + 0, 12, 0, 1, 0, 0, 0, 0, 4, 4, 25, 10, 0, 0, 0, 14, + 1, 1, 3, 0, 6, 14, 1, 0, 1, 5, 0, 0, 1, 0, 2, 0, + 2, 35, 0, 0, 4, 0, 0, 8, 1, 3, 4, 0, 7, 19, 2, 9, + 2, 2, 12, 7, 2, 6, 0, 5, 1, 0, 3, 4, 2, 3, 14, 1, + 0, 7, 2, 46, 5, 2, 0, 0, 14, 0, 57, 0, 14, 0, 3, 0, + 0, 0, 25, 0, 32, 24, 49, 24, 1, 0, 27, 0, 0, 5, 3, 0, + 63, 0, 0, 0, 104, 0, 0, 10, 0, 0, 83, 79, 45, 4, 0, 0, + 231, 8, 133, 0, 14 + }; + + using KV = std::pair; + + static const KV words[245] = + { + {"StoragePushConstant8", static_cast(4450)}, + {"UniformTexelBufferArrayNonUniformIndexing", static_cast(5311)}, + {"ImageBasic", static_cast(13)}, + {"DeviceGroup", static_cast(4437)}, + {"DotProduct", static_cast(6019)}, + {"AtomicStorageOps", static_cast(4445)}, + {"ShaderSMBuiltinsNV", static_cast(5373)}, + {"PhysicalStorageBufferAddresses", static_cast(5347)}, + {"FragmentBarycentricKHR", static_cast(5284)}, + {"RayTracingProvisionalKHR", static_cast(5353)}, + {"UniformBufferArrayNonUniformIndexingEXT", static_cast(5306)}, + {"FPGAKernelAttributesv2INTEL", static_cast(6161)}, + {"FPGAArgumentInterfacesINTEL", static_cast(6174)}, + {"SampledRect", static_cast(37)}, + {"AtomicFloat64AddEXT", static_cast(6034)}, + {"DeviceEnqueue", static_cast(19)}, + {"ShadingRateNV", static_cast(5291)}, + {"FragmentShadingRateKHR", static_cast(4422)}, + {"RoundToInfinityINTEL", static_cast(5582)}, + {"FPFastMathModeINTEL", static_cast(5837)}, + {"AtomicFloat16AddEXT", static_cast(6095)}, + {"StorageImageWriteWithoutFormat", static_cast(56)}, + {"GroupNonUniformVote", static_cast(62)}, + {"StorageImageArrayDynamicIndexing", static_cast(31)}, + {"Int64Atomics", static_cast(12)}, + {"DotProductInput4x8Bit", static_cast(6017)}, + {"ArbitraryPrecisionFixedPointINTEL", static_cast(5922)}, + {"FPGALoopControlsINTEL", static_cast(5888)}, + {"IntegerFunctions2INTEL", static_cast(5584)}, + {"AsmINTEL", static_cast(5606)}, + {"ShaderViewportIndexLayerNV", static_cast(5254)}, + {"GroupUniformArithmeticKHR", static_cast(6400)}, + {"ComputeDerivativeGroupQuadsNV", static_cast(5288)}, + {"Pipes", static_cast(17)}, + {"Int8", static_cast(39)}, + {"MultiViewport", static_cast(57)}, + {"SampledImageArrayDynamicIndexing", static_cast(29)}, + {"VulkanMemoryModelKHR", static_cast(5345)}, + {"FragmentShaderSampleInterlockEXT", static_cast(5363)}, + {"DotProductInput4x8BitKHR", static_cast(6017)}, + {"CooperativeMatrixNV", static_cast(5357)}, + {"RoundingModeRTE", static_cast(4467)}, + {"DotProductInput4x8BitPackedKHR", static_cast(6018)}, + {"TextureBlockMatchQCOM", static_cast(4486)}, + {"ShaderViewportIndex", static_cast(70)}, + {"DemoteToHelperInvocationEXT", static_cast(5379)}, + {"GroupNonUniformShuffleRelative", static_cast(66)}, + {"Shader", static_cast(1)}, + {"FPGAClusterAttributesINTEL", static_cast(5904)}, + {"UniformBufferArrayNonUniformIndexing", static_cast(5306)}, + {"SampleRateShading", static_cast(35)}, + {"MemoryAccessAliasingINTEL", static_cast(5910)}, + {"Groups", static_cast(18)}, + {"StorageTexelBufferArrayDynamicIndexingEXT", static_cast(5305)}, + {"StorageUniform16", static_cast(4434)}, + {"FragmentFullyCoveredEXT", static_cast(5265)}, + {"PhysicalStorageBufferAddressesEXT", static_cast(5347)}, + {"MeshShadingEXT", static_cast(5283)}, + {"GroupNonUniformPartitionedNV", static_cast(5297)}, + {"ImageMSArray", static_cast(48)}, + {"StorageInputOutput16", static_cast(4436)}, + {"VariablePointers", static_cast(4442)}, + {"TileImageStencilReadAccessEXT", static_cast(4168)}, + {"SampledImageArrayNonUniformIndexingEXT", static_cast(5307)}, + {"ShaderClockKHR", static_cast(5055)}, + {"SubgroupVoteKHR", static_cast(4431)}, + {"StorageBufferArrayNonUniformIndexingEXT", static_cast(5308)}, + {"UniformTexelBufferArrayDynamicIndexing", static_cast(5304)}, + {"GroupNonUniformArithmetic", static_cast(63)}, + {"RoundingModeRTZ", static_cast(4468)}, + {"StorageTexelBufferArrayNonUniformIndexingEXT", static_cast(5312)}, + {"FPGADSPControlINTEL", static_cast(5908)}, + {"SubgroupAvcMotionEstimationINTEL", static_cast(5696)}, + {"LongConstantCompositeINTEL", static_cast(6089)}, + {"UniformAndStorageBuffer16BitAccess", static_cast(4434)}, + {"DotProductInputAll", static_cast(6016)}, + {"VulkanMemoryModel", static_cast(5345)}, + {"FPMaxErrorINTEL", static_cast(6169)}, + {"VariablePointersStorageBuffer", static_cast(4441)}, + {"ImageGatherExtended", static_cast(25)}, + {"ShaderLayer", static_cast(69)}, + {"FragmentShaderShadingRateInterlockEXT", static_cast(5372)}, + {"FPGAInvocationPipeliningAttributesINTEL", static_cast(5916)}, + {"GroupNonUniform", static_cast(61)}, + {"AtomicFloat16MinMaxEXT", static_cast(5616)}, + {"FragmentShaderPixelInterlockEXT", static_cast(5378)}, + {"AtomicStorage", static_cast(21)}, + {"RayQueryKHR", static_cast(4472)}, + {"TextureBoxFilterQCOM", static_cast(4485)}, + {"GroupNonUniformBallot", static_cast(64)}, + {"ShaderViewportMaskNV", static_cast(5255)}, + {"WorkgroupMemoryExplicitLayout16BitAccessKHR", static_cast(4430)}, + {"AtomicFloat32AddEXT", static_cast(6033)}, + {"LoopFuseINTEL", static_cast(5906)}, + {"DerivativeControl", static_cast(51)}, + {"FunctionFloatControlINTEL", static_cast(5821)}, + {"RayTracingMotionBlurNV", static_cast(5341)}, + {"FragmentMaskAMD", static_cast(5010)}, + {"Geometry", static_cast(2)}, + {"SubgroupAvcMotionEstimationChromaINTEL", static_cast(5698)}, + {"RayTraversalPrimitiveCullingKHR", static_cast(4478)}, + {"TessellationPointSize", static_cast(23)}, + {"Addresses", static_cast(4)}, + {"SubgroupDispatch", static_cast(58)}, + {"StorageBuffer16BitAccess", static_cast(4433)}, + {"StorageUniformBufferBlock16", static_cast(4433)}, + {"ImageQuery", static_cast(50)}, + {"InterpolationFunction", static_cast(52)}, + {"UnstructuredLoopControlsINTEL", static_cast(5886)}, + {"GeometryPointSize", static_cast(24)}, + {"InputAttachmentArrayDynamicIndexingEXT", static_cast(5303)}, + {"ShaderNonUniform", static_cast(5301)}, + {"StorageImageReadWithoutFormat", static_cast(55)}, + {"GroupNonUniformShuffle", static_cast(65)}, + {"WorkgroupMemoryExplicitLayout8BitAccessKHR", static_cast(4429)}, + {"GroupNonUniformQuad", static_cast(68)}, + {"Float16", static_cast(9)}, + {"ClipDistance", static_cast(32)}, + {"SignedZeroInfNanPreserve", static_cast(4466)}, + {"ImageReadWrite", static_cast(14)}, + {"Kernel", static_cast(6)}, + {"RayQueryPositionFetchKHR", static_cast(5391)}, + {"BindlessTextureNV", static_cast(5390)}, + {"ImageGatherBiasLodAMD", static_cast(5009)}, + {"StorageImageExtendedFormats", static_cast(49)}, + {"FPGARegINTEL", static_cast(5948)}, + {"Matrix", static_cast(0)}, + {"StorageImageMultisample", static_cast(27)}, + {"Float16Buffer", static_cast(8)}, + {"SampledCubeArray", static_cast(45)}, + {"DebugInfoModuleINTEL", static_cast(6114)}, + {"MinLod", static_cast(42)}, + {"RayQueryProvisionalKHR", static_cast(4471)}, + {"ExpectAssumeKHR", static_cast(5629)}, + {"Vector16", static_cast(7)}, + {"RuntimeDescriptorArrayEXT", static_cast(5302)}, + {"SubgroupAvcMotionEstimationIntraINTEL", static_cast(5697)}, + {"ImageReadWriteLodAMD", static_cast(5015)}, + {"ShaderNonUniformEXT", static_cast(5301)}, + {"SubgroupImageBlockIOINTEL", static_cast(5570)}, + {"FPGALatencyControlINTEL", static_cast(6171)}, + {"FPGAMemoryAttributesINTEL", static_cast(5824)}, + {"SampleMaskPostDepthCoverage", static_cast(4447)}, + {"InputAttachment", static_cast(40)}, + {"SampledBuffer", static_cast(46)}, + {"FPGAKernelAttributesINTEL", static_cast(5897)}, + {"CoreBuiltinsARM", static_cast(4165)}, + {"DotProductInput4x8BitPacked", static_cast(6018)}, + {"FragmentDensityEXT", static_cast(5291)}, + {"Int64ImageEXT", static_cast(5016)}, + {"MeshShadingNV", static_cast(5266)}, + {"StorageTexelBufferArrayNonUniformIndexing", static_cast(5312)}, + {"FloatingPointModeINTEL", static_cast(5583)}, + {"RayTracingNV", static_cast(5340)}, + {"VectorComputeINTEL", static_cast(5617)}, + {"CooperativeMatrixKHR", static_cast(6022)}, + {"FPGAMemoryAccessesINTEL", static_cast(5898)}, + {"RuntimeAlignedAttributeINTEL", static_cast(5939)}, + {"StorageBufferArrayDynamicIndexing", static_cast(30)}, + {"Int64", static_cast(11)}, + {"UniformAndStorageBuffer8BitAccess", static_cast(4449)}, + {"RuntimeDescriptorArray", static_cast(5302)}, + {"TileImageColorReadAccessEXT", static_cast(4166)}, + {"UniformTexelBufferArrayDynamicIndexingEXT", static_cast(5304)}, + {"BlockingPipesINTEL", static_cast(5945)}, + {"VariableLengthArrayINTEL", static_cast(5817)}, + {"SubgroupImageMediaBlockIOINTEL", static_cast(5579)}, + {"Tessellation", static_cast(3)}, + {"SampleMaskOverrideCoverageNV", static_cast(5249)}, + {"ImageBuffer", static_cast(47)}, + {"Linkage", static_cast(5)}, + {"USMStorageClassesINTEL", static_cast(5935)}, + {"ComputeDerivativeGroupLinearNV", static_cast(5350)}, + {"StorageImageArrayNonUniformIndexing", static_cast(5309)}, + {"StorageImageArrayNonUniformIndexingEXT", static_cast(5309)}, + {"ImageRect", static_cast(36)}, + {"Float16ImageAMD", static_cast(5008)}, + {"SparseResidency", static_cast(41)}, + {"NamedBarrier", static_cast(59)}, + {"GenericPointer", static_cast(38)}, + {"SubgroupBufferBlockIOINTEL", static_cast(5569)}, + {"InputAttachmentArrayNonUniformIndexing", static_cast(5310)}, + {"TransformFeedback", static_cast(53)}, + {"AtomicFloat32MinMaxEXT", static_cast(5612)}, + {"StorageBufferArrayNonUniformIndexing", static_cast(5308)}, + {"CullDistance", static_cast(33)}, + {"OptNoneINTEL", static_cast(6094)}, + {"SampledImageArrayNonUniformIndexing", static_cast(5307)}, + {"SubgroupBallotKHR", static_cast(4423)}, + {"DrawParameters", static_cast(4427)}, + {"ShaderStereoViewNV", static_cast(5259)}, + {"ImageFootprintNV", static_cast(5282)}, + {"StorageBuffer8BitAccess", static_cast(4448)}, + {"UniformDecoration", static_cast(71)}, + {"ShaderViewportIndexLayerEXT", static_cast(5254)}, + {"BitInstructions", static_cast(6025)}, + {"GroupNonUniformRotateKHR", static_cast(6026)}, + {"PerViewAttributesNV", static_cast(5260)}, + {"Sampled1D", static_cast(43)}, + {"ArbitraryPrecisionFloatingPointINTEL", static_cast(5845)}, + {"VectorAnyINTEL", static_cast(5619)}, + {"PipeStorage", static_cast(60)}, + {"DemoteToHelperInvocation", static_cast(5379)}, + {"DenormFlushToZero", static_cast(4465)}, + {"Float64", static_cast(10)}, + {"VulkanMemoryModelDeviceScope", static_cast(5346)}, + {"IndirectReferencesINTEL", static_cast(5604)}, + {"DotProductKHR", static_cast(6019)}, + {"UniformBufferArrayDynamicIndexing", static_cast(28)}, + {"InputAttachmentArrayNonUniformIndexingEXT", static_cast(5310)}, + {"LiteralSampler", static_cast(20)}, + {"SubgroupShuffleINTEL", static_cast(5568)}, + {"InputAttachmentArrayDynamicIndexing", static_cast(5303)}, + {"GeometryShaderPassthroughNV", static_cast(5251)}, + {"Int16", static_cast(22)}, + {"StoragePushConstant16", static_cast(4435)}, + {"GeometryStreams", static_cast(54)}, + {"VulkanMemoryModelDeviceScopeKHR", static_cast(5346)}, + {"ShaderInvocationReorderNV", static_cast(5383)}, + {"FPGABufferLocationINTEL", static_cast(5920)}, + {"WorkgroupMemoryExplicitLayoutKHR", static_cast(4428)}, + {"GroupNonUniformClustered", static_cast(67)}, + {"FunctionPointersINTEL", static_cast(5603)}, + {"Image1D", static_cast(44)}, + {"DotProductInputAllKHR", static_cast(6016)}, + {"BFloat16ConversionINTEL", static_cast(6115)}, + {"ImageMipmap", static_cast(15)}, + {"KernelAttributesINTEL", static_cast(5892)}, + {"TextureSampleWeightedQCOM", static_cast(4484)}, + {"IOPipesINTEL", static_cast(5943)}, + {"MultiView", static_cast(4439)}, + {"RayTracingPositionFetchKHR", static_cast(5336)}, + {"StorageTexelBufferArrayDynamicIndexing", static_cast(5305)}, + {"UniformTexelBufferArrayNonUniformIndexingEXT", static_cast(5311)}, + {"AtomicFloat64MinMaxEXT", static_cast(5613)}, + {"StencilExportEXT", static_cast(5013)}, + {"RayTracingKHR", static_cast(4479)}, + {"DenormPreserve", static_cast(4464)}, + {"RayTracingOpacityMicromapEXT", static_cast(5381)}, + {"ArbitraryPrecisionIntegersINTEL", static_cast(5844)}, + {"TileImageDepthReadAccessEXT", static_cast(4167)}, + {"SplitBarrierINTEL", static_cast(6141)}, + {"RayCullMaskKHR", static_cast(6020)}, + {"ImageCubeArray", static_cast(34)}, + {"FragmentBarycentricNV", static_cast(5284)}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 245; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupEnumWithTypePrefix(const UnownedStringSlice& str, SpvWord& value) +{ + static const unsigned tableSalt[944] = { + 0, 2, 0, 4, 3, 1, 1, 3, 0, 2, 1, 3, 1, 0, 0, 2, + 0, 1, 1, 7, 0, 0, 1, 0, 2, 0, 0, 0, 3, 1, 1, 0, + 12, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 2, 1, + 0, 5, 0, 3, 5, 4, 1, 0, 0, 8, 3, 0, 1, 0, 1, 8, + 0, 9, 0, 0, 11, 3, 2, 0, 6, 0, 2, 3, 0, 5, 0, 0, + 0, 1, 1, 0, 1, 0, 0, 4, 1, 1, 0, 0, 0, 1, 0, 2, + 6, 0, 0, 0, 1, 6, 2, 1, 1, 0, 0, 5, 0, 1, 3, 1, + 0, 2, 0, 1, 1, 3, 1, 5, 0, 5, 1, 2, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 6, 3, 1, 2, 3, 6, 4, 0, 2, 0, + 1, 1, 2, 4, 4, 0, 1, 0, 1, 1, 1, 0, 0, 0, 4, 1, + 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 9, 0, 1, + 2, 1, 0, 2, 3, 0, 0, 0, 1, 3, 1, 5, 0, 6, 3, 0, + 7, 2, 0, 0, 1, 2, 0, 3, 1, 5, 2, 1, 1, 5, 1, 0, + 1, 0, 4, 0, 3, 8, 0, 6, 0, 0, 0, 2, 3, 3, 7, 1, + 1, 0, 1, 2, 0, 1, 0, 4, 0, 1, 4, 2, 0, 0, 2, 0, + 0, 0, 14, 1, 0, 2, 1, 0, 1, 1, 3, 0, 0, 0, 1, 0, + 3, 0, 4, 1, 0, 0, 1, 0, 0, 0, 4, 6, 1, 0, 0, 0, + 1, 3, 5, 6, 2, 3, 0, 6, 6, 1, 1, 0, 0, 2, 0, 1, + 0, 1, 1, 9, 2, 2, 4, 3, 2, 0, 2, 0, 5, 9, 1, 2, + 1, 2, 2, 0, 1, 1, 0, 0, 3, 2, 0, 0, 1, 1, 0, 3, + 3, 1, 10, 0, 0, 4, 0, 0, 2, 0, 0, 4, 2, 3, 2, 4, + 1, 0, 3, 1, 0, 3, 1, 3, 1, 3, 0, 0, 2, 0, 1, 0, + 0, 1, 0, 2, 2, 0, 0, 7, 1, 1, 8, 0, 1, 6, 0, 2, + 2, 3, 2, 1, 1, 0, 0, 3, 1, 1, 0, 0, 0, 2, 2, 1, + 0, 0, 3, 1, 1, 1, 3, 3, 0, 1, 2, 0, 1, 3, 5, 0, + 0, 2, 2, 1, 8, 1, 12, 0, 2, 2, 17, 4, 0, 1, 1, 1, + 11, 3, 1, 2, 4, 5, 1, 0, 4, 3, 3, 1, 1, 2, 1, 5, + 3, 1, 3, 1, 5, 2, 2, 0, 5, 0, 1, 0, 1, 3, 1, 2, + 2, 0, 0, 2, 5, 0, 0, 2, 8, 2, 8, 0, 3, 1, 0, 4, + 0, 0, 1, 3, 1, 2, 0, 2, 2, 13, 0, 4, 0, 3, 3, 0, + 2, 5, 1, 3, 5, 7, 2, 7, 1, 0, 13, 0, 3, 2, 1, 22, + 0, 3, 2, 4, 0, 1, 2, 5, 0, 2, 0, 2, 0, 5, 0, 0, + 0, 0, 1, 17, 0, 1, 11, 0, 5, 2, 0, 0, 4, 1, 17, 0, + 0, 0, 1, 2, 5, 0, 0, 1, 1, 1, 26, 1, 5, 0, 1, 0, + 1, 2, 0, 5, 5, 12, 1, 11, 17, 1, 2, 5, 0, 3, 11, 0, + 5, 1, 5, 5, 3, 0, 0, 3, 1, 0, 4, 1, 8, 1, 8, 0, + 0, 22, 1, 0, 3, 8, 1, 9, 4, 1, 0, 10, 0, 12, 1, 0, + 11, 0, 0, 3, 42, 4, 0, 2, 0, 1, 4, 0, 11, 1, 4, 8, + 14, 3, 0, 1, 6, 17, 1, 2, 15, 0, 10, 1, 0, 14, 2, 12, + 0, 2, 0, 1, 6, 0, 13, 2, 1, 0, 7, 0, 6, 7, 0, 0, + 14, 1, 7, 3, 2, 0, 1, 0, 7, 0, 1, 2, 0, 22, 0, 6, + 0, 12, 3, 3, 4, 0, 10, 0, 0, 0, 2, 0, 4, 0, 0, 26, + 1, 1, 0, 9, 0, 9, 10, 4, 3, 0, 4, 0, 20, 0, 0, 3, + 10, 4, 14, 13, 10, 0, 15, 1, 0, 21, 1, 0, 22, 2, 3, 0, + 0, 0, 10, 17, 0, 3, 1, 1, 0, 0, 1, 11, 4, 0, 2, 3, + 0, 7, 23, 6, 0, 17, 0, 18, 0, 20, 2, 0, 0, 0, 4, 1, + 0, 0, 1, 0, 0, 4, 5, 0, 4, 1, 7, 0, 3, 3, 1, 5, + 3, 10, 11, 0, 16, 1, 0, 8, 6, 4, 0, 7, 0, 33, 1, 0, + 1, 18, 0, 0, 16, 6, 14, 34, 10, 28, 0, 0, 1, 1, 0, 7, + 4, 0, 2, 1, 1, 5, 0, 0, 2, 0, 31, 41, 0, 9, 10, 0, + 0, 0, 9, 0, 0, 12, 9, 0, 0, 0, 19, 4, 0, 4, 0, 10, + 0, 0, 21, 13, 0, 6, 1, 19, 0, 7, 6, 0, 0, 1, 4, 3, + 0, 16, 0, 8, 32, 8, 0, 9, 0, 9, 10, 0, 2, 0, 10, 20, + 45, 5, 2, 2, 0, 5, 2, 0, 31, 1, 1, 73, 30, 64, 19, 8, + 2, 108, 7, 16, 5, 15, 4, 1, 20, 36, 1, 44, 0, 3, 3, 8, + 0, 0, 0, 10, 32, 30, 0, 41, 0, 0, 29, 3, 0, 0, 15, 100, + 0, 4, 1, 29, 11, 64, 105, 125, 0, 0, 0, 38, 115, 1, 1, 1, + 0, 11, 21, 66, 1, 79, 4, 0, 0, 141, 1, 0, 0, 0, 0, 0, + 530, 0, 8, 31, 3, 1, 0, 13, 0, 0, 6, 286, 14, 16, 134, 259 + }; + + using KV = std::pair; + + static const KV words[944] = + { + {"MemoryAccessMakePointerVisibleKHR", SpvWord{16}}, + {"CapabilityStoragePushConstant16", SpvWord{4435}}, + {"StorageClassTaskPayloadWorkgroupEXT", SpvWord{5402}}, + {"DecorationConduitKernelArgumentINTEL", SpvWord{6175}}, + {"BuiltInRayTminNV", SpvWord{5325}}, + {"MemoryAccessAligned", SpvWord{2}}, + {"ImageOperandsGrad", SpvWord{4}}, + {"CapabilityAtomicFloat32AddEXT", SpvWord{6033}}, + {"BuiltInWorldRayDirectionNV", SpvWord{5322}}, + {"SourceLanguageSYCL", SpvWord{7}}, + {"CapabilityFPGAInvocationPipeliningAttributesINTEL", SpvWord{5916}}, + {"BuiltInFragStencilRefEXT", SpvWord{5014}}, + {"FunctionControlNone", SpvWord{0}}, + {"BuiltInBaryCoordNoPerspNV", SpvWord{5287}}, + {"DecorationUniformId", SpvWord{27}}, + {"BuiltInGlobalLinearId", SpvWord{34}}, + {"DecorationLocation", SpvWord{30}}, + {"ImageFormatR16Snorm", SpvWord{19}}, + {"BuiltInSecondaryPositionNV", SpvWord{5257}}, + {"MemorySemanticsMakeAvailableKHR", SpvWord{8192}}, + {"ImageOperandsMinLod", SpvWord{128}}, + {"Dim1D", SpvWord{0}}, + {"SamplerAddressingModeRepeat", SpvWord{3}}, + {"CapabilityCooperativeMatrixKHR", SpvWord{6022}}, + {"ImageChannelDataTypeSignedInt8", SpvWord{7}}, + {"ImageOperandsNontemporal", SpvWord{16384}}, + {"BuiltInFragSizeEXT", SpvWord{5292}}, + {"FPFastMathModeNSZ", SpvWord{4}}, + {"ExecutionModeStencilRefGreaterFrontAMD", SpvWord{5080}}, + {"DecorationBuiltIn", SpvWord{11}}, + {"ExecutionModeOutputVertices", SpvWord{26}}, + {"DecorationDoublepumpINTEL", SpvWord{5831}}, + {"KernelEnqueueFlagsNoWait", SpvWord{0}}, + {"BuiltInBaryCoordNoPerspCentroidAMD", SpvWord{4993}}, + {"SourceLanguageUnknown", SpvWord{0}}, + {"FragmentShadingRateHorizontal4Pixels", SpvWord{8}}, + {"DecorationGLSLShared", SpvWord{8}}, + {"BuiltInFragCoord", SpvWord{15}}, + {"ImageChannelOrderRGB", SpvWord{4}}, + {"ImageFormatRgb10A2", SpvWord{11}}, + {"FPFastMathModeAllowContractFastINTEL", SpvWord{65536}}, + {"BuiltInTessCoord", SpvWord{13}}, + {"BuiltInLocalInvocationIndex", SpvWord{29}}, + {"ExecutionModeFloatingPointModeIEEEINTEL", SpvWord{5623}}, + {"ImageChannelOrderBGRA", SpvWord{6}}, + {"CapabilityRayCullMaskKHR", SpvWord{6020}}, + {"CapabilityVulkanMemoryModel", SpvWord{5345}}, + {"BuiltInWarpIDARM", SpvWord{4163}}, + {"BuiltInPrimitivePointIndicesEXT", SpvWord{5294}}, + {"ExecutionModeInvocations", SpvWord{0}}, + {"ImageOperandsConstOffset", SpvWord{8}}, + {"ImageFormatRg32f", SpvWord{6}}, + {"CapabilityInputAttachment", SpvWord{40}}, + {"RayFlagsCullNoOpaqueKHR", SpvWord{128}}, + {"CapabilityStorageImageArrayNonUniformIndexing", SpvWord{5309}}, + {"CapabilityIOPipesINTEL", SpvWord{5943}}, + {"ExecutionModeLocalSizeId", SpvWord{38}}, + {"PackedVectorFormatPackedVectorFormat4x8Bit", SpvWord{0}}, + {"AddressingModelPhysical32", SpvWord{1}}, + {"MemoryAccessNone", SpvWord{0}}, + {"ImageFormatRg32i", SpvWord{25}}, + {"BuiltInObjectToWorldKHR", SpvWord{5330}}, + {"DecorationCPacked", SpvWord{10}}, + {"DecorationConstant", SpvWord{22}}, + {"BuiltInVertexId", SpvWord{5}}, + {"ExecutionModelMeshEXT", SpvWord{5365}}, + {"DecorationFuseLoopsInFunctionINTEL", SpvWord{5907}}, + {"CapabilityInt16", SpvWord{22}}, + {"CapabilityFragmentDensityEXT", SpvWord{5291}}, + {"CapabilityGroupNonUniformBallot", SpvWord{64}}, + {"DecorationOffset", SpvWord{35}}, + {"StorageClassHostOnlyINTEL", SpvWord{5937}}, + {"DecorationMediaBlockIOINTEL", SpvWord{6140}}, + {"PackedVectorFormatPackedVectorFormat4x8BitKHR", SpvWord{0}}, + {"MemoryAccessNontemporal", SpvWord{4}}, + {"ExecutionModelRayGenerationKHR", SpvWord{5313}}, + {"DecorationUserSemantic", SpvWord{5635}}, + {"BuiltInFrontFacing", SpvWord{17}}, + {"RayFlagsNoneKHR", SpvWord{0}}, + {"ImageFormatRgba16", SpvWord{10}}, + {"BuiltInCurrentRayTimeNV", SpvWord{5334}}, + {"ExecutionModelCallableNV", SpvWord{5318}}, + {"MemoryModelVulkan", SpvWord{3}}, + {"ExecutionModeInputLines", SpvWord{20}}, + {"CapabilityShaderNonUniformEXT", SpvWord{5301}}, + {"BuiltInFullyCoveredEXT", SpvWord{5264}}, + {"DecorationFlat", SpvWord{14}}, + {"CapabilityImage1D", SpvWord{44}}, + {"StorageClassRayPayloadNV", SpvWord{5338}}, + {"SourceLanguageHERO_C", SpvWord{8}}, + {"CapabilityRuntimeDescriptorArrayEXT", SpvWord{5302}}, + {"CapabilityRayTracingPositionFetchKHR", SpvWord{5336}}, + {"BuiltInObjectRayOriginKHR", SpvWord{5323}}, + {"BuiltInViewportMaskNV", SpvWord{5253}}, + {"DecorationStallEnableINTEL", SpvWord{5905}}, + {"FunctionParameterAttributeZext", SpvWord{0}}, + {"ExecutionModeFloatingPointModeALTINTEL", SpvWord{5622}}, + {"DecorationMaxPrivateCopiesINTEL", SpvWord{5829}}, + {"BuiltInFragmentSizeNV", SpvWord{5292}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR", SpvWord{0}}, + {"DecorationNonUniform", SpvWord{5300}}, + {"CapabilitySampledCubeArray", SpvWord{45}}, + {"DimSubpassData", SpvWord{6}}, + {"CapabilitySignedZeroInfNanPreserve", SpvWord{4466}}, + {"BuiltInPrimitiveIndicesNV", SpvWord{5276}}, + {"ExecutionModeOutputPrimitivesNV", SpvWord{5270}}, + {"CapabilityTileImageStencilReadAccessEXT", SpvWord{4168}}, + {"FPRoundingModeRTZ", SpvWord{1}}, + {"ImageFormatRg8", SpvWord{13}}, + {"CapabilityStorageImageArrayDynamicIndexing", SpvWord{31}}, + {"FPOperationModeALT", SpvWord{1}}, + {"ExecutionModeOutputTrianglesEXT", SpvWord{5298}}, + {"RayFlagsNoOpaqueKHR", SpvWord{2}}, + {"ExecutionModelCallableKHR", SpvWord{5318}}, + {"RayFlagsCullFrontFacingTrianglesKHR", SpvWord{32}}, + {"CapabilityDenormPreserve", SpvWord{4464}}, + {"GroupOperationPartitionedExclusiveScanNV", SpvWord{8}}, + {"CapabilityFragmentBarycentricNV", SpvWord{5284}}, + {"FragmentShadingRateVertical2Pixels", SpvWord{1}}, + {"CapabilitySubgroupAvcMotionEstimationChromaINTEL", SpvWord{5698}}, + {"CapabilityImageBasic", SpvWord{13}}, + {"DecorationIOPipeStorageINTEL", SpvWord{5944}}, + {"StorageClassIncomingRayPayloadKHR", SpvWord{5342}}, + {"CapabilityPipeStorage", SpvWord{60}}, + {"CapabilityStorageBufferArrayNonUniformIndexingEXT", SpvWord{5308}}, + {"ExecutionModeOutputPoints", SpvWord{27}}, + {"DecorationBlock", SpvWord{2}}, + {"ExecutionModeSampleInterlockOrderedEXT", SpvWord{5368}}, + {"DecorationRestrictPointerEXT", SpvWord{5355}}, + {"MemorySemanticsSubgroupMemory", SpvWord{128}}, + {"CapabilityShaderViewportIndexLayerEXT", SpvWord{5254}}, + {"CapabilityMeshShadingNV", SpvWord{5266}}, + {"ExecutionModeVertexOrderCw", SpvWord{4}}, + {"ExecutionModeEarlyFragmentTests", SpvWord{9}}, + {"BuiltInHitTriangleVertexPositionsKHR", SpvWord{5335}}, + {"CapabilityBlockingPipesINTEL", SpvWord{5945}}, + {"ImageChannelOrderR", SpvWord{0}}, + {"ExecutionModeOutputTrianglesNV", SpvWord{5298}}, + {"CapabilityClipDistance", SpvWord{32}}, + {"MemorySemanticsNone", SpvWord{0}}, + {"CapabilityUniformBufferArrayNonUniformIndexingEXT", SpvWord{5306}}, + {"ExecutionModeInputLinesAdjacency", SpvWord{21}}, + {"ExecutionModelMissNV", SpvWord{5317}}, + {"BuiltInSubgroupEqMask", SpvWord{4416}}, + {"FunctionParameterAttributeRuntimeAlignedINTEL", SpvWord{5940}}, + {"CapabilityFPGAMemoryAttributesINTEL", SpvWord{5824}}, + {"ImageChannelOrderRG", SpvWord{2}}, + {"RayFlagsCullBackFacingTrianglesKHR", SpvWord{16}}, + {"BuiltInObjectRayDirectionNV", SpvWord{5324}}, + {"CapabilityCoreBuiltinsARM", SpvWord{4165}}, + {"CapabilityFPGADSPControlINTEL", SpvWord{5908}}, + {"BuiltInNumEnqueuedSubgroups", SpvWord{39}}, + {"DecorationArrayStride", SpvWord{6}}, + {"CapabilityInt64Atomics", SpvWord{12}}, + {"MemoryModelSimple", SpvWord{0}}, + {"ImageFormatRgba16i", SpvWord{22}}, + {"CapabilityDotProductInput4x8BitPackedKHR", SpvWord{6018}}, + {"ExecutionModeEarlyAndLateFragmentTestsAMD", SpvWord{5017}}, + {"BuiltInLayer", SpvWord{9}}, + {"BuiltInBaryCoordSmoothAMD", SpvWord{4995}}, + {"ExecutionModeInitializer", SpvWord{33}}, + {"ImageChannelDataTypeUnormShort555", SpvWord{5}}, + {"FPOperationModeIEEE", SpvWord{0}}, + {"MemoryAccessNonPrivatePointer", SpvWord{32}}, + {"BuiltInLaunchIdNV", SpvWord{5319}}, + {"CapabilityGroupNonUniformArithmetic", SpvWord{63}}, + {"ExecutionModelTessellationControl", SpvWord{1}}, + {"ImageFormatRg16Snorm", SpvWord{17}}, + {"LoopControlMaxIterations", SpvWord{32}}, + {"CapabilityTessellationPointSize", SpvWord{23}}, + {"ExecutionModeNonCoherentDepthAttachmentReadEXT", SpvWord{4170}}, + {"ImageChannelOrderDepthStencil", SpvWord{14}}, + {"ImageOperandsNonPrivateTexelKHR", SpvWord{1024}}, + {"DimRect", SpvWord{4}}, + {"QuantizationModesTRN_ZERO", SpvWord{1}}, + {"CapabilitySampleRateShading", SpvWord{35}}, + {"GroupOperationExclusiveScan", SpvWord{2}}, + {"DecorationCounterBuffer", SpvWord{5634}}, + {"GroupOperationInclusiveScan", SpvWord{1}}, + {"BuiltInLayerPerViewNV", SpvWord{5279}}, + {"ExecutionModeSampleInterlockUnorderedEXT", SpvWord{5369}}, + {"OverflowModesWRAP", SpvWord{0}}, + {"ExecutionModeDerivativeGroupQuadsNV", SpvWord{5289}}, + {"BuiltInHitKindNV", SpvWord{5333}}, + {"BuiltInClipDistance", SpvWord{3}}, + {"ExecutionModeDepthReplacing", SpvWord{12}}, + {"CapabilityPerViewAttributesNV", SpvWord{5260}}, + {"DecorationUserTypeGOOGLE", SpvWord{5636}}, + {"ExecutionModePixelInterlockOrderedEXT", SpvWord{5366}}, + {"CapabilitySampledBuffer", SpvWord{46}}, + {"DecorationBinding", SpvWord{33}}, + {"BuiltInHitTNV", SpvWord{5332}}, + {"CapabilityUnstructuredLoopControlsINTEL", SpvWord{5886}}, + {"ExecutionModeSpacingFractionalOdd", SpvWord{3}}, + {"SourceLanguageCPP_for_OpenCL", SpvWord{6}}, + {"ExecutionModeShadingRateInterlockUnorderedEXT", SpvWord{5371}}, + {"RayFlagsSkipAABBsKHR", SpvWord{512}}, + {"ImageChannelDataTypeSignedInt16", SpvWord{8}}, + {"CapabilityOptNoneINTEL", SpvWord{6094}}, + {"DecorationCoherent", SpvWord{23}}, + {"ExecutionModelMissKHR", SpvWord{5317}}, + {"BuiltInInstanceIndex", SpvWord{43}}, + {"ImageFormatR8", SpvWord{15}}, + {"SourceLanguageHLSL", SpvWord{5}}, + {"CapabilityGroups", SpvWord{18}}, + {"CapabilitySampledImageArrayNonUniformIndexingEXT", SpvWord{5307}}, + {"CapabilityDemoteToHelperInvocationEXT", SpvWord{5379}}, + {"CapabilityStorageTexelBufferArrayDynamicIndexingEXT", SpvWord{5305}}, + {"ImageChannelDataTypeUnormInt8", SpvWord{2}}, + {"CapabilityImageFootprintNV", SpvWord{5282}}, + {"ExecutionModeNamedBarrierCountINTEL", SpvWord{6417}}, + {"StorageClassCallableDataNV", SpvWord{5328}}, + {"CapabilityImageCubeArray", SpvWord{34}}, + {"BuiltInBaryCoordSmoothSampleAMD", SpvWord{4997}}, + {"ImageOperandsMakeTexelVisibleKHR", SpvWord{512}}, + {"DecorationPerViewNV", SpvWord{5272}}, + {"OverflowModesSAT_SYM", SpvWord{3}}, + {"CapabilityAddresses", SpvWord{4}}, + {"CapabilityFPGABufferLocationINTEL", SpvWord{5920}}, + {"CapabilityFunctionPointersINTEL", SpvWord{5603}}, + {"CapabilityMatrix", SpvWord{0}}, + {"CooperativeMatrixOperandsSaturatingAccumulationKHR", SpvWord{16}}, + {"ImageChannelOrderRGx", SpvWord{11}}, + {"BuiltInCullDistance", SpvWord{4}}, + {"DecorationFPFastMathMode", SpvWord{40}}, + {"MemorySemanticsOutputMemory", SpvWord{4096}}, + {"CapabilitySampleMaskOverrideCoverageNV", SpvWord{5249}}, + {"CapabilityUniformAndStorageBuffer16BitAccess", SpvWord{4434}}, + {"MemoryAccessMakePointerAvailable", SpvWord{8}}, + {"DecorationVectorComputeVariableINTEL", SpvWord{5624}}, + {"BuiltInObjectRayDirectionKHR", SpvWord{5324}}, + {"DecorationFunctionDenormModeINTEL", SpvWord{5823}}, + {"DecorationAliased", SpvWord{20}}, + {"CapabilityCullDistance", SpvWord{33}}, + {"CapabilityIndirectReferencesINTEL", SpvWord{5604}}, + {"DecorationBoundSamplerNV", SpvWord{5400}}, + {"BuiltInNumWorkgroups", SpvWord{24}}, + {"BuiltInFragDepth", SpvWord{22}}, + {"CapabilityGroupNonUniform", SpvWord{61}}, + {"BuiltInSubgroupLeMaskKHR", SpvWord{4419}}, + {"BuiltInTessLevelOuter", SpvWord{11}}, + {"ExecutionModeVecTypeHint", SpvWord{30}}, + {"ExecutionModePixelCenterInteger", SpvWord{6}}, + {"BuiltInLaunchIdKHR", SpvWord{5319}}, + {"QuantizationModesRND_CONV", SpvWord{6}}, + {"StorageClassStorageBuffer", SpvWord{12}}, + {"CapabilityLongConstantCompositeINTEL", SpvWord{6089}}, + {"MemorySemanticsSequentiallyConsistent", SpvWord{16}}, + {"DecorationInvariant", SpvWord{18}}, + {"ExecutionModeDepthGreater", SpvWord{14}}, + {"ImageFormatRg16ui", SpvWord{36}}, + {"ImageChannelOrdersRGB", SpvWord{15}}, + {"BuiltInMeshViewCountNV", SpvWord{5280}}, + {"MemoryAccessVolatile", SpvWord{1}}, + {"CapabilityShaderViewportIndex", SpvWord{70}}, + {"ExecutionModeInputTrianglesAdjacency", SpvWord{23}}, + {"ImageFormatR11fG11fB10f", SpvWord{8}}, + {"ImageOperandsSignExtend", SpvWord{4096}}, + {"CapabilityDotProductInputAll", SpvWord{6016}}, + {"CapabilityDeviceGroup", SpvWord{4437}}, + {"MemorySemanticsMakeAvailable", SpvWord{8192}}, + {"ExecutionModeSpacingEqual", SpvWord{1}}, + {"ExecutionModeStencilRefGreaterBackAMD", SpvWord{5083}}, + {"LoopControlMaxConcurrencyINTEL", SpvWord{131072}}, + {"DecorationDontStaticallyCoalesceINTEL", SpvWord{5901}}, + {"DecorationMaxReplicatesINTEL", SpvWord{5832}}, + {"CapabilityUniformDecoration", SpvWord{71}}, + {"LoopControlSpeculatedIterationsINTEL", SpvWord{4194304}}, + {"CapabilityImageGatherExtended", SpvWord{25}}, + {"ImageChannelOrderLuminance", SpvWord{9}}, + {"DecorationMaxConcurrencyINTEL", SpvWord{5918}}, + {"ExecutionModeOutputPrimitivesEXT", SpvWord{5270}}, + {"ImageFormatR8Snorm", SpvWord{20}}, + {"CapabilitySampleMaskPostDepthCoverage", SpvWord{4447}}, + {"MemorySemanticsAtomicCounterMemory", SpvWord{1024}}, + {"CapabilityExpectAssumeKHR", SpvWord{5629}}, + {"BuiltInInvocationsPerPixelNV", SpvWord{5293}}, + {"CapabilityAtomicStorageOps", SpvWord{4445}}, + {"DecorationAlignmentId", SpvWord{46}}, + {"ExecutionModelMeshNV", SpvWord{5268}}, + {"BuiltInSubgroupGtMask", SpvWord{4418}}, + {"DecorationSpecId", SpvWord{1}}, + {"CapabilityBFloat16ConversionINTEL", SpvWord{6115}}, + {"BuiltInWarpsPerSMNV", SpvWord{5374}}, + {"StorageClassAtomicCounter", SpvWord{10}}, + {"DecorationPipelineEnableINTEL", SpvWord{5919}}, + {"RayFlagsOpaqueKHR", SpvWord{1}}, + {"CapabilitySubgroupBufferBlockIOINTEL", SpvWord{5569}}, + {"ExecutionModelGLCompute", SpvWord{5}}, + {"DecorationFuncParamAttr", SpvWord{38}}, + {"StorageClassIncomingRayPayloadNV", SpvWord{5342}}, + {"ExecutionModeSubgroupSize", SpvWord{35}}, + {"DecorationNoPerspective", SpvWord{13}}, + {"DecorationBoundImageNV", SpvWord{5401}}, + {"CapabilityStorageImageReadWithoutFormat", SpvWord{55}}, + {"BuiltInRayGeometryIndexKHR", SpvWord{5352}}, + {"BuiltInShadingRateKHR", SpvWord{4444}}, + {"QuantizationModesTRN", SpvWord{0}}, + {"CapabilityShaderViewportMaskNV", SpvWord{5255}}, + {"BuiltInCullDistancePerViewNV", SpvWord{5278}}, + {"ExecutionModelTessellationEvaluation", SpvWord{2}}, + {"ImageOperandsVolatileTexelKHR", SpvWord{2048}}, + {"CapabilityGroupNonUniformShuffleRelative", SpvWord{66}}, + {"DecorationRestrict", SpvWord{19}}, + {"ExecutionModelGeometry", SpvWord{3}}, + {"CapabilitySubgroupVoteKHR", SpvWord{4431}}, + {"CapabilityStencilExportEXT", SpvWord{5013}}, + {"DecorationPerVertexKHR", SpvWord{5285}}, + {"StorageClassHitAttributeNV", SpvWord{5339}}, + {"CapabilityFragmentShaderShadingRateInterlockEXT", SpvWord{5372}}, + {"Dim3D", SpvWord{2}}, + {"CapabilitySampledImageArrayNonUniformIndexing", SpvWord{5307}}, + {"StorageClassIncomingCallableDataKHR", SpvWord{5329}}, + {"CapabilityTextureBoxFilterQCOM", SpvWord{4485}}, + {"CooperativeMatrixOperandsMatrixBSignedComponentsKHR", SpvWord{2}}, + {"CapabilityInputAttachmentArrayNonUniformIndexing", SpvWord{5310}}, + {"ImageFormatR64i", SpvWord{41}}, + {"CapabilityFPGAClusterAttributesINTEL", SpvWord{5904}}, + {"KernelEnqueueFlagsWaitWorkGroup", SpvWord{2}}, + {"DecorationHlslSemanticGOOGLE", SpvWord{5635}}, + {"ExecutionModeTriangles", SpvWord{22}}, + {"SamplerAddressingModeNone", SpvWord{0}}, + {"LoopControlMaxInterleavingINTEL", SpvWord{2097152}}, + {"CapabilityVectorComputeINTEL", SpvWord{5617}}, + {"DecorationBufferLocationINTEL", SpvWord{5921}}, + {"CapabilityShaderViewportIndexLayerNV", SpvWord{5254}}, + {"RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR", SpvWord{0}}, + {"BuiltInLaunchSizeKHR", SpvWord{5320}}, + {"BuiltInIncomingRayFlagsKHR", SpvWord{5351}}, + {"CooperativeMatrixLayoutRowMajorKHR", SpvWord{0}}, + {"StorageClassPhysicalStorageBuffer", SpvWord{5349}}, + {"DecorationMatrixStride", SpvWord{7}}, + {"ImageFormatRgba16Snorm", SpvWord{16}}, + {"DecorationCacheSizeINTEL", SpvWord{5900}}, + {"BuiltInWorldToObjectKHR", SpvWord{5331}}, + {"AccessQualifierWriteOnly", SpvWord{1}}, + {"DecorationNonReadable", SpvWord{25}}, + {"CapabilityRoundToInfinityINTEL", SpvWord{5582}}, + {"ImageFormatRgba32f", SpvWord{1}}, + {"CapabilityFPMaxErrorINTEL", SpvWord{6169}}, + {"ImageChannelOrderRGBx", SpvWord{12}}, + {"CapabilitySparseResidency", SpvWord{41}}, + {"DecorationMaxByteOffset", SpvWord{45}}, + {"CapabilityStorageUniform16", SpvWord{4434}}, + {"CapabilityStorageImageMultisample", SpvWord{27}}, + {"DecorationBurstCoalesceINTEL", SpvWord{5899}}, + {"BuiltInBaryCoordNoPerspAMD", SpvWord{4992}}, + {"ImageOperandsOffsets", SpvWord{65536}}, + {"LoopControlDependencyArrayINTEL", SpvWord{262144}}, + {"CapabilityShadingRateNV", SpvWord{5291}}, + {"LoopControlPipelineEnableINTEL", SpvWord{524288}}, + {"CapabilityFragmentMaskAMD", SpvWord{5010}}, + {"BuiltInCoreMaxIDARM", SpvWord{4162}}, + {"CapabilityImageGatherBiasLodAMD", SpvWord{5009}}, + {"CapabilityRuntimeAlignedAttributeINTEL", SpvWord{5939}}, + {"AddressingModelLogical", SpvWord{0}}, + {"BuiltInHelperInvocation", SpvWord{23}}, + {"ScopeShaderCallKHR", SpvWord{6}}, + {"CapabilityVariableLengthArrayINTEL", SpvWord{5817}}, + {"ExecutionModeRegisterMapInterfaceINTEL", SpvWord{6160}}, + {"DecorationRegisterINTEL", SpvWord{5825}}, + {"CooperativeMatrixLayoutColumnMajorKHR", SpvWord{1}}, + {"DecorationInitiationIntervalINTEL", SpvWord{5917}}, + {"CapabilitySubgroupBallotKHR", SpvWord{4423}}, + {"MemoryAccessMakePointerVisible", SpvWord{16}}, + {"ImageChannelOrderA", SpvWord{1}}, + {"CapabilityFPGAArgumentInterfacesINTEL", SpvWord{6174}}, + {"DecorationBufferBlock", SpvWord{3}}, + {"CapabilityDerivativeControl", SpvWord{51}}, + {"FPFastMathModeFast", SpvWord{16}}, + {"SamplerFilterModeNearest", SpvWord{0}}, + {"CapabilityVulkanMemoryModelKHR", SpvWord{5345}}, + {"ImageChannelDataTypeHalfFloat", SpvWord{13}}, + {"BuiltInSampleMask", SpvWord{20}}, + {"CapabilityTextureSampleWeightedQCOM", SpvWord{4484}}, + {"DecorationReferencedIndirectlyINTEL", SpvWord{5602}}, + {"ExecutionModeStencilRefLessFrontAMD", SpvWord{5081}}, + {"DecorationBankwidthINTEL", SpvWord{5828}}, + {"ImageChannelDataTypeSignedInt32", SpvWord{9}}, + {"StorageClassShaderRecordBufferKHR", SpvWord{5343}}, + {"ExecutionModeInputPoints", SpvWord{19}}, + {"CapabilityImageMipmap", SpvWord{15}}, + {"CapabilityVariablePointers", SpvWord{4442}}, + {"CapabilityDotProductInputAllKHR", SpvWord{6016}}, + {"DecorationSaturatedConversion", SpvWord{28}}, + {"QuantizationModesRND_CONV_ODD", SpvWord{7}}, + {"MemorySemanticsAcquireRelease", SpvWord{8}}, + {"CapabilityMinLod", SpvWord{42}}, + {"BuiltInGlobalInvocationId", SpvWord{28}}, + {"DecorationFPRoundingMode", SpvWord{39}}, + {"ScopeDevice", SpvWord{1}}, + {"ImageFormatRg16i", SpvWord{26}}, + {"MemorySemanticsImageMemory", SpvWord{2048}}, + {"CapabilityAtomicFloat16MinMaxEXT", SpvWord{5616}}, + {"ExecutionModeDenormFlushToZero", SpvWord{4460}}, + {"BuiltInEnqueuedWorkgroupSize", SpvWord{32}}, + {"BuiltInSubgroupGeMask", SpvWord{4417}}, + {"ImageChannelOrderRGBA", SpvWord{5}}, + {"ImageOperandsOffset", SpvWord{16}}, + {"FunctionControlConst", SpvWord{8}}, + {"MemorySemanticsWorkgroupMemory", SpvWord{256}}, + {"ImageFormatRgba16ui", SpvWord{31}}, + {"CapabilityDemoteToHelperInvocation", SpvWord{5379}}, + {"BuiltInBaryCoordSmoothCentroidAMD", SpvWord{4996}}, + {"CapabilityRayQueryProvisionalKHR", SpvWord{4471}}, + {"CooperativeMatrixUseMatrixAccumulatorKHR", SpvWord{2}}, + {"CapabilityDotProductKHR", SpvWord{6019}}, + {"ImageChannelDataTypeUnsignedIntRaw12EXT", SpvWord{20}}, + {"BuiltInSubgroupLeMask", SpvWord{4419}}, + {"AddressingModelPhysical64", SpvWord{2}}, + {"MemoryAccessAliasScopeINTELMask", SpvWord{65536}}, + {"MemorySemanticsVolatile", SpvWord{32768}}, + {"FragmentShadingRateVertical4Pixels", SpvWord{2}}, + {"CapabilityDotProductInput4x8BitPacked", SpvWord{6018}}, + {"CapabilityGroupNonUniformShuffle", SpvWord{65}}, + {"CapabilitySubgroupAvcMotionEstimationIntraINTEL", SpvWord{5697}}, + {"DecorationRelaxedPrecision", SpvWord{0}}, + {"BuiltInBaryCoordPullModelAMD", SpvWord{4998}}, + {"ExecutionModelAnyHitKHR", SpvWord{5315}}, + {"CapabilityInputAttachmentArrayDynamicIndexingEXT", SpvWord{5303}}, + {"LoopControlIterationMultiple", SpvWord{64}}, + {"ScopeQueueFamilyKHR", SpvWord{5}}, + {"RayFlagsSkipClosestHitShaderKHR", SpvWord{8}}, + {"ExecutionModeLocalSizeHint", SpvWord{18}}, + {"SourceLanguageGLSL", SpvWord{2}}, + {"StorageClassWorkgroup", SpvWord{4}}, + {"MemoryModelGLSL450", SpvWord{1}}, + {"BuiltInCoreCountARM", SpvWord{4161}}, + {"CapabilityIntegerFunctions2INTEL", SpvWord{5584}}, + {"DecorationVolatile", SpvWord{21}}, + {"MemorySemanticsRelease", SpvWord{4}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR", SpvWord{2}}, + {"LoopControlMinIterations", SpvWord{16}}, + {"CapabilityUniformTexelBufferArrayNonUniformIndexing", SpvWord{5311}}, + {"KernelEnqueueFlagsWaitKernel", SpvWord{1}}, + {"ExecutionModeMaxWorkDimINTEL", SpvWord{5894}}, + {"CapabilityFloatingPointModeINTEL", SpvWord{5583}}, + {"BuiltInGlobalSize", SpvWord{31}}, + {"CapabilityGeometryStreams", SpvWord{54}}, + {"FunctionParameterAttributeSext", SpvWord{1}}, + {"CapabilityFragmentBarycentricKHR", SpvWord{5284}}, + {"StorageClassPhysicalStorageBufferEXT", SpvWord{5349}}, + {"CapabilityComputeDerivativeGroupQuadsNV", SpvWord{5288}}, + {"ExecutionModelFragment", SpvWord{4}}, + {"CapabilityStorageBufferArrayDynamicIndexing", SpvWord{30}}, + {"ScopeWorkgroup", SpvWord{2}}, + {"DecorationSIMTCallINTEL", SpvWord{5599}}, + {"MemoryAccessMakePointerAvailableKHR", SpvWord{8}}, + {"DecorationRegisterMapKernelArgumentINTEL", SpvWord{6176}}, + {"ImageChannelOrderDepth", SpvWord{13}}, + {"CapabilityStorageImageArrayNonUniformIndexingEXT", SpvWord{5309}}, + {"CapabilityPipes", SpvWord{17}}, + {"ExecutionModeSharedLocalMemorySizeINTEL", SpvWord{5618}}, + {"DecorationVectorComputeFunctionINTEL", SpvWord{5626}}, + {"CapabilityLiteralSampler", SpvWord{20}}, + {"CapabilityWorkgroupMemoryExplicitLayoutKHR", SpvWord{4428}}, + {"DecorationRowMajor", SpvWord{4}}, + {"ImageFormatRgba8i", SpvWord{23}}, + {"ImageFormatRgba32ui", SpvWord{30}}, + {"AccessQualifierReadOnly", SpvWord{0}}, + {"BuiltInPrimitiveShadingRateKHR", SpvWord{4432}}, + {"SamplerAddressingModeClamp", SpvWord{2}}, + {"FunctionControlPure", SpvWord{4}}, + {"GroupOperationPartitionedReduceNV", SpvWord{6}}, + {"SelectionControlNone", SpvWord{0}}, + {"ExecutionModePixelInterlockUnorderedEXT", SpvWord{5367}}, + {"ExecutionModeLocalSizeHintId", SpvWord{39}}, + {"MemoryModelOpenCL", SpvWord{2}}, + {"FragmentShadingRateHorizontal2Pixels", SpvWord{4}}, + {"CapabilityMultiViewport", SpvWord{57}}, + {"CooperativeMatrixUseMatrixBKHR", SpvWord{1}}, + {"DecorationAlignment", SpvWord{44}}, + {"QuantizationModesRND_MIN_INF", SpvWord{5}}, + {"BuiltInSMCountNV", SpvWord{5375}}, + {"DecorationPerVertexNV", SpvWord{5285}}, + {"CapabilityVariablePointersStorageBuffer", SpvWord{4441}}, + {"BuiltInBaseInstance", SpvWord{4425}}, + {"DecorationAliasedPointer", SpvWord{5356}}, + {"CapabilitySubgroupShuffleINTEL", SpvWord{5568}}, + {"CapabilityRayQueryPositionFetchKHR", SpvWord{5391}}, + {"CapabilityTextureBlockMatchQCOM", SpvWord{4486}}, + {"ExecutionModeSubgroupsPerWorkgroup", SpvWord{36}}, + {"MemorySemanticsOutputMemoryKHR", SpvWord{4096}}, + {"ExecutionModeQuads", SpvWord{24}}, + {"ImageChannelDataTypeUnormInt101010", SpvWord{6}}, + {"ImageFormatRgba8", SpvWord{4}}, + {"BuiltInWorkgroupSize", SpvWord{25}}, + {"ExecutionModeNoGlobalOffsetINTEL", SpvWord{5895}}, + {"DecorationForcePow2DepthINTEL", SpvWord{5836}}, + {"BuiltInGlobalOffset", SpvWord{33}}, + {"BuiltInBaryCoordKHR", SpvWord{5286}}, + {"LoopControlInitiationIntervalINTEL", SpvWord{65536}}, + {"BuiltInWorldToObjectNV", SpvWord{5331}}, + {"ExecutionModeSchedulerTargetFmaxMhzINTEL", SpvWord{5903}}, + {"CapabilityStorageBuffer8BitAccess", SpvWord{4448}}, + {"CapabilityLinkage", SpvWord{5}}, + {"SourceLanguageOpenCL_C", SpvWord{3}}, + {"DecorationBankBitsINTEL", SpvWord{5835}}, + {"SamplerAddressingModeRepeatMirrored", SpvWord{4}}, + {"ExecutionModeDenormPreserve", SpvWord{4459}}, + {"ExecutionModeOutputTriangleStrip", SpvWord{29}}, + {"ImageFormatR16f", SpvWord{9}}, + {"DecorationFuncParamIOKindINTEL", SpvWord{5625}}, + {"ExecutionModelIntersectionNV", SpvWord{5314}}, + {"RayQueryIntersectionRayQueryCommittedIntersectionKHR", SpvWord{1}}, + {"BuiltInPrimitiveTriangleIndicesEXT", SpvWord{5296}}, + {"BuiltInPrimitiveId", SpvWord{7}}, + {"ImageOperandsLod", SpvWord{2}}, + {"AccessQualifierReadWrite", SpvWord{2}}, + {"CapabilitySplitBarrierINTEL", SpvWord{6141}}, + {"CapabilityGroupNonUniformQuad", SpvWord{68}}, + {"DecorationCentroid", SpvWord{16}}, + {"BuiltInSubgroupId", SpvWord{40}}, + {"LoopControlPeelCount", SpvWord{128}}, + {"LinkageTypeImport", SpvWord{1}}, + {"ExecutionModeRoundingModeRTPINTEL", SpvWord{5620}}, + {"ScopeQueueFamily", SpvWord{5}}, + {"DecorationSecondaryViewportRelativeNV", SpvWord{5256}}, + {"CapabilityStoragePushConstant8", SpvWord{4450}}, + {"BuiltInInvocationId", SpvWord{8}}, + {"MemoryModelVulkanKHR", SpvWord{3}}, + {"ExecutionModelVertex", SpvWord{0}}, + {"DecorationXfbBuffer", SpvWord{36}}, + {"DecorationSingleElementVectorINTEL", SpvWord{6085}}, + {"CapabilityInterpolationFunction", SpvWord{52}}, + {"CapabilityFPGAKernelAttributesv2INTEL", SpvWord{6161}}, + {"ImageFormatR32f", SpvWord{3}}, + {"CapabilityFPGARegINTEL", SpvWord{5948}}, + {"LoopControlNone", SpvWord{0}}, + {"BuiltInSubgroupLtMask", SpvWord{4420}}, + {"FunctionParameterAttributeByVal", SpvWord{2}}, + {"DecorationNumbanksINTEL", SpvWord{5827}}, + {"BuiltInInstanceId", SpvWord{6}}, + {"ImageChannelDataTypeUnormInt24", SpvWord{15}}, + {"ScopeSubgroup", SpvWord{3}}, + {"ExecutionModeStencilRefUnchangedBackAMD", SpvWord{5082}}, + {"LoopControlNoFusionINTEL", SpvWord{8388608}}, + {"CapabilityMeshShadingEXT", SpvWord{5283}}, + {"DecorationIndex", SpvWord{32}}, + {"ImageOperandsBias", SpvWord{1}}, + {"LinkageTypeExport", SpvWord{0}}, + {"ExecutionModeOriginUpperLeft", SpvWord{7}}, + {"BuiltInCoreIDARM", SpvWord{4160}}, + {"BuiltInHitKindKHR", SpvWord{5333}}, + {"BuiltInSubgroupGtMaskKHR", SpvWord{4418}}, + {"CapabilityFPGALatencyControlINTEL", SpvWord{6171}}, + {"SourceLanguageOpenCL_CPP", SpvWord{4}}, + {"ImageFormatRg8Snorm", SpvWord{18}}, + {"BuiltInRayTmaxNV", SpvWord{5326}}, + {"CapabilityTransformFeedback", SpvWord{53}}, + {"FPFastMathModeAllowRecip", SpvWord{8}}, + {"SourceLanguageWGSL", SpvWord{10}}, + {"CooperativeMatrixOperandsMatrixCSignedComponentsKHR", SpvWord{4}}, + {"BuiltInBaryCoordNV", SpvWord{5286}}, + {"ImageChannelDataTypeUnormShort565", SpvWord{4}}, + {"DecorationRestrictPointer", SpvWord{5355}}, + {"CapabilityRayQueryKHR", SpvWord{4472}}, + {"ExecutionModelClosestHitKHR", SpvWord{5316}}, + {"CapabilityArbitraryPrecisionFixedPointINTEL", SpvWord{5922}}, + {"CapabilityRayTracingOpacityMicromapEXT", SpvWord{5381}}, + {"DecorationPerPrimitiveNV", SpvWord{5271}}, + {"DecorationMathOpDSPModeINTEL", SpvWord{5909}}, + {"ImageOperandsVolatileTexel", SpvWord{2048}}, + {"BuiltInTessLevelInner", SpvWord{12}}, + {"ExecutionModePostDepthCoverage", SpvWord{4446}}, + {"CapabilityLoopFuseINTEL", SpvWord{5906}}, + {"CapabilityFunctionFloatControlINTEL", SpvWord{5821}}, + {"CapabilityPhysicalStorageBufferAddresses", SpvWord{5347}}, + {"ImageChannelOrderARGB", SpvWord{7}}, + {"StorageClassIncomingCallableDataNV", SpvWord{5329}}, + {"DecorationFunctionRoundingModeINTEL", SpvWord{5822}}, + {"ExecutionModeDepthUnchanged", SpvWord{16}}, + {"ImageChannelOrdersRGBx", SpvWord{16}}, + {"DecorationMemoryINTEL", SpvWord{5826}}, + {"CapabilityTileImageColorReadAccessEXT", SpvWord{4166}}, + {"CooperativeMatrixOperandsMatrixASignedComponentsKHR", SpvWord{1}}, + {"StorageClassFunction", SpvWord{7}}, + {"CapabilityGenericPointer", SpvWord{38}}, + {"CapabilityFPGAKernelAttributesINTEL", SpvWord{5897}}, + {"CapabilitySubgroupImageMediaBlockIOINTEL", SpvWord{5579}}, + {"CapabilityVector16", SpvWord{7}}, + {"ExecutionModeSubgroupUniformControlFlowKHR", SpvWord{4421}}, + {"CapabilityKernel", SpvWord{6}}, + {"BuiltInWorkDim", SpvWord{30}}, + {"CapabilityPhysicalStorageBufferAddressesEXT", SpvWord{5347}}, + {"SamplerAddressingModeClampToEdge", SpvWord{1}}, + {"DecorationMMHostInterfaceAddressWidthINTEL", SpvWord{6177}}, + {"CapabilityGroupNonUniformVote", SpvWord{62}}, + {"ImageFormatRgb10a2ui", SpvWord{34}}, + {"DecorationNonUniformEXT", SpvWord{5300}}, + {"CooperativeMatrixOperandsNoneKHR", SpvWord{0}}, + {"CapabilityShaderClockKHR", SpvWord{5055}}, + {"MemorySemanticsUniformMemory", SpvWord{64}}, + {"DecorationSideEffectsINTEL", SpvWord{5608}}, + {"StorageClassShaderRecordBufferNV", SpvWord{5343}}, + {"CapabilityShaderSMBuiltinsNV", SpvWord{5373}}, + {"CapabilityAtomicFloat64MinMaxEXT", SpvWord{5613}}, + {"SourceLanguageESSL", SpvWord{1}}, + {"DecorationMMHostInterfaceMaxBurstINTEL", SpvWord{6181}}, + {"DecorationMaxByteOffsetId", SpvWord{47}}, + {"ImageOperandsMakeTexelAvailable", SpvWord{256}}, + {"CapabilityImageBuffer", SpvWord{47}}, + {"CapabilityStorageTexelBufferArrayNonUniformIndexingEXT", SpvWord{5312}}, + {"BuiltInInstanceCustomIndexNV", SpvWord{5327}}, + {"ExecutionModeDepthLess", SpvWord{15}}, + {"ImageFormatR8ui", SpvWord{39}}, + {"GroupOperationReduce", SpvWord{0}}, + {"CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR", SpvWord{4430}}, + {"CapabilityInputAttachmentArrayDynamicIndexing", SpvWord{5303}}, + {"LoopControlLoopCoalesceINTEL", SpvWord{1048576}}, + {"FunctionParameterAttributeNoReadWrite", SpvWord{7}}, + {"CapabilityAtomicStorage", SpvWord{21}}, + {"DecorationSinglepumpINTEL", SpvWord{5830}}, + {"ExecutionModeLocalSize", SpvWord{17}}, + {"SamplerFilterModeLinear", SpvWord{1}}, + {"DecorationGLSLPacked", SpvWord{9}}, + {"SelectionControlDontFlatten", SpvWord{2}}, + {"ExecutionModelClosestHitNV", SpvWord{5316}}, + {"DecorationBlockMatchTextureQCOM", SpvWord{4488}}, + {"FunctionParameterAttributeNoAlias", SpvWord{4}}, + {"ImageFormatRg8ui", SpvWord{37}}, + {"CapabilityArbitraryPrecisionIntegersINTEL", SpvWord{5844}}, + {"LoopControlPartialCount", SpvWord{256}}, + {"CapabilityImageQuery", SpvWord{50}}, + {"StorageClassTileImageEXT", SpvWord{4172}}, + {"ImageFormatRgba16f", SpvWord{2}}, + {"KernelProfilingInfoCmdExecTime", SpvWord{1}}, + {"DecorationNoUnsignedWrap", SpvWord{4470}}, + {"ExecutionModeOutputLinesNV", SpvWord{5269}}, + {"BuiltInWarpIDNV", SpvWord{5376}}, + {"BuiltInSubgroupGeMaskKHR", SpvWord{4417}}, + {"CapabilityNamedBarrier", SpvWord{59}}, + {"CapabilityDotProductInput4x8BitKHR", SpvWord{6017}}, + {"BuiltInNumSubgroups", SpvWord{38}}, + {"CapabilityStorageBufferArrayNonUniformIndexing", SpvWord{5308}}, + {"CapabilityRayTracingKHR", SpvWord{4479}}, + {"ImageChannelDataTypeUnsignedIntRaw10EXT", SpvWord{19}}, + {"QuantizationModesRND_INF", SpvWord{4}}, + {"ExecutionModeSignedZeroInfNanPreserve", SpvWord{4461}}, + {"CapabilityDotProduct", SpvWord{6019}}, + {"CapabilityAtomicFloat32MinMaxEXT", SpvWord{5612}}, + {"FPFastMathModeAllowReassocINTEL", SpvWord{131072}}, + {"MemorySemanticsCrossWorkgroupMemory", SpvWord{512}}, + {"OverflowModesSAT", SpvWord{1}}, + {"CapabilityFPGALoopControlsINTEL", SpvWord{5888}}, + {"DecorationStableKernelArgumentINTEL", SpvWord{6183}}, + {"CapabilityBindlessTextureNV", SpvWord{5390}}, + {"ImageFormatR32i", SpvWord{24}}, + {"DecorationComponent", SpvWord{31}}, + {"StorageClassHitObjectAttributeNV", SpvWord{5385}}, + {"SelectionControlFlatten", SpvWord{1}}, + {"DecorationStackCallINTEL", SpvWord{5627}}, + {"CapabilityMemoryAccessAliasingINTEL", SpvWord{5910}}, + {"ImageFormatR64ui", SpvWord{40}}, + {"StorageClassDeviceOnlyINTEL", SpvWord{5936}}, + {"DecorationVectorComputeCallableFunctionINTEL", SpvWord{6087}}, + {"BuiltInViewportMaskPerViewNV", SpvWord{5262}}, + {"BuiltInRayTmaxKHR", SpvWord{5326}}, + {"DecorationPatch", SpvWord{15}}, + {"CapabilityGeometry", SpvWord{2}}, + {"ExecutionModeFinalizer", SpvWord{34}}, + {"ImageChannelOrderABGR", SpvWord{19}}, + {"ImageOperandsSample", SpvWord{64}}, + {"ExecutionModeSpacingFractionalEven", SpvWord{2}}, + {"ImageChannelDataTypeUnsignedInt8", SpvWord{10}}, + {"DecorationOverrideCoverageNV", SpvWord{5248}}, + {"FunctionParameterAttributeNoCapture", SpvWord{5}}, + {"ImageFormatRgba8ui", SpvWord{32}}, + {"CapabilityFragmentShaderPixelInterlockEXT", SpvWord{5378}}, + {"FunctionControlDontInline", SpvWord{2}}, + {"DecorationWeightTextureQCOM", SpvWord{4487}}, + {"CapabilityShaderInvocationReorderNV", SpvWord{5383}}, + {"DecorationExplicitInterpAMD", SpvWord{4999}}, + {"CapabilityDeviceEnqueue", SpvWord{19}}, + {"CapabilityFloat16", SpvWord{9}}, + {"CapabilityRayTracingNV", SpvWord{5340}}, + {"StorageClassCodeSectionINTEL", SpvWord{5605}}, + {"BuiltInPatchVertices", SpvWord{14}}, + {"DecorationBindlessSamplerNV", SpvWord{5398}}, + {"RayFlagsCullOpaqueKHR", SpvWord{64}}, + {"CapabilityStorageBuffer16BitAccess", SpvWord{4433}}, + {"ExecutionModelTaskEXT", SpvWord{5364}}, + {"ExecutionModeStreamingInterfaceINTEL", SpvWord{6154}}, + {"BuiltInClipDistancePerViewNV", SpvWord{5277}}, + {"CapabilitySampledRect", SpvWord{37}}, + {"CapabilityGroupNonUniformPartitionedNV", SpvWord{5297}}, + {"BuiltInWorldRayDirectionKHR", SpvWord{5322}}, + {"ExecutionModelRayGenerationNV", SpvWord{5313}}, + {"BuiltInWorldRayOriginKHR", SpvWord{5321}}, + {"ImageChannelDataTypeSnormInt8", SpvWord{0}}, + {"BuiltInSecondaryViewportMaskNV", SpvWord{5258}}, + {"DecorationMergeINTEL", SpvWord{5834}}, + {"FunctionParameterAttributeNoWrite", SpvWord{6}}, + {"DecorationFPMaxErrorDecorationINTEL", SpvWord{6170}}, + {"ExecutionModeOutputLinesEXT", SpvWord{5269}}, + {"DecorationDescriptorSet", SpvWord{34}}, + {"CapabilityVectorAnyINTEL", SpvWord{5619}}, + {"QuantizationModesRND", SpvWord{2}}, + {"DimCube", SpvWord{3}}, + {"ExecutionModeOriginLowerLeft", SpvWord{8}}, + {"ImageFormatRg32ui", SpvWord{35}}, + {"CapabilityAtomicFloat16AddEXT", SpvWord{6095}}, + {"FunctionParameterAttributeSret", SpvWord{3}}, + {"ImageOperandsConstOffsets", SpvWord{32}}, + {"DecorationAliasedPointerEXT", SpvWord{5356}}, + {"BuiltInWarpMaxIDARM", SpvWord{4164}}, + {"ImageFormatRg8i", SpvWord{27}}, + {"ImageChannelOrdersRGBA", SpvWord{17}}, + {"StorageClassPrivate", SpvWord{6}}, + {"BuiltInPositionPerViewNV", SpvWord{5261}}, + {"ExecutionModeIsolines", SpvWord{25}}, + {"ScopeCrossDevice", SpvWord{0}}, + {"BuiltInObjectToWorldNV", SpvWord{5330}}, + {"CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR", SpvWord{4429}}, + {"CapabilityUniformAndStorageBuffer8BitAccess", SpvWord{4449}}, + {"ImageChannelDataTypeUnsignedInt32", SpvWord{12}}, + {"FPRoundingModeRTP", SpvWord{2}}, + {"ExecutionModeRoundingModeRTNINTEL", SpvWord{5621}}, + {"DecorationLinkageAttributes", SpvWord{41}}, + {"DecorationFunctionFloatingPointModeINTEL", SpvWord{6080}}, + {"CapabilityRayTracingMotionBlurNV", SpvWord{5341}}, + {"StorageClassCallableDataKHR", SpvWord{5328}}, + {"CapabilityVulkanMemoryModelDeviceScope", SpvWord{5346}}, + {"LoopControlUnroll", SpvWord{1}}, + {"ImageChannelOrdersBGRA", SpvWord{18}}, + {"MemorySemanticsAcquire", SpvWord{2}}, + {"FPFastMathModeNotInf", SpvWord{2}}, + {"DecorationClobberINTEL", SpvWord{5607}}, + {"BuiltInCullPrimitiveEXT", SpvWord{5299}}, + {"FPRoundingModeRTE", SpvWord{0}}, + {"ExecutionModeSubgroupsPerWorkgroupId", SpvWord{37}}, + {"GroupOperationPartitionedInclusiveScanNV", SpvWord{7}}, + {"CapabilityInt64ImageEXT", SpvWord{5016}}, + {"CapabilityStorageUniformBufferBlock16", SpvWord{4433}}, + {"DecorationColMajor", SpvWord{5}}, + {"FunctionControlInline", SpvWord{1}}, + {"CapabilityShader", SpvWord{1}}, + {"ExecutionModeOutputLineStrip", SpvWord{28}}, + {"CapabilityFPFastMathModeINTEL", SpvWord{5837}}, + {"CapabilityFPGAMemoryAccessesINTEL", SpvWord{5898}}, + {"FPDenormModePreserve", SpvWord{0}}, + {"ExecutionModeNonCoherentColorAttachmentReadEXT", SpvWord{4169}}, + {"StorageClassHitAttributeKHR", SpvWord{5339}}, + {"CapabilityShaderStereoViewNV", SpvWord{5259}}, + {"ExecutionModeXfb", SpvWord{11}}, + {"MemorySemanticsMakeVisibleKHR", SpvWord{16384}}, + {"StorageClassUniform", SpvWord{2}}, + {"BuiltInCullMaskKHR", SpvWord{6021}}, + {"DecorationPerPrimitiveEXT", SpvWord{5271}}, + {"BuiltInBaryCoordNoPerspKHR", SpvWord{5287}}, + {"DecorationViewportRelativeNV", SpvWord{5252}}, + {"ExecutionModeStencilRefLessBackAMD", SpvWord{5084}}, + {"ImageFormatRgba32i", SpvWord{21}}, + {"BuiltInDrawIndex", SpvWord{4426}}, + {"ImageFormatRg16f", SpvWord{7}}, + {"ExecutionModePointMode", SpvWord{10}}, + {"BuiltInBaryCoordNoPerspSampleAMD", SpvWord{4994}}, + {"BuiltInTaskCountNV", SpvWord{5274}}, + {"DecorationBindlessImageNV", SpvWord{5399}}, + {"CapabilityImageReadWrite", SpvWord{14}}, + {"RayFlagsTerminateOnFirstHitKHR", SpvWord{4}}, + {"ImageFormatRg16", SpvWord{12}}, + {"KernelProfilingInfoNone", SpvWord{0}}, + {"CapabilityBitInstructions", SpvWord{6025}}, + {"ImageFormatR32ui", SpvWord{33}}, + {"CapabilityGeometryShaderPassthroughNV", SpvWord{5251}}, + {"BuiltInSubgroupSize", SpvWord{36}}, + {"FunctionControlOptNoneINTEL", SpvWord{65536}}, + {"ImageChannelDataTypeFloat", SpvWord{14}}, + {"ImageChannelOrderRx", SpvWord{10}}, + {"ImageFormatR16", SpvWord{14}}, + {"BuiltInIncomingRayFlagsNV", SpvWord{5351}}, + {"CapabilityFloat16Buffer", SpvWord{8}}, + {"DecorationMMHostInterfaceDataWidthINTEL", SpvWord{6178}}, + {"DecorationPassthroughNV", SpvWord{5250}}, + {"StorageClassOutput", SpvWord{3}}, + {"MemoryAccessNonPrivatePointerKHR", SpvWord{32}}, + {"CapabilityRoundingModeRTE", SpvWord{4467}}, + {"StorageClassRayPayloadKHR", SpvWord{5338}}, + {"CooperativeMatrixUseMatrixAKHR", SpvWord{0}}, + {"StorageClassCrossWorkgroup", SpvWord{5}}, + {"BuiltInLaunchSizeNV", SpvWord{5320}}, + {"QuantizationModesRND_ZERO", SpvWord{3}}, + {"BuiltInSampleId", SpvWord{18}}, + {"DecorationGlobalVariableOffsetINTEL", SpvWord{5628}}, + {"ImageFormatR16i", SpvWord{28}}, + {"ExecutionModeRoundingModeRTZ", SpvWord{4463}}, + {"BuiltInViewIndex", SpvWord{4440}}, + {"ImageFormatR8i", SpvWord{29}}, + {"CapabilityRayTraversalPrimitiveCullingKHR", SpvWord{4478}}, + {"CapabilityRoundingModeRTZ", SpvWord{4468}}, + {"ExecutionModeContractionOff", SpvWord{31}}, + {"AddressingModelPhysicalStorageBuffer64", SpvWord{5348}}, + {"ImageFormatUnknown", SpvWord{0}}, + {"BuiltInInstanceCustomIndexKHR", SpvWord{5327}}, + {"DecorationXfbStride", SpvWord{37}}, + {"CapabilityAtomicFloat64AddEXT", SpvWord{6034}}, + {"RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR", SpvWord{1}}, + {"FPFastMathModeNotNaN", SpvWord{1}}, + {"DecorationMMHostInterfaceReadWriteModeINTEL", SpvWord{6180}}, + {"DecorationLatencyControlConstraintINTEL", SpvWord{6173}}, + {"LoopControlMaxReinvocationDelayINTEL", SpvWord{33554432}}, + {"CapabilityStorageTexelBufferArrayNonUniformIndexing", SpvWord{5312}}, + {"CapabilityUSMStorageClassesINTEL", SpvWord{5935}}, + {"CapabilityImageRect", SpvWord{36}}, + {"CapabilityFloat64", SpvWord{10}}, + {"ImageOperandsMakeTexelVisible", SpvWord{512}}, + {"LoopControlDontUnroll", SpvWord{2}}, + {"StorageClassPushConstant", SpvWord{9}}, + {"BuiltInWorkgroupId", SpvWord{26}}, + {"ImageFormatR16ui", SpvWord{38}}, + {"CapabilityInt64", SpvWord{11}}, + {"BuiltInSubgroupEqMaskKHR", SpvWord{4416}}, + {"MemorySemanticsMakeVisible", SpvWord{16384}}, + {"DecorationNoSignedWrap", SpvWord{4469}}, + {"ImageChannelDataTypeUnsignedInt16", SpvWord{11}}, + {"OverflowModesSAT_ZERO", SpvWord{2}}, + {"MemoryAccessNoAliasINTELMask", SpvWord{131072}}, + {"CapabilityRuntimeDescriptorArray", SpvWord{5302}}, + {"CapabilitySubgroupAvcMotionEstimationINTEL", SpvWord{5696}}, + {"ExecutionModelIntersectionKHR", SpvWord{5314}}, + {"StorageClassImage", SpvWord{11}}, + {"BuiltInPrimitiveCountNV", SpvWord{5275}}, + {"DecorationHlslCounterBufferGOOGLE", SpvWord{5634}}, + {"CapabilityGroupNonUniformClustered", SpvWord{67}}, + {"LoopControlLoopCountINTEL", SpvWord{16777216}}, + {"RayFlagsSkipTrianglesKHR", SpvWord{256}}, + {"ExecutionModeShadingRateInterlockOrderedEXT", SpvWord{5370}}, + {"ExecutionModeMaxWorkgroupSizeINTEL", SpvWord{5893}}, + {"BuiltInLocalInvocationId", SpvWord{27}}, + {"CapabilityFragmentShadingRateKHR", SpvWord{4422}}, + {"CapabilityShaderNonUniform", SpvWord{5301}}, + {"ExecutionModeVertexOrderCcw", SpvWord{5}}, + {"FPDenormModeFlushToZero", SpvWord{1}}, + {"CooperativeMatrixOperandsMatrixResultSignedComponentsKHR", SpvWord{8}}, + {"RayQueryIntersectionRayQueryCandidateIntersectionKHR", SpvWord{0}}, + {"CapabilityAsmINTEL", SpvWord{5606}}, + {"BuiltInPosition", SpvWord{0}}, + {"BuiltInPrimitiveLineIndicesEXT", SpvWord{5295}}, + {"DecorationAliasScopeINTEL", SpvWord{5914}}, + {"CapabilityGroupUniformArithmeticKHR", SpvWord{6400}}, + {"BuiltInMeshViewIndicesNV", SpvWord{5281}}, + {"DimTileImageDataEXT", SpvWord{4173}}, + {"DecorationMMHostInterfaceWaitRequestINTEL", SpvWord{6182}}, + {"CapabilityArbitraryPrecisionFloatingPointINTEL", SpvWord{5845}}, + {"SourceLanguageNZSL", SpvWord{9}}, + {"CapabilityFragmentFullyCoveredEXT", SpvWord{5265}}, + {"BuiltInPointCoord", SpvWord{16}}, + {"CapabilitySubgroupDispatch", SpvWord{58}}, + {"CapabilityImageReadWriteLodAMD", SpvWord{5015}}, + {"CapabilityInputAttachmentArrayNonUniformIndexingEXT", SpvWord{5310}}, + {"ScopeInvocation", SpvWord{4}}, + {"ExecutionModelTaskNV", SpvWord{5267}}, + {"CapabilityStorageTexelBufferArrayDynamicIndexing", SpvWord{5305}}, + {"CapabilityTessellation", SpvWord{3}}, + {"CapabilitySubgroupImageBlockIOINTEL", SpvWord{5570}}, + {"ImageChannelOrderIntensity", SpvWord{8}}, + {"CapabilityRayTracingProvisionalKHR", SpvWord{5353}}, + {"CapabilityDotProductInput4x8Bit", SpvWord{6017}}, + {"FPRoundingModeRTN", SpvWord{3}}, + {"BuiltInVertexIndex", SpvWord{42}}, + {"ExecutionModeStencilRefReplacingEXT", SpvWord{5027}}, + {"MemorySemanticsRelaxed", SpvWord{0}}, + {"CapabilityFragmentShaderSampleInterlockEXT", SpvWord{5363}}, + {"ImageOperandsZeroExtend", SpvWord{8192}}, + {"CapabilityVulkanMemoryModelDeviceScopeKHR", SpvWord{5346}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR", SpvWord{1}}, + {"BuiltInBaseVertex", SpvWord{4424}}, + {"ExecutionModeNumSIMDWorkitemsINTEL", SpvWord{5896}}, + {"DecorationSample", SpvWord{17}}, + {"BuiltInSubgroupLtMaskKHR", SpvWord{4420}}, + {"ImageChannelDataTypeUnormInt16", SpvWord{3}}, + {"ImageOperandsNone", SpvWord{0}}, + {"CapabilityImageMSArray", SpvWord{48}}, + {"ImageFormatRgba8Snorm", SpvWord{5}}, + {"CapabilityUniformTexelBufferArrayNonUniformIndexingEXT", SpvWord{5311}}, + {"DecorationNonWritable", SpvWord{24}}, + {"BuiltInSubgroupMaxSize", SpvWord{37}}, + {"CapabilityTileImageDepthReadAccessEXT", SpvWord{4167}}, + {"Dim2D", SpvWord{1}}, + {"DecorationStream", SpvWord{29}}, + {"CapabilityUniformBufferArrayDynamicIndexing", SpvWord{28}}, + {"CapabilityStorageImageExtendedFormats", SpvWord{49}}, + {"CapabilityFloat16ImageAMD", SpvWord{5008}}, + {"ExecutionModelAnyHitNV", SpvWord{5315}}, + {"DecorationInputAttachmentIndex", SpvWord{43}}, + {"BuiltInRayTminKHR", SpvWord{5325}}, + {"BuiltInSubgroupLocalInvocationId", SpvWord{41}}, + {"BuiltInViewportIndex", SpvWord{10}}, + {"CapabilityMultiView", SpvWord{4439}}, + {"AddressingModelPhysicalStorageBuffer64EXT", SpvWord{5348}}, + {"DimBuffer", SpvWord{5}}, + {"DecorationLatencyControlLabelINTEL", SpvWord{6172}}, + {"DecorationSimpleDualPortINTEL", SpvWord{5833}}, + {"BuiltInWorldRayOriginNV", SpvWord{5321}}, + {"BuiltInObjectRayOriginNV", SpvWord{5323}}, + {"RayFlagsForceOpacityMicromap2StateEXT", SpvWord{1024}}, + {"CapabilityGeometryPointSize", SpvWord{24}}, + {"LinkageTypeLinkOnceODR", SpvWord{2}}, + {"ExecutionModeStencilRefUnchangedFrontAMD", SpvWord{5079}}, + {"FPFastMathModeNone", SpvWord{0}}, + {"DecorationNoAliasINTEL", SpvWord{5915}}, + {"CapabilityShaderLayer", SpvWord{69}}, + {"DecorationHitObjectShaderRecordBufferNV", SpvWord{5386}}, + {"ImageChannelDataTypeUnormInt101010_2", SpvWord{16}}, + {"BuiltInSamplePosition", SpvWord{19}}, + {"CapabilityUniformTexelBufferArrayDynamicIndexingEXT", SpvWord{5304}}, + {"DecorationUniform", SpvWord{26}}, + {"ImageOperandsMakeTexelAvailableKHR", SpvWord{256}}, + {"CapabilityUniformBufferArrayNonUniformIndexing", SpvWord{5306}}, + {"DecorationPrefetchINTEL", SpvWord{5902}}, + {"CapabilityDebugInfoModuleINTEL", SpvWord{6114}}, + {"StorageClassGeneric", SpvWord{8}}, + {"CapabilitySampled1D", SpvWord{43}}, + {"ImageOperandsNonPrivateTexel", SpvWord{1024}}, + {"LoopControlDependencyInfinite", SpvWord{4}}, + {"StorageClassInput", SpvWord{1}}, + {"LoopControlDependencyLength", SpvWord{8}}, + {"GroupOperationClusteredReduce", SpvWord{3}}, + {"CapabilityDrawParameters", SpvWord{4427}}, + {"CapabilityUniformTexelBufferArrayDynamicIndexing", SpvWord{5304}}, + {"ExecutionModeDerivativeGroupLinearNV", SpvWord{5290}}, + {"DecorationMMHostInterfaceLatencyINTEL", SpvWord{6179}}, + {"CapabilityInt8", SpvWord{39}}, + {"ImageChannelDataTypeSnormInt16", SpvWord{1}}, + {"CapabilityStorageInputOutput16", SpvWord{4436}}, + {"CapabilitySampledImageArrayDynamicIndexing", SpvWord{29}}, + {"ExecutionModeNonCoherentStencilAttachmentReadEXT", SpvWord{4171}}, + {"BuiltInSMIDNV", SpvWord{5377}}, + {"CapabilityKernelAttributesINTEL", SpvWord{5892}}, + {"StorageClassUniformConstant", SpvWord{0}}, + {"CapabilityCooperativeMatrixNV", SpvWord{5357}}, + {"DecorationNoContraction", SpvWord{42}}, + {"ExecutionModelKernel", SpvWord{6}}, + {"DecorationPerTaskNV", SpvWord{5273}}, + {"BuiltInFragInvocationCountEXT", SpvWord{5293}}, + {"BuiltInDeviceIndex", SpvWord{4438}}, + {"CapabilityStorageImageWriteWithoutFormat", SpvWord{56}}, + {"CapabilityGroupNonUniformRotateKHR", SpvWord{6026}}, + {"CapabilityDenormFlushToZero", SpvWord{4465}}, + {"ExecutionModeRoundingModeRTE", SpvWord{4462}}, + {"BuiltInPointSize", SpvWord{1}}, + {"CapabilityComputeDerivativeGroupLinearNV", SpvWord{5350}}, + {"ImageChannelOrderRA", SpvWord{3}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 944; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool getOpInfo(const SpvOp& k, SPIRVCoreGrammarInfo::OpInfo& v) +{ + switch(k) + { + case SpvOpNop: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpUndef: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSourceContinued: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSource: + { + const static OperandKind operandTypes[] = {{10}, {48}, {47}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 2, 4, 4, operandTypes}; + return true; + } + case SpvOpSourceExtension: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpName: + { + const static OperandKind operandTypes[] = {{47}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberName: + { + const static OperandKind operandTypes[] = {{47}, {48}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpString: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLine: + { + const static OperandKind operandTypes[] = {{47}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpExtension: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExtInstImport: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpExtInst: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {51}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpMemoryModel: + { + const static OperandKind operandTypes[] = {{12}, {13}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpEntryPoint: + { + const static OperandKind operandTypes[] = {{11}, {47}, {49}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpExecutionMode: + { + const static OperandKind operandTypes[] = {{47}, {14}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpCapability: + { + const static OperandKind operandTypes[] = {{35}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeVoid: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeBool: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeInt: + { + const static OperandKind operandTypes[] = {{44}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeFloat: + { + const static OperandKind operandTypes[] = {{44}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeVector: + { + const static OperandKind operandTypes[] = {{44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeMatrix: + { + const static OperandKind operandTypes[] = {{44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeImage: + { + const static OperandKind operandTypes[] = {{44}, {47}, {16}, {48}, {48}, {48}, {48}, {19}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 8, 9, 9, operandTypes}; + return true; + } + case SpvOpTypeSampler: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeSampledImage: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeArray: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeRuntimeArray: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeStruct: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpTypeOpaque: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypePointer: + { + const static OperandKind operandTypes[] = {{44}, {15}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeFunction: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpTypeEvent: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeDeviceEvent: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeReserveId: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeQueue: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypePipe: + { + const static OperandKind operandTypes[] = {{44}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeForwardPointer: + { + const static OperandKind operandTypes[] = {{47}, {15}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstantTrue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstantFalse: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstant: + { + const static OperandKind operandTypes[] = {{43}, {44}, {50}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConstantComposite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpConstantSampler: + { + const static OperandKind operandTypes[] = {{43}, {44}, {17}, {48}, {18}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpConstantNull: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstantTrue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstantFalse: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstant: + { + const static OperandKind operandTypes[] = {{43}, {44}, {50}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSpecConstantComposite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpSpecConstantOp: + { + const static OperandKind operandTypes[] = {{43}, {44}, {52}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFunction: + { + const static OperandKind operandTypes[] = {{43}, {44}, {4}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFunctionParameter: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpFunctionEnd: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpFunctionCall: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpVariable: + { + const static OperandKind operandTypes[] = {{43}, {44}, {15}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpImageTexelPointer: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpLoad: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpStore: + { + const static OperandKind operandTypes[] = {{47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpCopyMemory: + { + const static OperandKind operandTypes[] = {{47}, {47}, {6}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 4, 4, operandTypes}; + return true; + } + case SpvOpCopyMemorySized: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {6}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 5, 5, operandTypes}; + return true; + } + case SpvOpAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpInBoundsAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpPtrAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpArrayLength: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGenericPtrMemSemantics: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpInBoundsPtrAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpDecorate: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberDecorate: + { + const static OperandKind operandTypes[] = {{47}, {48}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDecorationGroup: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpGroupDecorate: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpGroupMemberDecorate: + { + const static OperandKind operandTypes[] = {{47}, {54}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpVectorExtractDynamic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorInsertDynamic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpVectorShuffle: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpCompositeConstruct: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpCompositeExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpCompositeInsert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpCopyObject: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTranspose: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSampledImage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageSampleImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleProjImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleProjExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleProjDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleProjDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageFetch: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageDrefGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageRead: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageWrite: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpImage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryFormat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryOrder: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQuerySizeLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageQuerySize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageQueryLevels: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQuerySamples: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertFToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertFToS: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSToF: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToF: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpUConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpQuantizeToF16: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertPtrToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSatConvertSToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSatConvertUToS: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToPtr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpPtrCastToGeneric: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGenericCastToPtr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGenericCastToPtrExplicit: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {15}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSNegate: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFNegate: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFSub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSRem: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFRem: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorTimesScalar: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesScalar: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorTimesMatrix: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesVector: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesMatrix: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpOuterProduct: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAddCarry: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISubBorrow: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMulExtended: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSMulExtended: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsNan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsInf: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsFinite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsNormal: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSignBitSet: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpLessOrGreater: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpOrdered: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUnordered: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalNot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSelect: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpIEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpINotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpULessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpULessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftRightLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftRightArithmetic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftLeftLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpNot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBitFieldInsert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpBitFieldSExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpBitFieldUExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpBitReverse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBitCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdx: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdy: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidth: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdxFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdyFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidthFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdxCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdyCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidthCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpEmitVertex: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEndPrimitive: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEmitStreamVertex: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpEndStreamPrimitive: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpControlBarrier: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpMemoryBarrier: + { + const static OperandKind operandTypes[] = {{46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpAtomicLoad: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicStore: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAtomicExchange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicCompareExchange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {45}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpAtomicCompareExchangeWeak: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {45}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpAtomicIIncrement: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicIDecrement: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicISub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpPhi: + { + const static OperandKind operandTypes[] = {{43}, {44}, {55}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpLoopMerge: + { + const static OperandKind operandTypes[] = {{47}, {47}, {3}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSelectionMerge: + { + const static OperandKind operandTypes[] = {{47}, {2}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLabel: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpBranch: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpBranchConditional: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpSwitch: + { + const static OperandKind operandTypes[] = {{47}, {47}, {53}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpKill: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpReturn: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpReturnValue: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpUnreachable: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpLifetimeStart: + { + const static OperandKind operandTypes[] = {{47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLifetimeStop: + { + const static OperandKind operandTypes[] = {{47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupAsyncCopy: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpGroupWaitEvents: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpReadPipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpWritePipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpReservedReadPipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpReservedWritePipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpReserveReadPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpReserveWritePipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpCommitReadPipe: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpCommitWritePipe: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIsValidReserveId: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetNumPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGetMaxPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupReserveReadPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupReserveWritePipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupCommitReadPipe: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupCommitWritePipe: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpEnqueueMarker: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpEnqueueKernel: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 12, 0xffff, 13, operandTypes}; + return true; + } + case SpvOpGetKernelNDrangeSubGroupCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelNDrangeMaxSubGroupSize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelWorkGroupSize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpGetKernelPreferredWorkGroupSizeMultiple: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpRetainEvent: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpReleaseEvent: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpCreateUserEvent: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpIsValidEvent: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSetUserEventStatus: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpCaptureEventProfilingInfo: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetDefaultQueue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpBuildNDRange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseFetch: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseDrefGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseTexelsResident: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpNoLine: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpAtomicFlagTestAndSet: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicFlagClear: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageSparseRead: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSizeOf: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypePipeStorage: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpConstantPipeStorage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCreatePipeFromPipeStorage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetKernelLocalSizeForSubgroupCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelMaxNumSubgroups: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeNamedBarrier: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpNamedBarrierInitialize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpMemoryNamedBarrier: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpModuleProcessed: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExecutionModeId: + { + const static OperandKind operandTypes[] = {{47}, {14}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpDecorateId: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupNonUniformElect: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAllEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBroadcastFirst: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformInverseBallot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotBitExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotBitCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotFindLSB: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotFindMSB: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffle: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleUp: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleDown: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformIMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformQuadBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformQuadSwap: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCopyLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpPtrEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpPtrNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpPtrDiff: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpColorAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpDepthAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpStencilAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpTerminateInvocation: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpSubgroupBallotKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupFirstInvocationKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAllKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAnyKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAllEqualKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupNonUniformRotateKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupReadInvocationKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTraceRayKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 11, 11, 11, operandTypes}; + return true; + } + case SpvOpExecuteCallableKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConvertUToAccelerationStructureKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIgnoreIntersectionKHR: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTerminateRayKHR: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpSDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpUDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSUDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpUDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpSUDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeCooperativeMatrixKHR: + { + const static OperandKind operandTypes[] = {{44}, {47}, {46}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLoadKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixStoreKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixMulAddKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {40}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLengthKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeRayQueryKHR: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryInitializeKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpRayQueryTerminateKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryGenerateIntersectionKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpRayQueryConfirmIntersectionKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryProceedKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTypeKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageSampleWeightedQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageBoxFilterQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageBlockMatchSSDQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpImageBlockMatchSADQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupIAddNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFAddNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpFragmentMaskFetchAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFragmentFetchAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpReadClockKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 14, 14, 14, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectRecordMissMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldToObjectNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectToWorldNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectRayDirectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectRayOriginNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectTraceRayMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectGetShaderRecordBufferHandleNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectRecordEmptyNV: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpHitObjectTraceRayNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpHitObjectRecordMissNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpHitObjectExecuteShaderNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpHitObjectGetCurrentTimeNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetAttributesNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpHitObjectGetHitKindNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetPrimitiveIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetGeometryIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetInstanceIdNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetInstanceCustomIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldRayDirectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldRayOriginNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetRayTMaxNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetRayTMinNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsEmptyNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsHitNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsMissNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpReorderThreadWithHitObjectNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 3, 3, operandTypes}; + return true; + } + case SpvOpReorderThreadWithHintNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeHitObjectNV: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpImageSampleFootprintNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 7, 7, operandTypes}; + return true; + } + case SpvOpEmitMeshTasksEXT: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpSetMeshOutputsEXT: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupNonUniformPartitionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpWritePackedPrimitiveIndices4x8NV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpReportIntersectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIgnoreIntersectionNV: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTerminateRayNV: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTraceNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 11, 11, 11, operandTypes}; + return true; + } + case SpvOpTraceMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpTraceRayMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTypeAccelerationStructureNV: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExecuteCallableNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeCooperativeMatrixNV: + { + const static OperandKind operandTypes[] = {{44}, {47}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLoadNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixStoreNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixMulAddNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLengthNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBeginInvocationInterlockEXT: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEndInvocationInterlockEXT: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpDemoteToHelperInvocation: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpIsHelperInvocationEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConvertUToImageNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToSamplerNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertImageToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSamplerToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToSampledImageNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSampledImageToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSamplerImageAddressingModeNV: + { + const static OperandKind operandTypes[] = {{48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleDownINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleUpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleXorINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupImageBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupImageBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupImageMediaBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupImageMediaBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpUCountLeadingZerosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpUCountTrailingZerosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAbsISubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAbsUSubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAddSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAddSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAverageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAverageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAverageRoundedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAverageRoundedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISubSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUSubSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIMul32x16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMul32x16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpConstantFunctionPointerINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFunctionPointerCallINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpAsmTargetINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAsmINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {49}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAsmCallINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpAtomicFMinEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicFMaxEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAssumeTrueKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExpectKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpDecorateString: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberDecorateString: + { + const static OperandKind operandTypes[] = {{47}, {48}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpVmeImageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTypeVmeImageINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeAvcImePayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcRefPayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcSicPayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcMceResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcRefResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcSicResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImeResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeRefWindowSizeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetWeightedSadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetBorderReachedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcFmeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpSubgroupAvcBmeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureSkcINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateIpeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpVariableLengthArrayINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSaveMemoryINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpRestoreMemoryINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastFromIntINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastToIntINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpArbitraryFloatAddINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatMulINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatDivINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatGTINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatGEINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLTINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLEINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatEQINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatRecipINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatRSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCbrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatHypotINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLogINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog10INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog1pINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExp2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExp10INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExpm1INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatASinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatASinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatACosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatACosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATanINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATanPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATan2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowRINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowNINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpLoopControlINTEL: + { + const static OperandKind operandTypes[] = {{48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpAliasDomainDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 2, 2, operandTypes}; + return true; + } + case SpvOpAliasScopeDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpAliasScopeListDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpFixedSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedRecipINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedRsqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedLogINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedExpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpPtrCastToCrossWorkgroupINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpCrossWorkgroupCastToPtrINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpReadPipeBlockingINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpWritePipeBlockingINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFPGARegINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetRayTMinKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetRayFlagsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceIdKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionGeometryIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionBarycentricsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionFrontFaceKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetWorldRayDirectionKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetWorldRayOriginKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectToWorldKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionWorldToObjectKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAtomicFAddEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeBufferSurfaceINTEL: + { + const static OperandKind operandTypes[] = {{44}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeStructContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpConstantCompositeContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpSpecConstantCompositeContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpConvertFToBF16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertBF16ToFINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpControlBarrierArriveINTEL: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpControlBarrierWaitINTEL: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupIMulKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMulKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseAndKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseOrKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseXorKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalAndKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalOrKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalXorKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + default: return false; + } +} + +static bool getOpName(const SpvOp& k, UnownedStringSlice& v) +{ + switch(k) + { + case SpvOpNop: + { + v = UnownedStringSlice{"OpNop"}; + return true; + } + case SpvOpUndef: + { + v = UnownedStringSlice{"OpUndef"}; + return true; + } + case SpvOpSourceContinued: + { + v = UnownedStringSlice{"OpSourceContinued"}; + return true; + } + case SpvOpSource: + { + v = UnownedStringSlice{"OpSource"}; + return true; + } + case SpvOpSourceExtension: + { + v = UnownedStringSlice{"OpSourceExtension"}; + return true; + } + case SpvOpName: + { + v = UnownedStringSlice{"OpName"}; + return true; + } + case SpvOpMemberName: + { + v = UnownedStringSlice{"OpMemberName"}; + return true; + } + case SpvOpString: + { + v = UnownedStringSlice{"OpString"}; + return true; + } + case SpvOpLine: + { + v = UnownedStringSlice{"OpLine"}; + return true; + } + case SpvOpExtension: + { + v = UnownedStringSlice{"OpExtension"}; + return true; + } + case SpvOpExtInstImport: + { + v = UnownedStringSlice{"OpExtInstImport"}; + return true; + } + case SpvOpExtInst: + { + v = UnownedStringSlice{"OpExtInst"}; + return true; + } + case SpvOpMemoryModel: + { + v = UnownedStringSlice{"OpMemoryModel"}; + return true; + } + case SpvOpEntryPoint: + { + v = UnownedStringSlice{"OpEntryPoint"}; + return true; + } + case SpvOpExecutionMode: + { + v = UnownedStringSlice{"OpExecutionMode"}; + return true; + } + case SpvOpCapability: + { + v = UnownedStringSlice{"OpCapability"}; + return true; + } + case SpvOpTypeVoid: + { + v = UnownedStringSlice{"OpTypeVoid"}; + return true; + } + case SpvOpTypeBool: + { + v = UnownedStringSlice{"OpTypeBool"}; + return true; + } + case SpvOpTypeInt: + { + v = UnownedStringSlice{"OpTypeInt"}; + return true; + } + case SpvOpTypeFloat: + { + v = UnownedStringSlice{"OpTypeFloat"}; + return true; + } + case SpvOpTypeVector: + { + v = UnownedStringSlice{"OpTypeVector"}; + return true; + } + case SpvOpTypeMatrix: + { + v = UnownedStringSlice{"OpTypeMatrix"}; + return true; + } + case SpvOpTypeImage: + { + v = UnownedStringSlice{"OpTypeImage"}; + return true; + } + case SpvOpTypeSampler: + { + v = UnownedStringSlice{"OpTypeSampler"}; + return true; + } + case SpvOpTypeSampledImage: + { + v = UnownedStringSlice{"OpTypeSampledImage"}; + return true; + } + case SpvOpTypeArray: + { + v = UnownedStringSlice{"OpTypeArray"}; + return true; + } + case SpvOpTypeRuntimeArray: + { + v = UnownedStringSlice{"OpTypeRuntimeArray"}; + return true; + } + case SpvOpTypeStruct: + { + v = UnownedStringSlice{"OpTypeStruct"}; + return true; + } + case SpvOpTypeOpaque: + { + v = UnownedStringSlice{"OpTypeOpaque"}; + return true; + } + case SpvOpTypePointer: + { + v = UnownedStringSlice{"OpTypePointer"}; + return true; + } + case SpvOpTypeFunction: + { + v = UnownedStringSlice{"OpTypeFunction"}; + return true; + } + case SpvOpTypeEvent: + { + v = UnownedStringSlice{"OpTypeEvent"}; + return true; + } + case SpvOpTypeDeviceEvent: + { + v = UnownedStringSlice{"OpTypeDeviceEvent"}; + return true; + } + case SpvOpTypeReserveId: + { + v = UnownedStringSlice{"OpTypeReserveId"}; + return true; + } + case SpvOpTypeQueue: + { + v = UnownedStringSlice{"OpTypeQueue"}; + return true; + } + case SpvOpTypePipe: + { + v = UnownedStringSlice{"OpTypePipe"}; + return true; + } + case SpvOpTypeForwardPointer: + { + v = UnownedStringSlice{"OpTypeForwardPointer"}; + return true; + } + case SpvOpConstantTrue: + { + v = UnownedStringSlice{"OpConstantTrue"}; + return true; + } + case SpvOpConstantFalse: + { + v = UnownedStringSlice{"OpConstantFalse"}; + return true; + } + case SpvOpConstant: + { + v = UnownedStringSlice{"OpConstant"}; + return true; + } + case SpvOpConstantComposite: + { + v = UnownedStringSlice{"OpConstantComposite"}; + return true; + } + case SpvOpConstantSampler: + { + v = UnownedStringSlice{"OpConstantSampler"}; + return true; + } + case SpvOpConstantNull: + { + v = UnownedStringSlice{"OpConstantNull"}; + return true; + } + case SpvOpSpecConstantTrue: + { + v = UnownedStringSlice{"OpSpecConstantTrue"}; + return true; + } + case SpvOpSpecConstantFalse: + { + v = UnownedStringSlice{"OpSpecConstantFalse"}; + return true; + } + case SpvOpSpecConstant: + { + v = UnownedStringSlice{"OpSpecConstant"}; + return true; + } + case SpvOpSpecConstantComposite: + { + v = UnownedStringSlice{"OpSpecConstantComposite"}; + return true; + } + case SpvOpSpecConstantOp: + { + v = UnownedStringSlice{"OpSpecConstantOp"}; + return true; + } + case SpvOpFunction: + { + v = UnownedStringSlice{"OpFunction"}; + return true; + } + case SpvOpFunctionParameter: + { + v = UnownedStringSlice{"OpFunctionParameter"}; + return true; + } + case SpvOpFunctionEnd: + { + v = UnownedStringSlice{"OpFunctionEnd"}; + return true; + } + case SpvOpFunctionCall: + { + v = UnownedStringSlice{"OpFunctionCall"}; + return true; + } + case SpvOpVariable: + { + v = UnownedStringSlice{"OpVariable"}; + return true; + } + case SpvOpImageTexelPointer: + { + v = UnownedStringSlice{"OpImageTexelPointer"}; + return true; + } + case SpvOpLoad: + { + v = UnownedStringSlice{"OpLoad"}; + return true; + } + case SpvOpStore: + { + v = UnownedStringSlice{"OpStore"}; + return true; + } + case SpvOpCopyMemory: + { + v = UnownedStringSlice{"OpCopyMemory"}; + return true; + } + case SpvOpCopyMemorySized: + { + v = UnownedStringSlice{"OpCopyMemorySized"}; + return true; + } + case SpvOpAccessChain: + { + v = UnownedStringSlice{"OpAccessChain"}; + return true; + } + case SpvOpInBoundsAccessChain: + { + v = UnownedStringSlice{"OpInBoundsAccessChain"}; + return true; + } + case SpvOpPtrAccessChain: + { + v = UnownedStringSlice{"OpPtrAccessChain"}; + return true; + } + case SpvOpArrayLength: + { + v = UnownedStringSlice{"OpArrayLength"}; + return true; + } + case SpvOpGenericPtrMemSemantics: + { + v = UnownedStringSlice{"OpGenericPtrMemSemantics"}; + return true; + } + case SpvOpInBoundsPtrAccessChain: + { + v = UnownedStringSlice{"OpInBoundsPtrAccessChain"}; + return true; + } + case SpvOpDecorate: + { + v = UnownedStringSlice{"OpDecorate"}; + return true; + } + case SpvOpMemberDecorate: + { + v = UnownedStringSlice{"OpMemberDecorate"}; + return true; + } + case SpvOpDecorationGroup: + { + v = UnownedStringSlice{"OpDecorationGroup"}; + return true; + } + case SpvOpGroupDecorate: + { + v = UnownedStringSlice{"OpGroupDecorate"}; + return true; + } + case SpvOpGroupMemberDecorate: + { + v = UnownedStringSlice{"OpGroupMemberDecorate"}; + return true; + } + case SpvOpVectorExtractDynamic: + { + v = UnownedStringSlice{"OpVectorExtractDynamic"}; + return true; + } + case SpvOpVectorInsertDynamic: + { + v = UnownedStringSlice{"OpVectorInsertDynamic"}; + return true; + } + case SpvOpVectorShuffle: + { + v = UnownedStringSlice{"OpVectorShuffle"}; + return true; + } + case SpvOpCompositeConstruct: + { + v = UnownedStringSlice{"OpCompositeConstruct"}; + return true; + } + case SpvOpCompositeExtract: + { + v = UnownedStringSlice{"OpCompositeExtract"}; + return true; + } + case SpvOpCompositeInsert: + { + v = UnownedStringSlice{"OpCompositeInsert"}; + return true; + } + case SpvOpCopyObject: + { + v = UnownedStringSlice{"OpCopyObject"}; + return true; + } + case SpvOpTranspose: + { + v = UnownedStringSlice{"OpTranspose"}; + return true; + } + case SpvOpSampledImage: + { + v = UnownedStringSlice{"OpSampledImage"}; + return true; + } + case SpvOpImageSampleImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleImplicitLod"}; + return true; + } + case SpvOpImageSampleExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleExplicitLod"}; + return true; + } + case SpvOpImageSampleDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleDrefImplicitLod"}; + return true; + } + case SpvOpImageSampleDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleDrefExplicitLod"}; + return true; + } + case SpvOpImageSampleProjImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjImplicitLod"}; + return true; + } + case SpvOpImageSampleProjExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjExplicitLod"}; + return true; + } + case SpvOpImageSampleProjDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjDrefImplicitLod"}; + return true; + } + case SpvOpImageSampleProjDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjDrefExplicitLod"}; + return true; + } + case SpvOpImageFetch: + { + v = UnownedStringSlice{"OpImageFetch"}; + return true; + } + case SpvOpImageGather: + { + v = UnownedStringSlice{"OpImageGather"}; + return true; + } + case SpvOpImageDrefGather: + { + v = UnownedStringSlice{"OpImageDrefGather"}; + return true; + } + case SpvOpImageRead: + { + v = UnownedStringSlice{"OpImageRead"}; + return true; + } + case SpvOpImageWrite: + { + v = UnownedStringSlice{"OpImageWrite"}; + return true; + } + case SpvOpImage: + { + v = UnownedStringSlice{"OpImage"}; + return true; + } + case SpvOpImageQueryFormat: + { + v = UnownedStringSlice{"OpImageQueryFormat"}; + return true; + } + case SpvOpImageQueryOrder: + { + v = UnownedStringSlice{"OpImageQueryOrder"}; + return true; + } + case SpvOpImageQuerySizeLod: + { + v = UnownedStringSlice{"OpImageQuerySizeLod"}; + return true; + } + case SpvOpImageQuerySize: + { + v = UnownedStringSlice{"OpImageQuerySize"}; + return true; + } + case SpvOpImageQueryLod: + { + v = UnownedStringSlice{"OpImageQueryLod"}; + return true; + } + case SpvOpImageQueryLevels: + { + v = UnownedStringSlice{"OpImageQueryLevels"}; + return true; + } + case SpvOpImageQuerySamples: + { + v = UnownedStringSlice{"OpImageQuerySamples"}; + return true; + } + case SpvOpConvertFToU: + { + v = UnownedStringSlice{"OpConvertFToU"}; + return true; + } + case SpvOpConvertFToS: + { + v = UnownedStringSlice{"OpConvertFToS"}; + return true; + } + case SpvOpConvertSToF: + { + v = UnownedStringSlice{"OpConvertSToF"}; + return true; + } + case SpvOpConvertUToF: + { + v = UnownedStringSlice{"OpConvertUToF"}; + return true; + } + case SpvOpUConvert: + { + v = UnownedStringSlice{"OpUConvert"}; + return true; + } + case SpvOpSConvert: + { + v = UnownedStringSlice{"OpSConvert"}; + return true; + } + case SpvOpFConvert: + { + v = UnownedStringSlice{"OpFConvert"}; + return true; + } + case SpvOpQuantizeToF16: + { + v = UnownedStringSlice{"OpQuantizeToF16"}; + return true; + } + case SpvOpConvertPtrToU: + { + v = UnownedStringSlice{"OpConvertPtrToU"}; + return true; + } + case SpvOpSatConvertSToU: + { + v = UnownedStringSlice{"OpSatConvertSToU"}; + return true; + } + case SpvOpSatConvertUToS: + { + v = UnownedStringSlice{"OpSatConvertUToS"}; + return true; + } + case SpvOpConvertUToPtr: + { + v = UnownedStringSlice{"OpConvertUToPtr"}; + return true; + } + case SpvOpPtrCastToGeneric: + { + v = UnownedStringSlice{"OpPtrCastToGeneric"}; + return true; + } + case SpvOpGenericCastToPtr: + { + v = UnownedStringSlice{"OpGenericCastToPtr"}; + return true; + } + case SpvOpGenericCastToPtrExplicit: + { + v = UnownedStringSlice{"OpGenericCastToPtrExplicit"}; + return true; + } + case SpvOpBitcast: + { + v = UnownedStringSlice{"OpBitcast"}; + return true; + } + case SpvOpSNegate: + { + v = UnownedStringSlice{"OpSNegate"}; + return true; + } + case SpvOpFNegate: + { + v = UnownedStringSlice{"OpFNegate"}; + return true; + } + case SpvOpIAdd: + { + v = UnownedStringSlice{"OpIAdd"}; + return true; + } + case SpvOpFAdd: + { + v = UnownedStringSlice{"OpFAdd"}; + return true; + } + case SpvOpISub: + { + v = UnownedStringSlice{"OpISub"}; + return true; + } + case SpvOpFSub: + { + v = UnownedStringSlice{"OpFSub"}; + return true; + } + case SpvOpIMul: + { + v = UnownedStringSlice{"OpIMul"}; + return true; + } + case SpvOpFMul: + { + v = UnownedStringSlice{"OpFMul"}; + return true; + } + case SpvOpUDiv: + { + v = UnownedStringSlice{"OpUDiv"}; + return true; + } + case SpvOpSDiv: + { + v = UnownedStringSlice{"OpSDiv"}; + return true; + } + case SpvOpFDiv: + { + v = UnownedStringSlice{"OpFDiv"}; + return true; + } + case SpvOpUMod: + { + v = UnownedStringSlice{"OpUMod"}; + return true; + } + case SpvOpSRem: + { + v = UnownedStringSlice{"OpSRem"}; + return true; + } + case SpvOpSMod: + { + v = UnownedStringSlice{"OpSMod"}; + return true; + } + case SpvOpFRem: + { + v = UnownedStringSlice{"OpFRem"}; + return true; + } + case SpvOpFMod: + { + v = UnownedStringSlice{"OpFMod"}; + return true; + } + case SpvOpVectorTimesScalar: + { + v = UnownedStringSlice{"OpVectorTimesScalar"}; + return true; + } + case SpvOpMatrixTimesScalar: + { + v = UnownedStringSlice{"OpMatrixTimesScalar"}; + return true; + } + case SpvOpVectorTimesMatrix: + { + v = UnownedStringSlice{"OpVectorTimesMatrix"}; + return true; + } + case SpvOpMatrixTimesVector: + { + v = UnownedStringSlice{"OpMatrixTimesVector"}; + return true; + } + case SpvOpMatrixTimesMatrix: + { + v = UnownedStringSlice{"OpMatrixTimesMatrix"}; + return true; + } + case SpvOpOuterProduct: + { + v = UnownedStringSlice{"OpOuterProduct"}; + return true; + } + case SpvOpDot: + { + v = UnownedStringSlice{"OpDot"}; + return true; + } + case SpvOpIAddCarry: + { + v = UnownedStringSlice{"OpIAddCarry"}; + return true; + } + case SpvOpISubBorrow: + { + v = UnownedStringSlice{"OpISubBorrow"}; + return true; + } + case SpvOpUMulExtended: + { + v = UnownedStringSlice{"OpUMulExtended"}; + return true; + } + case SpvOpSMulExtended: + { + v = UnownedStringSlice{"OpSMulExtended"}; + return true; + } + case SpvOpAny: + { + v = UnownedStringSlice{"OpAny"}; + return true; + } + case SpvOpAll: + { + v = UnownedStringSlice{"OpAll"}; + return true; + } + case SpvOpIsNan: + { + v = UnownedStringSlice{"OpIsNan"}; + return true; + } + case SpvOpIsInf: + { + v = UnownedStringSlice{"OpIsInf"}; + return true; + } + case SpvOpIsFinite: + { + v = UnownedStringSlice{"OpIsFinite"}; + return true; + } + case SpvOpIsNormal: + { + v = UnownedStringSlice{"OpIsNormal"}; + return true; + } + case SpvOpSignBitSet: + { + v = UnownedStringSlice{"OpSignBitSet"}; + return true; + } + case SpvOpLessOrGreater: + { + v = UnownedStringSlice{"OpLessOrGreater"}; + return true; + } + case SpvOpOrdered: + { + v = UnownedStringSlice{"OpOrdered"}; + return true; + } + case SpvOpUnordered: + { + v = UnownedStringSlice{"OpUnordered"}; + return true; + } + case SpvOpLogicalEqual: + { + v = UnownedStringSlice{"OpLogicalEqual"}; + return true; + } + case SpvOpLogicalNotEqual: + { + v = UnownedStringSlice{"OpLogicalNotEqual"}; + return true; + } + case SpvOpLogicalOr: + { + v = UnownedStringSlice{"OpLogicalOr"}; + return true; + } + case SpvOpLogicalAnd: + { + v = UnownedStringSlice{"OpLogicalAnd"}; + return true; + } + case SpvOpLogicalNot: + { + v = UnownedStringSlice{"OpLogicalNot"}; + return true; + } + case SpvOpSelect: + { + v = UnownedStringSlice{"OpSelect"}; + return true; + } + case SpvOpIEqual: + { + v = UnownedStringSlice{"OpIEqual"}; + return true; + } + case SpvOpINotEqual: + { + v = UnownedStringSlice{"OpINotEqual"}; + return true; + } + case SpvOpUGreaterThan: + { + v = UnownedStringSlice{"OpUGreaterThan"}; + return true; + } + case SpvOpSGreaterThan: + { + v = UnownedStringSlice{"OpSGreaterThan"}; + return true; + } + case SpvOpUGreaterThanEqual: + { + v = UnownedStringSlice{"OpUGreaterThanEqual"}; + return true; + } + case SpvOpSGreaterThanEqual: + { + v = UnownedStringSlice{"OpSGreaterThanEqual"}; + return true; + } + case SpvOpULessThan: + { + v = UnownedStringSlice{"OpULessThan"}; + return true; + } + case SpvOpSLessThan: + { + v = UnownedStringSlice{"OpSLessThan"}; + return true; + } + case SpvOpULessThanEqual: + { + v = UnownedStringSlice{"OpULessThanEqual"}; + return true; + } + case SpvOpSLessThanEqual: + { + v = UnownedStringSlice{"OpSLessThanEqual"}; + return true; + } + case SpvOpFOrdEqual: + { + v = UnownedStringSlice{"OpFOrdEqual"}; + return true; + } + case SpvOpFUnordEqual: + { + v = UnownedStringSlice{"OpFUnordEqual"}; + return true; + } + case SpvOpFOrdNotEqual: + { + v = UnownedStringSlice{"OpFOrdNotEqual"}; + return true; + } + case SpvOpFUnordNotEqual: + { + v = UnownedStringSlice{"OpFUnordNotEqual"}; + return true; + } + case SpvOpFOrdLessThan: + { + v = UnownedStringSlice{"OpFOrdLessThan"}; + return true; + } + case SpvOpFUnordLessThan: + { + v = UnownedStringSlice{"OpFUnordLessThan"}; + return true; + } + case SpvOpFOrdGreaterThan: + { + v = UnownedStringSlice{"OpFOrdGreaterThan"}; + return true; + } + case SpvOpFUnordGreaterThan: + { + v = UnownedStringSlice{"OpFUnordGreaterThan"}; + return true; + } + case SpvOpFOrdLessThanEqual: + { + v = UnownedStringSlice{"OpFOrdLessThanEqual"}; + return true; + } + case SpvOpFUnordLessThanEqual: + { + v = UnownedStringSlice{"OpFUnordLessThanEqual"}; + return true; + } + case SpvOpFOrdGreaterThanEqual: + { + v = UnownedStringSlice{"OpFOrdGreaterThanEqual"}; + return true; + } + case SpvOpFUnordGreaterThanEqual: + { + v = UnownedStringSlice{"OpFUnordGreaterThanEqual"}; + return true; + } + case SpvOpShiftRightLogical: + { + v = UnownedStringSlice{"OpShiftRightLogical"}; + return true; + } + case SpvOpShiftRightArithmetic: + { + v = UnownedStringSlice{"OpShiftRightArithmetic"}; + return true; + } + case SpvOpShiftLeftLogical: + { + v = UnownedStringSlice{"OpShiftLeftLogical"}; + return true; + } + case SpvOpBitwiseOr: + { + v = UnownedStringSlice{"OpBitwiseOr"}; + return true; + } + case SpvOpBitwiseXor: + { + v = UnownedStringSlice{"OpBitwiseXor"}; + return true; + } + case SpvOpBitwiseAnd: + { + v = UnownedStringSlice{"OpBitwiseAnd"}; + return true; + } + case SpvOpNot: + { + v = UnownedStringSlice{"OpNot"}; + return true; + } + case SpvOpBitFieldInsert: + { + v = UnownedStringSlice{"OpBitFieldInsert"}; + return true; + } + case SpvOpBitFieldSExtract: + { + v = UnownedStringSlice{"OpBitFieldSExtract"}; + return true; + } + case SpvOpBitFieldUExtract: + { + v = UnownedStringSlice{"OpBitFieldUExtract"}; + return true; + } + case SpvOpBitReverse: + { + v = UnownedStringSlice{"OpBitReverse"}; + return true; + } + case SpvOpBitCount: + { + v = UnownedStringSlice{"OpBitCount"}; + return true; + } + case SpvOpDPdx: + { + v = UnownedStringSlice{"OpDPdx"}; + return true; + } + case SpvOpDPdy: + { + v = UnownedStringSlice{"OpDPdy"}; + return true; + } + case SpvOpFwidth: + { + v = UnownedStringSlice{"OpFwidth"}; + return true; + } + case SpvOpDPdxFine: + { + v = UnownedStringSlice{"OpDPdxFine"}; + return true; + } + case SpvOpDPdyFine: + { + v = UnownedStringSlice{"OpDPdyFine"}; + return true; + } + case SpvOpFwidthFine: + { + v = UnownedStringSlice{"OpFwidthFine"}; + return true; + } + case SpvOpDPdxCoarse: + { + v = UnownedStringSlice{"OpDPdxCoarse"}; + return true; + } + case SpvOpDPdyCoarse: + { + v = UnownedStringSlice{"OpDPdyCoarse"}; + return true; + } + case SpvOpFwidthCoarse: + { + v = UnownedStringSlice{"OpFwidthCoarse"}; + return true; + } + case SpvOpEmitVertex: + { + v = UnownedStringSlice{"OpEmitVertex"}; + return true; + } + case SpvOpEndPrimitive: + { + v = UnownedStringSlice{"OpEndPrimitive"}; + return true; + } + case SpvOpEmitStreamVertex: + { + v = UnownedStringSlice{"OpEmitStreamVertex"}; + return true; + } + case SpvOpEndStreamPrimitive: + { + v = UnownedStringSlice{"OpEndStreamPrimitive"}; + return true; + } + case SpvOpControlBarrier: + { + v = UnownedStringSlice{"OpControlBarrier"}; + return true; + } + case SpvOpMemoryBarrier: + { + v = UnownedStringSlice{"OpMemoryBarrier"}; + return true; + } + case SpvOpAtomicLoad: + { + v = UnownedStringSlice{"OpAtomicLoad"}; + return true; + } + case SpvOpAtomicStore: + { + v = UnownedStringSlice{"OpAtomicStore"}; + return true; + } + case SpvOpAtomicExchange: + { + v = UnownedStringSlice{"OpAtomicExchange"}; + return true; + } + case SpvOpAtomicCompareExchange: + { + v = UnownedStringSlice{"OpAtomicCompareExchange"}; + return true; + } + case SpvOpAtomicCompareExchangeWeak: + { + v = UnownedStringSlice{"OpAtomicCompareExchangeWeak"}; + return true; + } + case SpvOpAtomicIIncrement: + { + v = UnownedStringSlice{"OpAtomicIIncrement"}; + return true; + } + case SpvOpAtomicIDecrement: + { + v = UnownedStringSlice{"OpAtomicIDecrement"}; + return true; + } + case SpvOpAtomicIAdd: + { + v = UnownedStringSlice{"OpAtomicIAdd"}; + return true; + } + case SpvOpAtomicISub: + { + v = UnownedStringSlice{"OpAtomicISub"}; + return true; + } + case SpvOpAtomicSMin: + { + v = UnownedStringSlice{"OpAtomicSMin"}; + return true; + } + case SpvOpAtomicUMin: + { + v = UnownedStringSlice{"OpAtomicUMin"}; + return true; + } + case SpvOpAtomicSMax: + { + v = UnownedStringSlice{"OpAtomicSMax"}; + return true; + } + case SpvOpAtomicUMax: + { + v = UnownedStringSlice{"OpAtomicUMax"}; + return true; + } + case SpvOpAtomicAnd: + { + v = UnownedStringSlice{"OpAtomicAnd"}; + return true; + } + case SpvOpAtomicOr: + { + v = UnownedStringSlice{"OpAtomicOr"}; + return true; + } + case SpvOpAtomicXor: + { + v = UnownedStringSlice{"OpAtomicXor"}; + return true; + } + case SpvOpPhi: + { + v = UnownedStringSlice{"OpPhi"}; + return true; + } + case SpvOpLoopMerge: + { + v = UnownedStringSlice{"OpLoopMerge"}; + return true; + } + case SpvOpSelectionMerge: + { + v = UnownedStringSlice{"OpSelectionMerge"}; + return true; + } + case SpvOpLabel: + { + v = UnownedStringSlice{"OpLabel"}; + return true; + } + case SpvOpBranch: + { + v = UnownedStringSlice{"OpBranch"}; + return true; + } + case SpvOpBranchConditional: + { + v = UnownedStringSlice{"OpBranchConditional"}; + return true; + } + case SpvOpSwitch: + { + v = UnownedStringSlice{"OpSwitch"}; + return true; + } + case SpvOpKill: + { + v = UnownedStringSlice{"OpKill"}; + return true; + } + case SpvOpReturn: + { + v = UnownedStringSlice{"OpReturn"}; + return true; + } + case SpvOpReturnValue: + { + v = UnownedStringSlice{"OpReturnValue"}; + return true; + } + case SpvOpUnreachable: + { + v = UnownedStringSlice{"OpUnreachable"}; + return true; + } + case SpvOpLifetimeStart: + { + v = UnownedStringSlice{"OpLifetimeStart"}; + return true; + } + case SpvOpLifetimeStop: + { + v = UnownedStringSlice{"OpLifetimeStop"}; + return true; + } + case SpvOpGroupAsyncCopy: + { + v = UnownedStringSlice{"OpGroupAsyncCopy"}; + return true; + } + case SpvOpGroupWaitEvents: + { + v = UnownedStringSlice{"OpGroupWaitEvents"}; + return true; + } + case SpvOpGroupAll: + { + v = UnownedStringSlice{"OpGroupAll"}; + return true; + } + case SpvOpGroupAny: + { + v = UnownedStringSlice{"OpGroupAny"}; + return true; + } + case SpvOpGroupBroadcast: + { + v = UnownedStringSlice{"OpGroupBroadcast"}; + return true; + } + case SpvOpGroupIAdd: + { + v = UnownedStringSlice{"OpGroupIAdd"}; + return true; + } + case SpvOpGroupFAdd: + { + v = UnownedStringSlice{"OpGroupFAdd"}; + return true; + } + case SpvOpGroupFMin: + { + v = UnownedStringSlice{"OpGroupFMin"}; + return true; + } + case SpvOpGroupUMin: + { + v = UnownedStringSlice{"OpGroupUMin"}; + return true; + } + case SpvOpGroupSMin: + { + v = UnownedStringSlice{"OpGroupSMin"}; + return true; + } + case SpvOpGroupFMax: + { + v = UnownedStringSlice{"OpGroupFMax"}; + return true; + } + case SpvOpGroupUMax: + { + v = UnownedStringSlice{"OpGroupUMax"}; + return true; + } + case SpvOpGroupSMax: + { + v = UnownedStringSlice{"OpGroupSMax"}; + return true; + } + case SpvOpReadPipe: + { + v = UnownedStringSlice{"OpReadPipe"}; + return true; + } + case SpvOpWritePipe: + { + v = UnownedStringSlice{"OpWritePipe"}; + return true; + } + case SpvOpReservedReadPipe: + { + v = UnownedStringSlice{"OpReservedReadPipe"}; + return true; + } + case SpvOpReservedWritePipe: + { + v = UnownedStringSlice{"OpReservedWritePipe"}; + return true; + } + case SpvOpReserveReadPipePackets: + { + v = UnownedStringSlice{"OpReserveReadPipePackets"}; + return true; + } + case SpvOpReserveWritePipePackets: + { + v = UnownedStringSlice{"OpReserveWritePipePackets"}; + return true; + } + case SpvOpCommitReadPipe: + { + v = UnownedStringSlice{"OpCommitReadPipe"}; + return true; + } + case SpvOpCommitWritePipe: + { + v = UnownedStringSlice{"OpCommitWritePipe"}; + return true; + } + case SpvOpIsValidReserveId: + { + v = UnownedStringSlice{"OpIsValidReserveId"}; + return true; + } + case SpvOpGetNumPipePackets: + { + v = UnownedStringSlice{"OpGetNumPipePackets"}; + return true; + } + case SpvOpGetMaxPipePackets: + { + v = UnownedStringSlice{"OpGetMaxPipePackets"}; + return true; + } + case SpvOpGroupReserveReadPipePackets: + { + v = UnownedStringSlice{"OpGroupReserveReadPipePackets"}; + return true; + } + case SpvOpGroupReserveWritePipePackets: + { + v = UnownedStringSlice{"OpGroupReserveWritePipePackets"}; + return true; + } + case SpvOpGroupCommitReadPipe: + { + v = UnownedStringSlice{"OpGroupCommitReadPipe"}; + return true; + } + case SpvOpGroupCommitWritePipe: + { + v = UnownedStringSlice{"OpGroupCommitWritePipe"}; + return true; + } + case SpvOpEnqueueMarker: + { + v = UnownedStringSlice{"OpEnqueueMarker"}; + return true; + } + case SpvOpEnqueueKernel: + { + v = UnownedStringSlice{"OpEnqueueKernel"}; + return true; + } + case SpvOpGetKernelNDrangeSubGroupCount: + { + v = UnownedStringSlice{"OpGetKernelNDrangeSubGroupCount"}; + return true; + } + case SpvOpGetKernelNDrangeMaxSubGroupSize: + { + v = UnownedStringSlice{"OpGetKernelNDrangeMaxSubGroupSize"}; + return true; + } + case SpvOpGetKernelWorkGroupSize: + { + v = UnownedStringSlice{"OpGetKernelWorkGroupSize"}; + return true; + } + case SpvOpGetKernelPreferredWorkGroupSizeMultiple: + { + v = UnownedStringSlice{"OpGetKernelPreferredWorkGroupSizeMultiple"}; + return true; + } + case SpvOpRetainEvent: + { + v = UnownedStringSlice{"OpRetainEvent"}; + return true; + } + case SpvOpReleaseEvent: + { + v = UnownedStringSlice{"OpReleaseEvent"}; + return true; + } + case SpvOpCreateUserEvent: + { + v = UnownedStringSlice{"OpCreateUserEvent"}; + return true; + } + case SpvOpIsValidEvent: + { + v = UnownedStringSlice{"OpIsValidEvent"}; + return true; + } + case SpvOpSetUserEventStatus: + { + v = UnownedStringSlice{"OpSetUserEventStatus"}; + return true; + } + case SpvOpCaptureEventProfilingInfo: + { + v = UnownedStringSlice{"OpCaptureEventProfilingInfo"}; + return true; + } + case SpvOpGetDefaultQueue: + { + v = UnownedStringSlice{"OpGetDefaultQueue"}; + return true; + } + case SpvOpBuildNDRange: + { + v = UnownedStringSlice{"OpBuildNDRange"}; + return true; + } + case SpvOpImageSparseSampleImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleDrefImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleDrefExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjDrefImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjDrefExplicitLod"}; + return true; + } + case SpvOpImageSparseFetch: + { + v = UnownedStringSlice{"OpImageSparseFetch"}; + return true; + } + case SpvOpImageSparseGather: + { + v = UnownedStringSlice{"OpImageSparseGather"}; + return true; + } + case SpvOpImageSparseDrefGather: + { + v = UnownedStringSlice{"OpImageSparseDrefGather"}; + return true; + } + case SpvOpImageSparseTexelsResident: + { + v = UnownedStringSlice{"OpImageSparseTexelsResident"}; + return true; + } + case SpvOpNoLine: + { + v = UnownedStringSlice{"OpNoLine"}; + return true; + } + case SpvOpAtomicFlagTestAndSet: + { + v = UnownedStringSlice{"OpAtomicFlagTestAndSet"}; + return true; + } + case SpvOpAtomicFlagClear: + { + v = UnownedStringSlice{"OpAtomicFlagClear"}; + return true; + } + case SpvOpImageSparseRead: + { + v = UnownedStringSlice{"OpImageSparseRead"}; + return true; + } + case SpvOpSizeOf: + { + v = UnownedStringSlice{"OpSizeOf"}; + return true; + } + case SpvOpTypePipeStorage: + { + v = UnownedStringSlice{"OpTypePipeStorage"}; + return true; + } + case SpvOpConstantPipeStorage: + { + v = UnownedStringSlice{"OpConstantPipeStorage"}; + return true; + } + case SpvOpCreatePipeFromPipeStorage: + { + v = UnownedStringSlice{"OpCreatePipeFromPipeStorage"}; + return true; + } + case SpvOpGetKernelLocalSizeForSubgroupCount: + { + v = UnownedStringSlice{"OpGetKernelLocalSizeForSubgroupCount"}; + return true; + } + case SpvOpGetKernelMaxNumSubgroups: + { + v = UnownedStringSlice{"OpGetKernelMaxNumSubgroups"}; + return true; + } + case SpvOpTypeNamedBarrier: + { + v = UnownedStringSlice{"OpTypeNamedBarrier"}; + return true; + } + case SpvOpNamedBarrierInitialize: + { + v = UnownedStringSlice{"OpNamedBarrierInitialize"}; + return true; + } + case SpvOpMemoryNamedBarrier: + { + v = UnownedStringSlice{"OpMemoryNamedBarrier"}; + return true; + } + case SpvOpModuleProcessed: + { + v = UnownedStringSlice{"OpModuleProcessed"}; + return true; + } + case SpvOpExecutionModeId: + { + v = UnownedStringSlice{"OpExecutionModeId"}; + return true; + } + case SpvOpDecorateId: + { + v = UnownedStringSlice{"OpDecorateId"}; + return true; + } + case SpvOpGroupNonUniformElect: + { + v = UnownedStringSlice{"OpGroupNonUniformElect"}; + return true; + } + case SpvOpGroupNonUniformAll: + { + v = UnownedStringSlice{"OpGroupNonUniformAll"}; + return true; + } + case SpvOpGroupNonUniformAny: + { + v = UnownedStringSlice{"OpGroupNonUniformAny"}; + return true; + } + case SpvOpGroupNonUniformAllEqual: + { + v = UnownedStringSlice{"OpGroupNonUniformAllEqual"}; + return true; + } + case SpvOpGroupNonUniformBroadcast: + { + v = UnownedStringSlice{"OpGroupNonUniformBroadcast"}; + return true; + } + case SpvOpGroupNonUniformBroadcastFirst: + { + v = UnownedStringSlice{"OpGroupNonUniformBroadcastFirst"}; + return true; + } + case SpvOpGroupNonUniformBallot: + { + v = UnownedStringSlice{"OpGroupNonUniformBallot"}; + return true; + } + case SpvOpGroupNonUniformInverseBallot: + { + v = UnownedStringSlice{"OpGroupNonUniformInverseBallot"}; + return true; + } + case SpvOpGroupNonUniformBallotBitExtract: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotBitExtract"}; + return true; + } + case SpvOpGroupNonUniformBallotBitCount: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotBitCount"}; + return true; + } + case SpvOpGroupNonUniformBallotFindLSB: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotFindLSB"}; + return true; + } + case SpvOpGroupNonUniformBallotFindMSB: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotFindMSB"}; + return true; + } + case SpvOpGroupNonUniformShuffle: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffle"}; + return true; + } + case SpvOpGroupNonUniformShuffleXor: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleXor"}; + return true; + } + case SpvOpGroupNonUniformShuffleUp: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleUp"}; + return true; + } + case SpvOpGroupNonUniformShuffleDown: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleDown"}; + return true; + } + case SpvOpGroupNonUniformIAdd: + { + v = UnownedStringSlice{"OpGroupNonUniformIAdd"}; + return true; + } + case SpvOpGroupNonUniformFAdd: + { + v = UnownedStringSlice{"OpGroupNonUniformFAdd"}; + return true; + } + case SpvOpGroupNonUniformIMul: + { + v = UnownedStringSlice{"OpGroupNonUniformIMul"}; + return true; + } + case SpvOpGroupNonUniformFMul: + { + v = UnownedStringSlice{"OpGroupNonUniformFMul"}; + return true; + } + case SpvOpGroupNonUniformSMin: + { + v = UnownedStringSlice{"OpGroupNonUniformSMin"}; + return true; + } + case SpvOpGroupNonUniformUMin: + { + v = UnownedStringSlice{"OpGroupNonUniformUMin"}; + return true; + } + case SpvOpGroupNonUniformFMin: + { + v = UnownedStringSlice{"OpGroupNonUniformFMin"}; + return true; + } + case SpvOpGroupNonUniformSMax: + { + v = UnownedStringSlice{"OpGroupNonUniformSMax"}; + return true; + } + case SpvOpGroupNonUniformUMax: + { + v = UnownedStringSlice{"OpGroupNonUniformUMax"}; + return true; + } + case SpvOpGroupNonUniformFMax: + { + v = UnownedStringSlice{"OpGroupNonUniformFMax"}; + return true; + } + case SpvOpGroupNonUniformBitwiseAnd: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseAnd"}; + return true; + } + case SpvOpGroupNonUniformBitwiseOr: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseOr"}; + return true; + } + case SpvOpGroupNonUniformBitwiseXor: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseXor"}; + return true; + } + case SpvOpGroupNonUniformLogicalAnd: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalAnd"}; + return true; + } + case SpvOpGroupNonUniformLogicalOr: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalOr"}; + return true; + } + case SpvOpGroupNonUniformLogicalXor: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalXor"}; + return true; + } + case SpvOpGroupNonUniformQuadBroadcast: + { + v = UnownedStringSlice{"OpGroupNonUniformQuadBroadcast"}; + return true; + } + case SpvOpGroupNonUniformQuadSwap: + { + v = UnownedStringSlice{"OpGroupNonUniformQuadSwap"}; + return true; + } + case SpvOpCopyLogical: + { + v = UnownedStringSlice{"OpCopyLogical"}; + return true; + } + case SpvOpPtrEqual: + { + v = UnownedStringSlice{"OpPtrEqual"}; + return true; + } + case SpvOpPtrNotEqual: + { + v = UnownedStringSlice{"OpPtrNotEqual"}; + return true; + } + case SpvOpPtrDiff: + { + v = UnownedStringSlice{"OpPtrDiff"}; + return true; + } + case SpvOpColorAttachmentReadEXT: + { + v = UnownedStringSlice{"OpColorAttachmentReadEXT"}; + return true; + } + case SpvOpDepthAttachmentReadEXT: + { + v = UnownedStringSlice{"OpDepthAttachmentReadEXT"}; + return true; + } + case SpvOpStencilAttachmentReadEXT: + { + v = UnownedStringSlice{"OpStencilAttachmentReadEXT"}; + return true; + } + case SpvOpTerminateInvocation: + { + v = UnownedStringSlice{"OpTerminateInvocation"}; + return true; + } + case SpvOpSubgroupBallotKHR: + { + v = UnownedStringSlice{"OpSubgroupBallotKHR"}; + return true; + } + case SpvOpSubgroupFirstInvocationKHR: + { + v = UnownedStringSlice{"OpSubgroupFirstInvocationKHR"}; + return true; + } + case SpvOpSubgroupAllKHR: + { + v = UnownedStringSlice{"OpSubgroupAllKHR"}; + return true; + } + case SpvOpSubgroupAnyKHR: + { + v = UnownedStringSlice{"OpSubgroupAnyKHR"}; + return true; + } + case SpvOpSubgroupAllEqualKHR: + { + v = UnownedStringSlice{"OpSubgroupAllEqualKHR"}; + return true; + } + case SpvOpGroupNonUniformRotateKHR: + { + v = UnownedStringSlice{"OpGroupNonUniformRotateKHR"}; + return true; + } + case SpvOpSubgroupReadInvocationKHR: + { + v = UnownedStringSlice{"OpSubgroupReadInvocationKHR"}; + return true; + } + case SpvOpTraceRayKHR: + { + v = UnownedStringSlice{"OpTraceRayKHR"}; + return true; + } + case SpvOpExecuteCallableKHR: + { + v = UnownedStringSlice{"OpExecuteCallableKHR"}; + return true; + } + case SpvOpConvertUToAccelerationStructureKHR: + { + v = UnownedStringSlice{"OpConvertUToAccelerationStructureKHR"}; + return true; + } + case SpvOpIgnoreIntersectionKHR: + { + v = UnownedStringSlice{"OpIgnoreIntersectionKHR"}; + return true; + } + case SpvOpTerminateRayKHR: + { + v = UnownedStringSlice{"OpTerminateRayKHR"}; + return true; + } + case SpvOpSDot: + { + v = UnownedStringSlice{"OpSDot"}; + return true; + } + case SpvOpUDot: + { + v = UnownedStringSlice{"OpUDot"}; + return true; + } + case SpvOpSUDot: + { + v = UnownedStringSlice{"OpSUDot"}; + return true; + } + case SpvOpSDotAccSat: + { + v = UnownedStringSlice{"OpSDotAccSat"}; + return true; + } + case SpvOpUDotAccSat: + { + v = UnownedStringSlice{"OpUDotAccSat"}; + return true; + } + case SpvOpSUDotAccSat: + { + v = UnownedStringSlice{"OpSUDotAccSat"}; + return true; + } + case SpvOpTypeCooperativeMatrixKHR: + { + v = UnownedStringSlice{"OpTypeCooperativeMatrixKHR"}; + return true; + } + case SpvOpCooperativeMatrixLoadKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixLoadKHR"}; + return true; + } + case SpvOpCooperativeMatrixStoreKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixStoreKHR"}; + return true; + } + case SpvOpCooperativeMatrixMulAddKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixMulAddKHR"}; + return true; + } + case SpvOpCooperativeMatrixLengthKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixLengthKHR"}; + return true; + } + case SpvOpTypeRayQueryKHR: + { + v = UnownedStringSlice{"OpTypeRayQueryKHR"}; + return true; + } + case SpvOpRayQueryInitializeKHR: + { + v = UnownedStringSlice{"OpRayQueryInitializeKHR"}; + return true; + } + case SpvOpRayQueryTerminateKHR: + { + v = UnownedStringSlice{"OpRayQueryTerminateKHR"}; + return true; + } + case SpvOpRayQueryGenerateIntersectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGenerateIntersectionKHR"}; + return true; + } + case SpvOpRayQueryConfirmIntersectionKHR: + { + v = UnownedStringSlice{"OpRayQueryConfirmIntersectionKHR"}; + return true; + } + case SpvOpRayQueryProceedKHR: + { + v = UnownedStringSlice{"OpRayQueryProceedKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionTypeKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTypeKHR"}; + return true; + } + case SpvOpImageSampleWeightedQCOM: + { + v = UnownedStringSlice{"OpImageSampleWeightedQCOM"}; + return true; + } + case SpvOpImageBoxFilterQCOM: + { + v = UnownedStringSlice{"OpImageBoxFilterQCOM"}; + return true; + } + case SpvOpImageBlockMatchSSDQCOM: + { + v = UnownedStringSlice{"OpImageBlockMatchSSDQCOM"}; + return true; + } + case SpvOpImageBlockMatchSADQCOM: + { + v = UnownedStringSlice{"OpImageBlockMatchSADQCOM"}; + return true; + } + case SpvOpGroupIAddNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupIAddNonUniformAMD"}; + return true; + } + case SpvOpGroupFAddNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFAddNonUniformAMD"}; + return true; + } + case SpvOpGroupFMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFMinNonUniformAMD"}; + return true; + } + case SpvOpGroupUMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupUMinNonUniformAMD"}; + return true; + } + case SpvOpGroupSMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupSMinNonUniformAMD"}; + return true; + } + case SpvOpGroupFMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFMaxNonUniformAMD"}; + return true; + } + case SpvOpGroupUMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupUMaxNonUniformAMD"}; + return true; + } + case SpvOpGroupSMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupSMaxNonUniformAMD"}; + return true; + } + case SpvOpFragmentMaskFetchAMD: + { + v = UnownedStringSlice{"OpFragmentMaskFetchAMD"}; + return true; + } + case SpvOpFragmentFetchAMD: + { + v = UnownedStringSlice{"OpFragmentFetchAMD"}; + return true; + } + case SpvOpReadClockKHR: + { + v = UnownedStringSlice{"OpReadClockKHR"}; + return true; + } + case SpvOpHitObjectRecordHitMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitMotionNV"}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitWithIndexMotionNV"}; + return true; + } + case SpvOpHitObjectRecordMissMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordMissMotionNV"}; + return true; + } + case SpvOpHitObjectGetWorldToObjectNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldToObjectNV"}; + return true; + } + case SpvOpHitObjectGetObjectToWorldNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectToWorldNV"}; + return true; + } + case SpvOpHitObjectGetObjectRayDirectionNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectRayDirectionNV"}; + return true; + } + case SpvOpHitObjectGetObjectRayOriginNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectRayOriginNV"}; + return true; + } + case SpvOpHitObjectTraceRayMotionNV: + { + v = UnownedStringSlice{"OpHitObjectTraceRayMotionNV"}; + return true; + } + case SpvOpHitObjectGetShaderRecordBufferHandleNV: + { + v = UnownedStringSlice{"OpHitObjectGetShaderRecordBufferHandleNV"}; + return true; + } + case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetShaderBindingTableRecordIndexNV"}; + return true; + } + case SpvOpHitObjectRecordEmptyNV: + { + v = UnownedStringSlice{"OpHitObjectRecordEmptyNV"}; + return true; + } + case SpvOpHitObjectTraceRayNV: + { + v = UnownedStringSlice{"OpHitObjectTraceRayNV"}; + return true; + } + case SpvOpHitObjectRecordHitNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitNV"}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitWithIndexNV"}; + return true; + } + case SpvOpHitObjectRecordMissNV: + { + v = UnownedStringSlice{"OpHitObjectRecordMissNV"}; + return true; + } + case SpvOpHitObjectExecuteShaderNV: + { + v = UnownedStringSlice{"OpHitObjectExecuteShaderNV"}; + return true; + } + case SpvOpHitObjectGetCurrentTimeNV: + { + v = UnownedStringSlice{"OpHitObjectGetCurrentTimeNV"}; + return true; + } + case SpvOpHitObjectGetAttributesNV: + { + v = UnownedStringSlice{"OpHitObjectGetAttributesNV"}; + return true; + } + case SpvOpHitObjectGetHitKindNV: + { + v = UnownedStringSlice{"OpHitObjectGetHitKindNV"}; + return true; + } + case SpvOpHitObjectGetPrimitiveIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetPrimitiveIndexNV"}; + return true; + } + case SpvOpHitObjectGetGeometryIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetGeometryIndexNV"}; + return true; + } + case SpvOpHitObjectGetInstanceIdNV: + { + v = UnownedStringSlice{"OpHitObjectGetInstanceIdNV"}; + return true; + } + case SpvOpHitObjectGetInstanceCustomIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetInstanceCustomIndexNV"}; + return true; + } + case SpvOpHitObjectGetWorldRayDirectionNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldRayDirectionNV"}; + return true; + } + case SpvOpHitObjectGetWorldRayOriginNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldRayOriginNV"}; + return true; + } + case SpvOpHitObjectGetRayTMaxNV: + { + v = UnownedStringSlice{"OpHitObjectGetRayTMaxNV"}; + return true; + } + case SpvOpHitObjectGetRayTMinNV: + { + v = UnownedStringSlice{"OpHitObjectGetRayTMinNV"}; + return true; + } + case SpvOpHitObjectIsEmptyNV: + { + v = UnownedStringSlice{"OpHitObjectIsEmptyNV"}; + return true; + } + case SpvOpHitObjectIsHitNV: + { + v = UnownedStringSlice{"OpHitObjectIsHitNV"}; + return true; + } + case SpvOpHitObjectIsMissNV: + { + v = UnownedStringSlice{"OpHitObjectIsMissNV"}; + return true; + } + case SpvOpReorderThreadWithHitObjectNV: + { + v = UnownedStringSlice{"OpReorderThreadWithHitObjectNV"}; + return true; + } + case SpvOpReorderThreadWithHintNV: + { + v = UnownedStringSlice{"OpReorderThreadWithHintNV"}; + return true; + } + case SpvOpTypeHitObjectNV: + { + v = UnownedStringSlice{"OpTypeHitObjectNV"}; + return true; + } + case SpvOpImageSampleFootprintNV: + { + v = UnownedStringSlice{"OpImageSampleFootprintNV"}; + return true; + } + case SpvOpEmitMeshTasksEXT: + { + v = UnownedStringSlice{"OpEmitMeshTasksEXT"}; + return true; + } + case SpvOpSetMeshOutputsEXT: + { + v = UnownedStringSlice{"OpSetMeshOutputsEXT"}; + return true; + } + case SpvOpGroupNonUniformPartitionNV: + { + v = UnownedStringSlice{"OpGroupNonUniformPartitionNV"}; + return true; + } + case SpvOpWritePackedPrimitiveIndices4x8NV: + { + v = UnownedStringSlice{"OpWritePackedPrimitiveIndices4x8NV"}; + return true; + } + case SpvOpReportIntersectionNV: + { + v = UnownedStringSlice{"OpReportIntersectionNV"}; + return true; + } + case SpvOpIgnoreIntersectionNV: + { + v = UnownedStringSlice{"OpIgnoreIntersectionNV"}; + return true; + } + case SpvOpTerminateRayNV: + { + v = UnownedStringSlice{"OpTerminateRayNV"}; + return true; + } + case SpvOpTraceNV: + { + v = UnownedStringSlice{"OpTraceNV"}; + return true; + } + case SpvOpTraceMotionNV: + { + v = UnownedStringSlice{"OpTraceMotionNV"}; + return true; + } + case SpvOpTraceRayMotionNV: + { + v = UnownedStringSlice{"OpTraceRayMotionNV"}; + return true; + } + case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTriangleVertexPositionsKHR"}; + return true; + } + case SpvOpTypeAccelerationStructureNV: + { + v = UnownedStringSlice{"OpTypeAccelerationStructureNV"}; + return true; + } + case SpvOpExecuteCallableNV: + { + v = UnownedStringSlice{"OpExecuteCallableNV"}; + return true; + } + case SpvOpTypeCooperativeMatrixNV: + { + v = UnownedStringSlice{"OpTypeCooperativeMatrixNV"}; + return true; + } + case SpvOpCooperativeMatrixLoadNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixLoadNV"}; + return true; + } + case SpvOpCooperativeMatrixStoreNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixStoreNV"}; + return true; + } + case SpvOpCooperativeMatrixMulAddNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixMulAddNV"}; + return true; + } + case SpvOpCooperativeMatrixLengthNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixLengthNV"}; + return true; + } + case SpvOpBeginInvocationInterlockEXT: + { + v = UnownedStringSlice{"OpBeginInvocationInterlockEXT"}; + return true; + } + case SpvOpEndInvocationInterlockEXT: + { + v = UnownedStringSlice{"OpEndInvocationInterlockEXT"}; + return true; + } + case SpvOpDemoteToHelperInvocation: + { + v = UnownedStringSlice{"OpDemoteToHelperInvocation"}; + return true; + } + case SpvOpIsHelperInvocationEXT: + { + v = UnownedStringSlice{"OpIsHelperInvocationEXT"}; + return true; + } + case SpvOpConvertUToImageNV: + { + v = UnownedStringSlice{"OpConvertUToImageNV"}; + return true; + } + case SpvOpConvertUToSamplerNV: + { + v = UnownedStringSlice{"OpConvertUToSamplerNV"}; + return true; + } + case SpvOpConvertImageToUNV: + { + v = UnownedStringSlice{"OpConvertImageToUNV"}; + return true; + } + case SpvOpConvertSamplerToUNV: + { + v = UnownedStringSlice{"OpConvertSamplerToUNV"}; + return true; + } + case SpvOpConvertUToSampledImageNV: + { + v = UnownedStringSlice{"OpConvertUToSampledImageNV"}; + return true; + } + case SpvOpConvertSampledImageToUNV: + { + v = UnownedStringSlice{"OpConvertSampledImageToUNV"}; + return true; + } + case SpvOpSamplerImageAddressingModeNV: + { + v = UnownedStringSlice{"OpSamplerImageAddressingModeNV"}; + return true; + } + case SpvOpSubgroupShuffleINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleINTEL"}; + return true; + } + case SpvOpSubgroupShuffleDownINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleDownINTEL"}; + return true; + } + case SpvOpSubgroupShuffleUpINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleUpINTEL"}; + return true; + } + case SpvOpSubgroupShuffleXorINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleXorINTEL"}; + return true; + } + case SpvOpSubgroupBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupBlockWriteINTEL"}; + return true; + } + case SpvOpSubgroupImageBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupImageBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageBlockWriteINTEL"}; + return true; + } + case SpvOpSubgroupImageMediaBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageMediaBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupImageMediaBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageMediaBlockWriteINTEL"}; + return true; + } + case SpvOpUCountLeadingZerosINTEL: + { + v = UnownedStringSlice{"OpUCountLeadingZerosINTEL"}; + return true; + } + case SpvOpUCountTrailingZerosINTEL: + { + v = UnownedStringSlice{"OpUCountTrailingZerosINTEL"}; + return true; + } + case SpvOpAbsISubINTEL: + { + v = UnownedStringSlice{"OpAbsISubINTEL"}; + return true; + } + case SpvOpAbsUSubINTEL: + { + v = UnownedStringSlice{"OpAbsUSubINTEL"}; + return true; + } + case SpvOpIAddSatINTEL: + { + v = UnownedStringSlice{"OpIAddSatINTEL"}; + return true; + } + case SpvOpUAddSatINTEL: + { + v = UnownedStringSlice{"OpUAddSatINTEL"}; + return true; + } + case SpvOpIAverageINTEL: + { + v = UnownedStringSlice{"OpIAverageINTEL"}; + return true; + } + case SpvOpUAverageINTEL: + { + v = UnownedStringSlice{"OpUAverageINTEL"}; + return true; + } + case SpvOpIAverageRoundedINTEL: + { + v = UnownedStringSlice{"OpIAverageRoundedINTEL"}; + return true; + } + case SpvOpUAverageRoundedINTEL: + { + v = UnownedStringSlice{"OpUAverageRoundedINTEL"}; + return true; + } + case SpvOpISubSatINTEL: + { + v = UnownedStringSlice{"OpISubSatINTEL"}; + return true; + } + case SpvOpUSubSatINTEL: + { + v = UnownedStringSlice{"OpUSubSatINTEL"}; + return true; + } + case SpvOpIMul32x16INTEL: + { + v = UnownedStringSlice{"OpIMul32x16INTEL"}; + return true; + } + case SpvOpUMul32x16INTEL: + { + v = UnownedStringSlice{"OpUMul32x16INTEL"}; + return true; + } + case SpvOpConstantFunctionPointerINTEL: + { + v = UnownedStringSlice{"OpConstantFunctionPointerINTEL"}; + return true; + } + case SpvOpFunctionPointerCallINTEL: + { + v = UnownedStringSlice{"OpFunctionPointerCallINTEL"}; + return true; + } + case SpvOpAsmTargetINTEL: + { + v = UnownedStringSlice{"OpAsmTargetINTEL"}; + return true; + } + case SpvOpAsmINTEL: + { + v = UnownedStringSlice{"OpAsmINTEL"}; + return true; + } + case SpvOpAsmCallINTEL: + { + v = UnownedStringSlice{"OpAsmCallINTEL"}; + return true; + } + case SpvOpAtomicFMinEXT: + { + v = UnownedStringSlice{"OpAtomicFMinEXT"}; + return true; + } + case SpvOpAtomicFMaxEXT: + { + v = UnownedStringSlice{"OpAtomicFMaxEXT"}; + return true; + } + case SpvOpAssumeTrueKHR: + { + v = UnownedStringSlice{"OpAssumeTrueKHR"}; + return true; + } + case SpvOpExpectKHR: + { + v = UnownedStringSlice{"OpExpectKHR"}; + return true; + } + case SpvOpDecorateString: + { + v = UnownedStringSlice{"OpDecorateString"}; + return true; + } + case SpvOpMemberDecorateString: + { + v = UnownedStringSlice{"OpMemberDecorateString"}; + return true; + } + case SpvOpVmeImageINTEL: + { + v = UnownedStringSlice{"OpVmeImageINTEL"}; + return true; + } + case SpvOpTypeVmeImageINTEL: + { + v = UnownedStringSlice{"OpTypeVmeImageINTEL"}; + return true; + } + case SpvOpTypeAvcImePayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImePayloadINTEL"}; + return true; + } + case SpvOpTypeAvcRefPayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcRefPayloadINTEL"}; + return true; + } + case SpvOpTypeAvcSicPayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcSicPayloadINTEL"}; + return true; + } + case SpvOpTypeAvcMcePayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcMcePayloadINTEL"}; + return true; + } + case SpvOpTypeAvcMceResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcMceResultINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpTypeAvcImeDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpTypeAvcRefResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcRefResultINTEL"}; + return true; + } + case SpvOpTypeAvcSicResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcSicResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetAcOnlyHaarINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToImePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImeResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToImeResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToRefPayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToRefResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToSicPayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToSicResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetBestInterDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMajorShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMinorShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterDirectionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMotionVectorCountINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeRefWindowSizeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeRefWindowSizeINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeAdjustRefOffsetINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetWeightedSadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetWeightedSadINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetBorderReachedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetBorderReachedINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcFmeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcFmeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcBmeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcBmeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefSetBilinearFilterEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureSkcINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureSkcINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureIpeLumaINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetMotionVectorMaskINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetBilinearFilterEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateIpeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateIpeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetIpeLumaShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetIpeChromaModeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetInterRawSadsINTEL"}; + return true; + } + case SpvOpVariableLengthArrayINTEL: + { + v = UnownedStringSlice{"OpVariableLengthArrayINTEL"}; + return true; + } + case SpvOpSaveMemoryINTEL: + { + v = UnownedStringSlice{"OpSaveMemoryINTEL"}; + return true; + } + case SpvOpRestoreMemoryINTEL: + { + v = UnownedStringSlice{"OpRestoreMemoryINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinCosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinCosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastFromIntINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastFromIntINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastToIntINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastToIntINTEL"}; + return true; + } + case SpvOpArbitraryFloatAddINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatAddINTEL"}; + return true; + } + case SpvOpArbitraryFloatSubINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSubINTEL"}; + return true; + } + case SpvOpArbitraryFloatMulINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatMulINTEL"}; + return true; + } + case SpvOpArbitraryFloatDivINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatDivINTEL"}; + return true; + } + case SpvOpArbitraryFloatGTINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatGTINTEL"}; + return true; + } + case SpvOpArbitraryFloatGEINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatGEINTEL"}; + return true; + } + case SpvOpArbitraryFloatLTINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLTINTEL"}; + return true; + } + case SpvOpArbitraryFloatLEINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLEINTEL"}; + return true; + } + case SpvOpArbitraryFloatEQINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatEQINTEL"}; + return true; + } + case SpvOpArbitraryFloatRecipINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatRecipINTEL"}; + return true; + } + case SpvOpArbitraryFloatRSqrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatRSqrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatCbrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCbrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatHypotINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatHypotINTEL"}; + return true; + } + case SpvOpArbitraryFloatSqrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSqrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatLogINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLogINTEL"}; + return true; + } + case SpvOpArbitraryFloatLog2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog2INTEL"}; + return true; + } + case SpvOpArbitraryFloatLog10INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog10INTEL"}; + return true; + } + case SpvOpArbitraryFloatLog1pINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog1pINTEL"}; + return true; + } + case SpvOpArbitraryFloatExpINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExpINTEL"}; + return true; + } + case SpvOpArbitraryFloatExp2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExp2INTEL"}; + return true; + } + case SpvOpArbitraryFloatExp10INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExp10INTEL"}; + return true; + } + case SpvOpArbitraryFloatExpm1INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExpm1INTEL"}; + return true; + } + case SpvOpArbitraryFloatSinINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinINTEL"}; + return true; + } + case SpvOpArbitraryFloatCosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCosINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinCosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinCosINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatCosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatASinINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatASinINTEL"}; + return true; + } + case SpvOpArbitraryFloatASinPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatASinPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatACosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatACosINTEL"}; + return true; + } + case SpvOpArbitraryFloatACosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatACosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatATanINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATanINTEL"}; + return true; + } + case SpvOpArbitraryFloatATanPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATanPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatATan2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATan2INTEL"}; + return true; + } + case SpvOpArbitraryFloatPowINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowINTEL"}; + return true; + } + case SpvOpArbitraryFloatPowRINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowRINTEL"}; + return true; + } + case SpvOpArbitraryFloatPowNINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowNINTEL"}; + return true; + } + case SpvOpLoopControlINTEL: + { + v = UnownedStringSlice{"OpLoopControlINTEL"}; + return true; + } + case SpvOpAliasDomainDeclINTEL: + { + v = UnownedStringSlice{"OpAliasDomainDeclINTEL"}; + return true; + } + case SpvOpAliasScopeDeclINTEL: + { + v = UnownedStringSlice{"OpAliasScopeDeclINTEL"}; + return true; + } + case SpvOpAliasScopeListDeclINTEL: + { + v = UnownedStringSlice{"OpAliasScopeListDeclINTEL"}; + return true; + } + case SpvOpFixedSqrtINTEL: + { + v = UnownedStringSlice{"OpFixedSqrtINTEL"}; + return true; + } + case SpvOpFixedRecipINTEL: + { + v = UnownedStringSlice{"OpFixedRecipINTEL"}; + return true; + } + case SpvOpFixedRsqrtINTEL: + { + v = UnownedStringSlice{"OpFixedRsqrtINTEL"}; + return true; + } + case SpvOpFixedSinINTEL: + { + v = UnownedStringSlice{"OpFixedSinINTEL"}; + return true; + } + case SpvOpFixedCosINTEL: + { + v = UnownedStringSlice{"OpFixedCosINTEL"}; + return true; + } + case SpvOpFixedSinCosINTEL: + { + v = UnownedStringSlice{"OpFixedSinCosINTEL"}; + return true; + } + case SpvOpFixedSinPiINTEL: + { + v = UnownedStringSlice{"OpFixedSinPiINTEL"}; + return true; + } + case SpvOpFixedCosPiINTEL: + { + v = UnownedStringSlice{"OpFixedCosPiINTEL"}; + return true; + } + case SpvOpFixedSinCosPiINTEL: + { + v = UnownedStringSlice{"OpFixedSinCosPiINTEL"}; + return true; + } + case SpvOpFixedLogINTEL: + { + v = UnownedStringSlice{"OpFixedLogINTEL"}; + return true; + } + case SpvOpFixedExpINTEL: + { + v = UnownedStringSlice{"OpFixedExpINTEL"}; + return true; + } + case SpvOpPtrCastToCrossWorkgroupINTEL: + { + v = UnownedStringSlice{"OpPtrCastToCrossWorkgroupINTEL"}; + return true; + } + case SpvOpCrossWorkgroupCastToPtrINTEL: + { + v = UnownedStringSlice{"OpCrossWorkgroupCastToPtrINTEL"}; + return true; + } + case SpvOpReadPipeBlockingINTEL: + { + v = UnownedStringSlice{"OpReadPipeBlockingINTEL"}; + return true; + } + case SpvOpWritePipeBlockingINTEL: + { + v = UnownedStringSlice{"OpWritePipeBlockingINTEL"}; + return true; + } + case SpvOpFPGARegINTEL: + { + v = UnownedStringSlice{"OpFPGARegINTEL"}; + return true; + } + case SpvOpRayQueryGetRayTMinKHR: + { + v = UnownedStringSlice{"OpRayQueryGetRayTMinKHR"}; + return true; + } + case SpvOpRayQueryGetRayFlagsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetRayFlagsKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionTKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceCustomIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceIdKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceIdKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionGeometryIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionGeometryIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionPrimitiveIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionBarycentricsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionBarycentricsKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionFrontFaceKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionFrontFaceKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectRayDirectionKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectRayOriginKHR"}; + return true; + } + case SpvOpRayQueryGetWorldRayDirectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGetWorldRayDirectionKHR"}; + return true; + } + case SpvOpRayQueryGetWorldRayOriginKHR: + { + v = UnownedStringSlice{"OpRayQueryGetWorldRayOriginKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectToWorldKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectToWorldKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionWorldToObjectKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionWorldToObjectKHR"}; + return true; + } + case SpvOpAtomicFAddEXT: + { + v = UnownedStringSlice{"OpAtomicFAddEXT"}; + return true; + } + case SpvOpTypeBufferSurfaceINTEL: + { + v = UnownedStringSlice{"OpTypeBufferSurfaceINTEL"}; + return true; + } + case SpvOpTypeStructContinuedINTEL: + { + v = UnownedStringSlice{"OpTypeStructContinuedINTEL"}; + return true; + } + case SpvOpConstantCompositeContinuedINTEL: + { + v = UnownedStringSlice{"OpConstantCompositeContinuedINTEL"}; + return true; + } + case SpvOpSpecConstantCompositeContinuedINTEL: + { + v = UnownedStringSlice{"OpSpecConstantCompositeContinuedINTEL"}; + return true; + } + case SpvOpConvertFToBF16INTEL: + { + v = UnownedStringSlice{"OpConvertFToBF16INTEL"}; + return true; + } + case SpvOpConvertBF16ToFINTEL: + { + v = UnownedStringSlice{"OpConvertBF16ToFINTEL"}; + return true; + } + case SpvOpControlBarrierArriveINTEL: + { + v = UnownedStringSlice{"OpControlBarrierArriveINTEL"}; + return true; + } + case SpvOpControlBarrierWaitINTEL: + { + v = UnownedStringSlice{"OpControlBarrierWaitINTEL"}; + return true; + } + case SpvOpGroupIMulKHR: + { + v = UnownedStringSlice{"OpGroupIMulKHR"}; + return true; + } + case SpvOpGroupFMulKHR: + { + v = UnownedStringSlice{"OpGroupFMulKHR"}; + return true; + } + case SpvOpGroupBitwiseAndKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseAndKHR"}; + return true; + } + case SpvOpGroupBitwiseOrKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseOrKHR"}; + return true; + } + case SpvOpGroupBitwiseXorKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseXorKHR"}; + return true; + } + case SpvOpGroupLogicalAndKHR: + { + v = UnownedStringSlice{"OpGroupLogicalAndKHR"}; + return true; + } + case SpvOpGroupLogicalOrKHR: + { + v = UnownedStringSlice{"OpGroupLogicalOrKHR"}; + return true; + } + case SpvOpGroupLogicalXorKHR: + { + v = UnownedStringSlice{"OpGroupLogicalXorKHR"}; + return true; + } + default: return false; + } +} + +static bool lookupOperandKind(const UnownedStringSlice& str, OperandKind& value) +{ + static const unsigned tableSalt[56] = { + 3, 1, 3, 1, 0, 3, 0, 0, 3, 0, 1, 1, 1, 3, 6, 2, + 1, 2, 0, 0, 2, 1, 0, 1, 6, 1, 0, 0, 0, 2, 5, 6, + 2, 0, 1, 0, 9, 2, 1, 5, 11, 7, 0, 0, 2, 0, 3, 0, + 0, 2, 0, 20, 4, 7, 0, 9 + }; + + using KV = std::pair; + + static const KV words[56] = + { + {"QuantizationModes", OperandKind{24}}, + {"PairIdRefIdRef", OperandKind{55}}, + {"CooperativeMatrixOperands", OperandKind{40}}, + {"LiteralSpecConstantOpInteger", OperandKind{52}}, + {"SamplerFilterMode", OperandKind{18}}, + {"Decoration", OperandKind{30}}, + {"ImageChannelDataType", OperandKind{21}}, + {"LiteralInteger", OperandKind{48}}, + {"IdMemorySemantics", OperandKind{45}}, + {"AccessQualifier", OperandKind{28}}, + {"LinkageType", OperandKind{27}}, + {"BuiltIn", OperandKind{31}}, + {"SamplerAddressingMode", OperandKind{17}}, + {"IdRef", OperandKind{47}}, + {"Scope", OperandKind{32}}, + {"ImageChannelOrder", OperandKind{20}}, + {"ExecutionModel", OperandKind{11}}, + {"FragmentShadingRate", OperandKind{9}}, + {"LiteralExtInstInteger", OperandKind{51}}, + {"LiteralString", OperandKind{49}}, + {"SourceLanguage", OperandKind{10}}, + {"LiteralContextDependentNumber", OperandKind{50}}, + {"FPRoundingMode", OperandKind{22}}, + {"FPOperationMode", OperandKind{25}}, + {"RayQueryCommittedIntersectionType", OperandKind{37}}, + {"CooperativeMatrixUse", OperandKind{42}}, + {"MemoryAccess", OperandKind{6}}, + {"PackedVectorFormat", OperandKind{39}}, + {"FunctionControl", OperandKind{4}}, + {"FunctionParameterAttribute", OperandKind{29}}, + {"MemoryModel", OperandKind{13}}, + {"StorageClass", OperandKind{15}}, + {"ImageFormat", OperandKind{19}}, + {"MemorySemantics", OperandKind{5}}, + {"KernelEnqueueFlags", OperandKind{34}}, + {"LoopControl", OperandKind{3}}, + {"PairLiteralIntegerIdRef", OperandKind{53}}, + {"IdResult", OperandKind{44}}, + {"ImageOperands", OperandKind{0}}, + {"Capability", OperandKind{35}}, + {"FPDenormMode", OperandKind{23}}, + {"Dim", OperandKind{16}}, + {"RayQueryIntersection", OperandKind{36}}, + {"IdScope", OperandKind{46}}, + {"ExecutionMode", OperandKind{14}}, + {"AddressingModel", OperandKind{12}}, + {"CooperativeMatrixLayout", OperandKind{41}}, + {"RayFlags", OperandKind{8}}, + {"SelectionControl", OperandKind{2}}, + {"OverflowModes", OperandKind{26}}, + {"FPFastMathMode", OperandKind{1}}, + {"RayQueryCandidateIntersectionType", OperandKind{38}}, + {"PairIdRefLiteralInteger", OperandKind{54}}, + {"IdResultType", OperandKind{43}}, + {"GroupOperation", OperandKind{33}}, + {"KernelProfilingInfo", OperandKind{7}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 56; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +bool lookupEnumWithHexPrefix(const UnownedStringSlice& str, SpvWord& value) +{ + static const unsigned tableSalt[944] = { + 1, 0, 0, 0, 2, 3, 2, 1, 3, 2, 0, 8, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 0, 2, 3, 1, + 2, 2, 5, 0, 3, 1, 4, 1, 0, 4, 3, 3, 0, 1, 0, 0, + 1, 1, 1, 0, 1, 2, 3, 0, 0, 0, 1, 0, 1, 0, 0, 1, + 0, 0, 0, 1, 0, 4, 0, 2, 0, 0, 5, 0, 0, 0, 0, 2, + 0, 3, 0, 0, 0, 0, 0, 1, 0, 8, 1, 1, 11, 3, 2, 0, + 1, 1, 21, 0, 0, 2, 4, 0, 2, 3, 6, 3, 0, 0, 0, 6, + 0, 1, 17, 0, 2, 0, 10, 1, 0, 0, 1, 1, 0, 8, 0, 0, + 2, 1, 2, 1, 0, 0, 1, 0, 0, 0, 2, 2, 0, 1, 0, 3, + 3, 0, 2, 0, 4, 0, 0, 1, 1, 0, 0, 2, 1, 5, 0, 2, + 0, 1, 1, 1, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 4, 6, + 1, 0, 1, 2, 10, 0, 1, 0, 0, 3, 2, 5, 1, 0, 2, 0, + 2, 3, 0, 7, 1, 4, 2, 0, 1, 0, 1, 0, 0, 0, 0, 9, + 7, 0, 1, 9, 1, 5, 0, 0, 0, 1, 0, 2, 0, 11, 2, 0, + 3, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 9, 8, 4, 1, + 0, 5, 0, 0, 0, 7, 9, 6, 0, 3, 0, 1, 3, 0, 2, 5, + 0, 1, 0, 2, 0, 1, 0, 0, 0, 1, 3, 2, 0, 0, 5, 0, + 5, 0, 1, 18, 1, 0, 0, 0, 4, 0, 0, 1, 0, 0, 1, 2, + 2, 3, 2, 9, 3, 0, 3, 3, 1, 0, 1, 2, 1, 2, 1, 0, + 0, 2, 0, 3, 2, 2, 0, 0, 3, 2, 0, 0, 2, 0, 3, 0, + 0, 0, 0, 5, 1, 0, 3, 2, 0, 0, 11, 3, 2, 0, 0, 7, + 0, 0, 4, 6, 5, 0, 0, 2, 3, 2, 0, 0, 3, 14, 4, 6, + 1, 6, 1, 0, 0, 2, 0, 1, 1, 11, 8, 0, 3, 1, 3, 4, + 0, 0, 0, 0, 1, 1, 0, 1, 2, 7, 1, 0, 0, 0, 13, 0, + 4, 0, 0, 0, 2, 1, 1, 7, 5, 4, 3, 1, 0, 3, 2, 2, + 0, 0, 0, 6, 18, 0, 0, 0, 3, 3, 4, 5, 4, 0, 1, 5, + 3, 0, 4, 5, 6, 9, 1, 3, 0, 0, 0, 1, 0, 1, 2, 7, + 0, 3, 1, 0, 9, 2, 0, 0, 0, 6, 4, 1, 8, 1, 0, 1, + 4, 2, 1, 0, 1, 4, 0, 5, 0, 4, 0, 3, 0, 1, 5, 6, + 0, 1, 1, 4, 0, 2, 6, 5, 1, 5, 1, 2, 2, 1, 0, 2, + 10, 0, 0, 4, 0, 1, 0, 1, 1, 8, 2, 2, 4, 1, 0, 0, + 1, 3, 14, 8, 2, 15, 3, 1, 5, 11, 5, 0, 0, 1, 3, 0, + 2, 0, 3, 0, 1, 3, 2, 5, 1, 4, 1, 6, 0, 0, 2, 1, + 0, 2, 0, 0, 0, 1, 0, 2, 0, 3, 0, 0, 6, 2, 18, 3, + 1, 7, 0, 4, 0, 4, 0, 0, 2, 3, 2, 2, 0, 8, 0, 0, + 10, 0, 0, 9, 1, 4, 3, 6, 0, 1, 6, 3, 14, 0, 0, 0, + 0, 0, 0, 11, 9, 5, 1, 0, 8, 0, 0, 0, 0, 0, 0, 0, + 2, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 0, 5, 9, 0, 0, + 5, 11, 3, 4, 8, 0, 3, 5, 3, 0, 3, 1, 19, 0, 0, 1, + 27, 7, 6, 2, 6, 4, 29, 1, 14, 5, 6, 0, 4, 1, 0, 0, + 1, 4, 6, 0, 1, 0, 19, 18, 9, 1, 0, 12, 1, 1, 0, 0, + 2, 0, 0, 12, 0, 0, 25, 0, 12, 11, 4, 2, 0, 2, 0, 34, + 0, 0, 5, 2, 0, 4, 0, 0, 36, 4, 0, 6, 6, 3, 12, 0, + 1, 1, 3, 0, 0, 0, 8, 4, 0, 14, 0, 0, 21, 7, 2, 0, + 46, 6, 0, 4, 1, 0, 1, 3, 41, 23, 0, 2, 1, 0, 0, 14, + 0, 9, 1, 2, 11, 0, 0, 66, 15, 26, 1, 26, 0, 0, 0, 0, + 1, 0, 2, 1, 2, 14, 0, 0, 12, 1, 17, 1, 2, 4, 5, 3, + 1, 3, 7, 4, 0, 5, 15, 29, 20, 0, 5, 0, 2, 12, 0, 3, + 0, 0, 31, 0, 2, 4, 6, 3, 0, 1, 6, 21, 0, 8, 0, 0, + 0, 4, 0, 1, 3, 1, 5, 6, 0, 1, 1, 0, 9, 9, 5, 14, + 13, 57, 0, 0, 68, 0, 3, 29, 27, 0, 0, 29, 0, 1, 10, 0, + 0, 3, 16, 1, 0, 0, 9, 17, 0, 0, 0, 5, 12, 43, 38, 1, + 0, 1, 8, 47, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 5, 0, + 14, 6, 21, 9, 10, 0, 0, 16, 9, 2, 29, 80, 0, 30, 29, 76, + 3, 2, 76, 0, 16, 6, 0, 28, 9, 44, 43, 0, 132, 1, 0, 1, + 1, 1, 2, 0, 0, 0, 6, 120, 17, 169, 2, 3, 56, 0, 0, 0, + 0, 0, 7, 49, 11, 0, 14, 30, 21, 0, 0, 8, 4, 15, 4, 0, + 37, 7, 1, 12, 68, 3, 20, 0, 408, 339, 4, 67, 461, 10, 27, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 415, 2, 1, 0, 1, 0, 3, 172 + }; + + using KV = std::pair; + + static const KV words[944] = + { + {"bpRayTmaxKHR", SpvWord{5326}}, + {"bpBaseVertex", SpvWord{4424}}, + {"bpObjectToWorldNV", SpvWord{5330}}, + {"bpTessLevelOuter", SpvWord{11}}, + {"boBufferBlock", SpvWord{3}}, + {"bdR11fG11fB10f", SpvWord{8}}, + {"cdRuntimeDescriptorArray", SpvWord{5302}}, + {"boXfbStride", SpvWord{37}}, + {"bdR16ui", SpvWord{38}}, + {"bpLocalInvocationIndex", SpvWord{29}}, + {"bnSret", SpvWord{3}}, + {"cdFunctionFloatControlINTEL", SpvWord{5821}}, + {"boFuseLoopsInFunctionINTEL", SpvWord{5907}}, + {"anOpenCL", SpvWord{2}}, + {"aiSkipClosestHitShaderKHR", SpvWord{8}}, + {"cdInputAttachment", SpvWord{40}}, + {"bpObjectRayOriginNV", SpvWord{5323}}, + {"aoOriginUpperLeft", SpvWord{7}}, + {"cdFloat64", SpvWord{10}}, + {"bdR32f", SpvWord{3}}, + {"akCPP_for_OpenCL", SpvWord{6}}, + {"anSimple", SpvWord{0}}, + {"boBankBitsINTEL", SpvWord{5835}}, + {"bpNumWorkgroups", SpvWord{24}}, + {"bpPatchVertices", SpvWord{14}}, + {"boInputAttachmentIndex", SpvWord{43}}, + {"aoNumSIMDWorkitemsINTEL", SpvWord{5896}}, + {"boVectorComputeCallableFunctionINTEL", SpvWord{6087}}, + {"boBindlessImageNV", SpvWord{5399}}, + {"boUniform", SpvWord{26}}, + {"cdStorageImageExtendedFormats", SpvWord{49}}, + {"cdTextureBlockMatchQCOM", SpvWord{4486}}, + {"aoMaxWorkgroupSizeINTEL", SpvWord{5893}}, + {"baCube", SpvWord{3}}, + {"aoSubgroupUniformControlFlowKHR", SpvWord{4421}}, + {"apCallableDataKHR", SpvWord{5328}}, + {"agNonPrivatePointer", SpvWord{32}}, + {"aeNone", SpvWord{0}}, + {"boMathOpDSPModeINTEL", SpvWord{5909}}, + {"cdSampledImageArrayNonUniformIndexing", SpvWord{5307}}, + {"beLuminance", SpvWord{9}}, + {"aoPostDepthCoverage", SpvWord{4446}}, + {"bdR16", SpvWord{14}}, + {"bnByVal", SpvWord{2}}, + {"afImageMemory", SpvWord{2048}}, + {"bpBaryCoordNoPerspAMD", SpvWord{4992}}, + {"cdDotProductInput4x8Bit", SpvWord{6017}}, + {"bpPrimitiveShadingRateKHR", SpvWord{4432}}, + {"abNotInf", SpvWord{2}}, + {"bfUnormInt16", SpvWord{3}}, + {"boMaxByteOffsetId", SpvWord{47}}, + {"aoVertexOrderCw", SpvWord{4}}, + {"bkWRAP", SpvWord{0}}, + {"bnNoReadWrite", SpvWord{7}}, + {"cdImageMSArray", SpvWord{48}}, + {"bkSAT", SpvWord{1}}, + {"bpCullMaskKHR", SpvWord{6021}}, + {"boStableKernelArgumentINTEL", SpvWord{6183}}, + {"bpBaryCoordKHR", SpvWord{5286}}, + {"cdStorageUniformBufferBlock16", SpvWord{4433}}, + {"bfUnormShort565", SpvWord{4}}, + {"acFlatten", SpvWord{1}}, + {"bfUnormInt101010_2", SpvWord{16}}, + {"boPerVertexNV", SpvWord{5285}}, + {"cdTileImageStencilReadAccessEXT", SpvWord{4168}}, + {"akUnknown", SpvWord{0}}, + {"bpBaryCoordSmoothCentroidAMD", SpvWord{4996}}, + {"adMaxConcurrencyINTEL", SpvWord{131072}}, + {"cdSubgroupAvcMotionEstimationChromaINTEL", SpvWord{5698}}, + {"cdInputAttachmentArrayDynamicIndexingEXT", SpvWord{5303}}, + {"boLocation", SpvWord{30}}, + {"alMissKHR", SpvWord{5317}}, + {"cbPartitionedInclusiveScanNV", SpvWord{7}}, + {"boInvariant", SpvWord{18}}, + {"alTaskEXT", SpvWord{5364}}, + {"cdLoopFuseINTEL", SpvWord{5906}}, + {"aiCullFrontFacingTrianglesKHR", SpvWord{32}}, + {"bpSampleMask", SpvWord{20}}, + {"cdDotProduct", SpvWord{6019}}, + {"cdFragmentFullyCoveredEXT", SpvWord{5265}}, + {"cdStencilExportEXT", SpvWord{5013}}, + {"boNonUniform", SpvWord{5300}}, + {"cdSampledImageArrayNonUniformIndexingEXT", SpvWord{5307}}, + {"boCoherent", SpvWord{23}}, + {"bpLayerPerViewNV", SpvWord{5279}}, + {"bdRg8Snorm", SpvWord{18}}, + {"bpSubgroupLocalInvocationId", SpvWord{41}}, + {"cbReduce", SpvWord{0}}, + {"boBoundSamplerNV", SpvWord{5400}}, + {"akGLSL", SpvWord{2}}, + {"boCentroid", SpvWord{16}}, + {"apShaderRecordBufferKHR", SpvWord{5343}}, + {"boCounterBuffer", SpvWord{5634}}, + {"boVolatile", SpvWord{21}}, + {"bpWorkgroupId", SpvWord{26}}, + {"boVectorComputeFunctionINTEL", SpvWord{5626}}, + {"ciMatrixASignedComponentsKHR", SpvWord{1}}, + {"boFuncParamIOKindINTEL", SpvWord{5625}}, + {"boFlat", SpvWord{14}}, + {"cdDeviceGroup", SpvWord{4437}}, + {"boPerPrimitiveNV", SpvWord{5271}}, + {"aaSample", SpvWord{64}}, + {"aoRoundingModeRTE", SpvWord{4462}}, + {"bdR16Snorm", SpvWord{19}}, + {"caShaderCallKHR", SpvWord{6}}, + {"blExport", SpvWord{0}}, + {"boIndex", SpvWord{32}}, + {"cdComputeDerivativeGroupQuadsNV", SpvWord{5288}}, + {"bpObjectRayDirectionNV", SpvWord{5324}}, + {"cdInt64", SpvWord{11}}, + {"chPackedVectorFormat4x8BitKHR", SpvWord{0}}, + {"bpFragInvocationCountEXT", SpvWord{5293}}, + {"alIntersectionNV", SpvWord{5314}}, + {"ba1D", SpvWord{0}}, + {"cgRayQueryCandidateIntersectionAABBKHR", SpvWord{1}}, + {"aoInputLines", SpvWord{20}}, + {"aeInline", SpvWord{1}}, + {"cdIOPipesINTEL", SpvWord{5943}}, + {"cdFPGALoopControlsINTEL", SpvWord{5888}}, + {"cdFPGAKernelAttributesv2INTEL", SpvWord{6161}}, + {"cdImageCubeArray", SpvWord{34}}, + {"bpInstanceId", SpvWord{6}}, + {"cdFPGARegINTEL", SpvWord{5948}}, + {"cbClusteredReduce", SpvWord{3}}, + {"aaConstOffsets", SpvWord{32}}, + {"bpHelperInvocation", SpvWord{23}}, + {"aoStencilRefLessBackAMD", SpvWord{5084}}, + {"aeDontInline", SpvWord{2}}, + {"cdUnstructuredLoopControlsINTEL", SpvWord{5886}}, + {"besRGBx", SpvWord{16}}, + {"cdAtomicFloat16MinMaxEXT", SpvWord{5616}}, + {"cdDotProductKHR", SpvWord{6019}}, + {"bpSecondaryPositionNV", SpvWord{5257}}, + {"cdVulkanMemoryModel", SpvWord{5345}}, + {"cdShaderNonUniformEXT", SpvWord{5301}}, + {"alIntersectionKHR", SpvWord{5314}}, + {"boGLSLShared", SpvWord{8}}, + {"bpBaryCoordNoPerspCentroidAMD", SpvWord{4993}}, + {"apPushConstant", SpvWord{9}}, + {"biRND_CONV", SpvWord{6}}, + {"bpFragmentSizeNV", SpvWord{5292}}, + {"aoFinalizer", SpvWord{34}}, + {"bdR8i", SpvWord{29}}, + {"aoQuads", SpvWord{24}}, + {"boHlslCounterBufferGOOGLE", SpvWord{5634}}, + {"boSample", SpvWord{17}}, + {"bdR8", SpvWord{15}}, + {"boPerPrimitiveEXT", SpvWord{5271}}, + {"biRND_ZERO", SpvWord{3}}, + {"bdRgba32ui", SpvWord{30}}, + {"aoDepthReplacing", SpvWord{12}}, + {"cdGroupNonUniformShuffleRelative", SpvWord{66}}, + {"bpSubgroupLtMask", SpvWord{4420}}, + {"aoSchedulerTargetFmaxMhzINTEL", SpvWord{5903}}, + {"cdSubgroupAvcMotionEstimationIntraINTEL", SpvWord{5697}}, + {"cdShaderClockKHR", SpvWord{5055}}, + {"cdUniformBufferArrayNonUniformIndexing", SpvWord{5306}}, + {"boOverrideCoverageNV", SpvWord{5248}}, + {"aoDenormFlushToZero", SpvWord{4460}}, + {"boMMHostInterfaceDataWidthINTEL", SpvWord{6178}}, + {"bfSignedInt16", SpvWord{8}}, + {"bpSubgroupEqMaskKHR", SpvWord{4416}}, + {"aoSubgroupSize", SpvWord{35}}, + {"cdMinLod", SpvWord{42}}, + {"agNoAliasINTELMask", SpvWord{131072}}, + {"aaVolatileTexelKHR", SpvWord{2048}}, + {"bpSMCountNV", SpvWord{5375}}, + {"bpCullDistance", SpvWord{4}}, + {"boAlignment", SpvWord{44}}, + {"aoOutputPoints", SpvWord{27}}, + {"bpWorkgroupSize", SpvWord{25}}, + {"adLoopCoalesceINTEL", SpvWord{1048576}}, + {"cdVariableLengthArrayINTEL", SpvWord{5817}}, + {"bpWarpIDARM", SpvWord{4163}}, + {"apPhysicalStorageBuffer", SpvWord{5349}}, + {"bdRg16Snorm", SpvWord{17}}, + {"boXfbBuffer", SpvWord{36}}, + {"boComponent", SpvWord{31}}, + {"afOutputMemory", SpvWord{4096}}, + {"cdSubgroupAvcMotionEstimationINTEL", SpvWord{5696}}, + {"cdRayTracingNV", SpvWord{5340}}, + {"bpWorldToObjectNV", SpvWord{5331}}, + {"ciMatrixBSignedComponentsKHR", SpvWord{2}}, + {"cdVariablePointersStorageBuffer", SpvWord{4441}}, + {"aoNonCoherentStencilAttachmentReadEXT", SpvWord{4171}}, + {"boBufferLocationINTEL", SpvWord{5921}}, + {"boBindlessSamplerNV", SpvWord{5398}}, + {"cdRayTracingOpacityMicromapEXT", SpvWord{5381}}, + {"cdStorageTexelBufferArrayDynamicIndexingEXT", SpvWord{5305}}, + {"cdStorageImageArrayDynamicIndexing", SpvWord{31}}, + {"cdFloat16", SpvWord{9}}, + {"apStorageBuffer", SpvWord{12}}, + {"bpSubgroupLtMaskKHR", SpvWord{4420}}, + {"cdSparseResidency", SpvWord{41}}, + {"bpWarpIDNV", SpvWord{5376}}, + {"boRestrict", SpvWord{19}}, + {"aoOutputPrimitivesNV", SpvWord{5270}}, + {"boMatrixStride", SpvWord{7}}, + {"cdUSMStorageClassesINTEL", SpvWord{5935}}, + {"cdStorageBufferArrayNonUniformIndexing", SpvWord{5308}}, + {"cdGroupNonUniformRotateKHR", SpvWord{6026}}, + {"aoIsolines", SpvWord{25}}, + {"biTRN", SpvWord{0}}, + {"boFunctionFloatingPointModeINTEL", SpvWord{6080}}, + {"bpPrimitiveId", SpvWord{7}}, + {"boAliased", SpvWord{20}}, + {"akWGSL", SpvWord{10}}, + {"aoShadingRateInterlockOrderedEXT", SpvWord{5370}}, + {"cdMeshShadingEXT", SpvWord{5283}}, + {"ajHorizontal2Pixels", SpvWord{4}}, + {"boUserTypeGOOGLE", SpvWord{5636}}, + {"aoSampleInterlockOrderedEXT", SpvWord{5368}}, + {"cdSubgroupBufferBlockIOINTEL", SpvWord{5569}}, + {"bpObjectRayOriginKHR", SpvWord{5323}}, + {"ajHorizontal4Pixels", SpvWord{8}}, + {"cdVulkanMemoryModelDeviceScope", SpvWord{5346}}, + {"bdRg32f", SpvWord{6}}, + {"cdRayQueryKHR", SpvWord{4472}}, + {"boRelaxedPrecision", SpvWord{0}}, + {"bdRg16", SpvWord{12}}, + {"boHitObjectShaderRecordBufferNV", SpvWord{5386}}, + {"bdRg16ui", SpvWord{36}}, + {"cdSignedZeroInfNanPreserve", SpvWord{4466}}, + {"cdSubgroupBallotKHR", SpvWord{4423}}, + {"agNontemporal", SpvWord{4}}, + {"bpPosition", SpvWord{0}}, + {"blImport", SpvWord{1}}, + {"afMakeAvailable", SpvWord{8192}}, + {"adInitiationIntervalINTEL", SpvWord{65536}}, + {"boAlignmentId", SpvWord{46}}, + {"aoSpacingFractionalOdd", SpvWord{3}}, + {"adLoopCountINTEL", SpvWord{16777216}}, + {"bcLinear", SpvWord{1}}, + {"ckMatrixAKHR", SpvWord{0}}, + {"boDoublepumpINTEL", SpvWord{5831}}, + {"cdFloatingPointModeINTEL", SpvWord{5583}}, + {"bpPositionPerViewNV", SpvWord{5261}}, + {"apImage", SpvWord{11}}, + {"bpInvocationId", SpvWord{8}}, + {"caDevice", SpvWord{1}}, + {"cdVectorAnyINTEL", SpvWord{5619}}, + {"boViewportRelativeNV", SpvWord{5252}}, + {"cdFragmentBarycentricKHR", SpvWord{5284}}, + {"aaMakeTexelAvailableKHR", SpvWord{256}}, + {"ccNoWait", SpvWord{0}}, + {"bpRayTminNV", SpvWord{5325}}, + {"abNotNaN", SpvWord{1}}, + {"bdRgba16Snorm", SpvWord{16}}, + {"aoOutputVertices", SpvWord{26}}, + {"aoStencilRefGreaterFrontAMD", SpvWord{5080}}, + {"boRestrictPointer", SpvWord{5355}}, + {"bgRTN", SpvWord{3}}, + {"cdSplitBarrierINTEL", SpvWord{6141}}, + {"boNonWritable", SpvWord{24}}, + {"bpPointSize", SpvWord{1}}, + {"bfUnormInt8", SpvWord{2}}, + {"aiOpaqueKHR", SpvWord{1}}, + {"boSecondaryViewportRelativeNV", SpvWord{5256}}, + {"cdFunctionPointersINTEL", SpvWord{5603}}, + {"cdDemoteToHelperInvocationEXT", SpvWord{5379}}, + {"cdStorageBufferArrayDynamicIndexing", SpvWord{30}}, + {"boFPRoundingMode", SpvWord{39}}, + {"bpFragSizeEXT", SpvWord{5292}}, + {"cdShader", SpvWord{1}}, + {"ba2D", SpvWord{1}}, + {"boAliasedPointer", SpvWord{5356}}, + {"bnNoAlias", SpvWord{4}}, + {"aaSignExtend", SpvWord{4096}}, + {"bdRgba32f", SpvWord{1}}, + {"cdInt64ImageEXT", SpvWord{5016}}, + {"aoSubgroupsPerWorkgroup", SpvWord{36}}, + {"boRestrictPointerEXT", SpvWord{5355}}, + {"cdVulkanMemoryModelDeviceScopeKHR", SpvWord{5346}}, + {"bdRg32i", SpvWord{25}}, + {"bpVertexIndex", SpvWord{42}}, + {"alTessellationControl", SpvWord{1}}, + {"aoOutputTrianglesNV", SpvWord{5298}}, + {"aoOutputLineStrip", SpvWord{28}}, + {"boFunctionRoundingModeINTEL", SpvWord{5822}}, + {"cdGroupNonUniformShuffle", SpvWord{65}}, + {"bpSubgroupGeMask", SpvWord{4417}}, + {"cdArbitraryPrecisionFloatingPointINTEL", SpvWord{5845}}, + {"afSubgroupMemory", SpvWord{128}}, + {"bdR64ui", SpvWord{40}}, + {"boMaxPrivateCopiesINTEL", SpvWord{5829}}, + {"cdAtomicStorageOps", SpvWord{4445}}, + {"cdStorageBuffer8BitAccess", SpvWord{4448}}, + {"boBlock", SpvWord{2}}, + {"cdSampledCubeArray", SpvWord{45}}, + {"cdMemoryAccessAliasingINTEL", SpvWord{5910}}, + {"adDependencyArrayINTEL", SpvWord{262144}}, + {"cdRoundingModeRTZ", SpvWord{4468}}, + {"afVolatile", SpvWord{32768}}, + {"abFast", SpvWord{16}}, + {"aoContractionOff", SpvWord{31}}, + {"bpNumEnqueuedSubgroups", SpvWord{39}}, + {"aoVecTypeHint", SpvWord{30}}, + {"bdRgba32i", SpvWord{21}}, + {"besRGBA", SpvWord{17}}, + {"ba3D", SpvWord{2}}, + {"apUniformConstant", SpvWord{0}}, + {"afWorkgroupMemory", SpvWord{256}}, + {"cdSubgroupImageBlockIOINTEL", SpvWord{5570}}, + {"boSideEffectsINTEL", SpvWord{5608}}, + {"anVulkan", SpvWord{3}}, + {"cdRayTraversalPrimitiveCullingKHR", SpvWord{4478}}, + {"cdGroupNonUniformArithmetic", SpvWord{63}}, + {"bgRTP", SpvWord{2}}, + {"cdMeshShadingNV", SpvWord{5266}}, + {"bfUnormShort555", SpvWord{5}}, + {"ciMatrixResultSignedComponentsKHR", SpvWord{8}}, + {"bdUnknown", SpvWord{0}}, + {"amPhysicalStorageBuffer64EXT", SpvWord{5348}}, + {"boDontStaticallyCoalesceINTEL", SpvWord{5901}}, + {"bpSubgroupLeMask", SpvWord{4419}}, + {"cdAtomicFloat64AddEXT", SpvWord{6034}}, + {"cdRoundingModeRTE", SpvWord{4467}}, + {"aoDerivativeGroupQuadsNV", SpvWord{5289}}, + {"boColMajor", SpvWord{5}}, + {"apIncomingRayPayloadKHR", SpvWord{5342}}, + {"afRelease", SpvWord{4}}, + {"cjRowMajorKHR", SpvWord{0}}, + {"afCrossWorkgroupMemory", SpvWord{512}}, + {"cdStoragePushConstant16", SpvWord{4435}}, + {"alFragment", SpvWord{4}}, + {"boMMHostInterfaceReadWriteModeINTEL", SpvWord{6180}}, + {"bbClampToEdge", SpvWord{1}}, + {"bpGlobalOffset", SpvWord{33}}, + {"aiNoOpaqueKHR", SpvWord{2}}, + {"baSubpassData", SpvWord{6}}, + {"cdImageMipmap", SpvWord{15}}, + {"bpSubgroupGeMaskKHR", SpvWord{4417}}, + {"cdImageFootprintNV", SpvWord{5282}}, + {"cdGenericPointer", SpvWord{38}}, + {"bdR32ui", SpvWord{33}}, + {"bfUnormInt101010", SpvWord{6}}, + {"bpPrimitiveCountNV", SpvWord{5275}}, + {"boRowMajor", SpvWord{4}}, + {"cdTileImageColorReadAccessEXT", SpvWord{4166}}, + {"ckMatrixAccumulatorKHR", SpvWord{2}}, + {"apIncomingCallableDataNV", SpvWord{5329}}, + {"boMediaBlockIOINTEL", SpvWord{6140}}, + {"agMakePointerAvailableKHR", SpvWord{8}}, + {"adSpeculatedIterationsINTEL", SpvWord{4194304}}, + {"bpRayGeometryIndexKHR", SpvWord{5352}}, + {"apPhysicalStorageBufferEXT", SpvWord{5349}}, + {"bpRayTmaxNV", SpvWord{5326}}, + {"bdR32i", SpvWord{24}}, + {"bdRgba8", SpvWord{4}}, + {"bpWorldRayDirectionKHR", SpvWord{5322}}, + {"adUnroll", SpvWord{1}}, + {"bdRg16f", SpvWord{7}}, + {"boPassthroughNV", SpvWord{5250}}, + {"cdSampleMaskPostDepthCoverage", SpvWord{4447}}, + {"bdR8ui", SpvWord{39}}, + {"cdUniformAndStorageBuffer8BitAccess", SpvWord{4449}}, + {"cdRuntimeAlignedAttributeINTEL", SpvWord{5939}}, + {"cdUniformBufferArrayNonUniformIndexingEXT", SpvWord{5306}}, + {"bpDeviceIndex", SpvWord{4438}}, + {"bpSubgroupLeMaskKHR", SpvWord{4419}}, + {"caInvocation", SpvWord{4}}, + {"bpTessLevelInner", SpvWord{12}}, + {"cdFloat16Buffer", SpvWord{8}}, + {"bpCullPrimitiveEXT", SpvWord{5299}}, + {"boPerVertexKHR", SpvWord{5285}}, + {"boExplicitInterpAMD", SpvWord{4999}}, + {"bpShadingRateKHR", SpvWord{4444}}, + {"agAligned", SpvWord{2}}, + {"boGLSLPacked", SpvWord{9}}, + {"aiCullNoOpaqueKHR", SpvWord{128}}, + {"boFunctionDenormModeINTEL", SpvWord{5823}}, + {"bbClamp", SpvWord{2}}, + {"bmReadWrite", SpvWord{2}}, + {"aaNontemporal", SpvWord{16384}}, + {"apOutput", SpvWord{3}}, + {"bpSMIDNV", SpvWord{5377}}, + {"cdShadingRateNV", SpvWord{5291}}, + {"apFunction", SpvWord{7}}, + {"baTileImageDataEXT", SpvWord{4173}}, + {"boNoSignedWrap", SpvWord{4469}}, + {"cdBlockingPipesINTEL", SpvWord{5945}}, + {"cdImageQuery", SpvWord{50}}, + {"aoVertexOrderCcw", SpvWord{5}}, + {"boLatencyControlLabelINTEL", SpvWord{6172}}, + {"agMakePointerVisibleKHR", SpvWord{16}}, + {"cdStorageTexelBufferArrayDynamicIndexing", SpvWord{5305}}, + {"beRx", SpvWord{10}}, + {"bdRgba16", SpvWord{10}}, + {"biRND", SpvWord{2}}, + {"boArrayStride", SpvWord{6}}, + {"cdFPGABufferLocationINTEL", SpvWord{5920}}, + {"beRG", SpvWord{2}}, + {"aoInputTrianglesAdjacency", SpvWord{23}}, + {"bdRgba8ui", SpvWord{32}}, + {"agAliasScopeINTELMask", SpvWord{65536}}, + {"bpSubgroupSize", SpvWord{36}}, + {"boStackCallINTEL", SpvWord{5627}}, + {"cbPartitionedExclusiveScanNV", SpvWord{8}}, + {"cdUniformAndStorageBuffer16BitAccess", SpvWord{4434}}, + {"aoSharedLocalMemorySizeINTEL", SpvWord{5618}}, + {"bfUnsignedInt32", SpvWord{12}}, + {"cdStorageImageArrayNonUniformIndexingEXT", SpvWord{5309}}, + {"alClosestHitNV", SpvWord{5316}}, + {"cdStorageInputOutput16", SpvWord{4436}}, + {"aoTriangles", SpvWord{22}}, + {"akOpenCL_C", SpvWord{3}}, + {"cdExpectAssumeKHR", SpvWord{5629}}, + {"cdFPGAClusterAttributesINTEL", SpvWord{5904}}, + {"aoDepthGreater", SpvWord{14}}, + {"boMaxByteOffset", SpvWord{45}}, + {"cdFragmentMaskAMD", SpvWord{5010}}, + {"bpLayer", SpvWord{9}}, + {"cdImage1D", SpvWord{44}}, + {"bdRgb10a2ui", SpvWord{34}}, + {"bdR16i", SpvWord{28}}, + {"aaNonPrivateTexelKHR", SpvWord{1024}}, + {"cjColumnMajorKHR", SpvWord{1}}, + {"bpWorldRayOriginNV", SpvWord{5321}}, + {"bpCullDistancePerViewNV", SpvWord{5278}}, + {"cdInputAttachmentArrayNonUniformIndexing", SpvWord{5310}}, + {"bfSnormInt8", SpvWord{0}}, + {"cdSubgroupShuffleINTEL", SpvWord{5568}}, + {"bhFlushToZero", SpvWord{1}}, + {"abAllowRecip", SpvWord{8}}, + {"cdSampleMaskOverrideCoverageNV", SpvWord{5249}}, + {"adPeelCount", SpvWord{128}}, + {"boPerTaskNV", SpvWord{5273}}, + {"cdKernelAttributesINTEL", SpvWord{5892}}, + {"bpFragCoord", SpvWord{15}}, + {"boBurstCoalesceINTEL", SpvWord{5899}}, + {"bpBaryCoordNV", SpvWord{5286}}, + {"boPrefetchINTEL", SpvWord{5902}}, + {"bpInvocationsPerPixelNV", SpvWord{5293}}, + {"bpTaskCountNV", SpvWord{5274}}, + {"cdLongConstantCompositeINTEL", SpvWord{6089}}, + {"bpClipDistancePerViewNV", SpvWord{5277}}, + {"bpEnqueuedWorkgroupSize", SpvWord{32}}, + {"cdTileImageDepthReadAccessEXT", SpvWord{4167}}, + {"bpSubgroupEqMask", SpvWord{4416}}, + {"aoLocalSizeHint", SpvWord{18}}, + {"cdVector16", SpvWord{7}}, + {"bdRgba16i", SpvWord{22}}, + {"apHostOnlyINTEL", SpvWord{5937}}, + {"bpHitKindNV", SpvWord{5333}}, + {"aoLocalSizeHintId", SpvWord{39}}, + {"alCallableNV", SpvWord{5318}}, + {"beRGBA", SpvWord{5}}, + {"boOffset", SpvWord{35}}, + {"agMakePointerVisible", SpvWord{16}}, + {"cdSampled1D", SpvWord{43}}, + {"bpWarpsPerSMNV", SpvWord{5374}}, + {"beA", SpvWord{1}}, + {"acDontFlatten", SpvWord{2}}, + {"cgRayQueryCandidateIntersectionTriangleKHR", SpvWord{0}}, + {"cdComputeDerivativeGroupLinearNV", SpvWord{5350}}, + {"cbInclusiveScan", SpvWord{1}}, + {"boNoUnsignedWrap", SpvWord{4470}}, + {"aoStencilRefUnchangedBackAMD", SpvWord{5082}}, + {"bnNoWrite", SpvWord{6}}, + {"boUniformId", SpvWord{27}}, + {"cdAtomicFloat32MinMaxEXT", SpvWord{5612}}, + {"aoDenormPreserve", SpvWord{4459}}, + {"aaOffset", SpvWord{16}}, + {"aeConst", SpvWord{8}}, + {"cdIntegerFunctions2INTEL", SpvWord{5584}}, + {"cdRoundToInfinityINTEL", SpvWord{5582}}, + {"aiNoneKHR", SpvWord{0}}, + {"boReferencedIndirectlyINTEL", SpvWord{5602}}, + {"alVertex", SpvWord{0}}, + {"cdFragmentDensityEXT", SpvWord{5291}}, + {"bpRayTminKHR", SpvWord{5325}}, + {"aoStreamingInterfaceINTEL", SpvWord{6154}}, + {"aoPixelInterlockUnorderedEXT", SpvWord{5367}}, + {"cdRayTracingProvisionalKHR", SpvWord{5353}}, + {"cdFPGAKernelAttributesINTEL", SpvWord{5897}}, + {"bcNearest", SpvWord{0}}, + {"alAnyHitKHR", SpvWord{5315}}, + {"cdKernel", SpvWord{6}}, + {"anVulkanKHR", SpvWord{3}}, + {"akHLSL", SpvWord{5}}, + {"aoSignedZeroInfNanPreserve", SpvWord{4461}}, + {"aoEarlyFragmentTests", SpvWord{9}}, + {"boCPacked", SpvWord{10}}, + {"cdImageBasic", SpvWord{13}}, + {"bjIEEE", SpvWord{0}}, + {"apUniform", SpvWord{2}}, + {"aoPixelCenterInteger", SpvWord{6}}, + {"beBGRA", SpvWord{6}}, + {"cdRayQueryProvisionalKHR", SpvWord{4471}}, + {"boSIMTCallINTEL", SpvWord{5599}}, + {"alTaskNV", SpvWord{5267}}, + {"bdRgba16ui", SpvWord{31}}, + {"ciNoneKHR", SpvWord{0}}, + {"cdGroupNonUniformQuad", SpvWord{68}}, + {"akSYCL", SpvWord{7}}, + {"cdCullDistance", SpvWord{33}}, + {"boConstant", SpvWord{22}}, + {"adDependencyLength", SpvWord{8}}, + {"adMaxReinvocationDelayINTEL", SpvWord{33554432}}, + {"afAcquireRelease", SpvWord{8}}, + {"cdLinkage", SpvWord{5}}, + {"alRayGenerationKHR", SpvWord{5313}}, + {"cdBitInstructions", SpvWord{6025}}, + {"bfSignedInt32", SpvWord{9}}, + {"cdClipDistance", SpvWord{32}}, + {"aaZeroExtend", SpvWord{8192}}, + {"bpPointCoord", SpvWord{16}}, + {"cdStorageImageMultisample", SpvWord{27}}, + {"apGeneric", SpvWord{8}}, + {"bpPrimitiveIndicesNV", SpvWord{5276}}, + {"boGlobalVariableOffsetINTEL", SpvWord{5628}}, + {"aoEarlyAndLateFragmentTestsAMD", SpvWord{5017}}, + {"bgRTZ", SpvWord{1}}, + {"cdGeometry", SpvWord{2}}, + {"bdRgba8i", SpvWord{23}}, + {"bpCoreCountARM", SpvWord{4161}}, + {"aaMakeTexelVisible", SpvWord{512}}, + {"apRayPayloadNV", SpvWord{5338}}, + {"aaVolatileTexel", SpvWord{2048}}, + {"agNone", SpvWord{0}}, + {"bpPrimitiveTriangleIndicesEXT", SpvWord{5296}}, + {"amPhysical64", SpvWord{2}}, + {"bpSampleId", SpvWord{18}}, + {"acNone", SpvWord{0}}, + {"beRA", SpvWord{3}}, + {"afRelaxed", SpvWord{0}}, + {"bfUnsignedIntRaw10EXT", SpvWord{19}}, + {"boStallEnableINTEL", SpvWord{5905}}, + {"aoRoundingModeRTPINTEL", SpvWord{5620}}, + {"cdPerViewAttributesNV", SpvWord{5260}}, + {"bpWorldRayOriginKHR", SpvWord{5321}}, + {"cdShaderInvocationReorderNV", SpvWord{5383}}, + {"cdShaderStereoViewNV", SpvWord{5259}}, + {"cdSubgroupVoteKHR", SpvWord{4431}}, + {"adPipelineEnableINTEL", SpvWord{524288}}, + {"apAtomicCounter", SpvWord{10}}, + {"aoSpacingFractionalEven", SpvWord{2}}, + {"bkSAT_ZERO", SpvWord{2}}, + {"apCallableDataNV", SpvWord{5328}}, + {"cdBFloat16ConversionINTEL", SpvWord{6115}}, + {"aoStencilRefUnchangedFrontAMD", SpvWord{5079}}, + {"bpIncomingRayFlagsNV", SpvWord{5351}}, + {"cdShaderViewportIndexLayerNV", SpvWord{5254}}, + {"ccWaitKernel", SpvWord{1}}, + {"cfRayQueryCommittedIntersectionGeneratedKHR", SpvWord{2}}, + {"bpHitTriangleVertexPositionsKHR", SpvWord{5335}}, + {"bjALT", SpvWord{1}}, + {"cdFragmentShadingRateKHR", SpvWord{4422}}, + {"cbPartitionedReduceNV", SpvWord{6}}, + {"bpSamplePosition", SpvWord{19}}, + {"alCallableKHR", SpvWord{5318}}, + {"ckMatrixBKHR", SpvWord{1}}, + {"cdGeometryPointSize", SpvWord{24}}, + {"cdFragmentShaderShadingRateInterlockEXT", SpvWord{5372}}, + {"boBlockMatchTextureQCOM", SpvWord{4488}}, + {"boMemoryINTEL", SpvWord{5826}}, + {"cdGroups", SpvWord{18}}, + {"bpPrimitiveLineIndicesEXT", SpvWord{5295}}, + {"bnZext", SpvWord{0}}, + {"cdPipes", SpvWord{17}}, + {"bpVertexId", SpvWord{5}}, + {"cdAtomicFloat32AddEXT", SpvWord{6033}}, + {"cdAtomicStorage", SpvWord{21}}, + {"cdDeviceEnqueue", SpvWord{19}}, + {"apHitObjectAttributeNV", SpvWord{5385}}, + {"adNoFusionINTEL", SpvWord{8388608}}, + {"cdShaderViewportIndexLayerEXT", SpvWord{5254}}, + {"amPhysical32", SpvWord{1}}, + {"aiCullBackFacingTrianglesKHR", SpvWord{16}}, + {"bpCoreIDARM", SpvWord{4160}}, + {"caQueueFamilyKHR", SpvWord{5}}, + {"apDeviceOnlyINTEL", SpvWord{5936}}, + {"cdImageReadWriteLodAMD", SpvWord{5015}}, + {"boLatencyControlConstraintINTEL", SpvWord{6173}}, + {"aoSubgroupsPerWorkgroupId", SpvWord{37}}, + {"bpInstanceCustomIndexKHR", SpvWord{5327}}, + {"aoNonCoherentDepthAttachmentReadEXT", SpvWord{4170}}, + {"bfUnsignedInt8", SpvWord{10}}, + {"bmWriteOnly", SpvWord{1}}, + {"boNoPerspective", SpvWord{13}}, + {"aoOutputLinesEXT", SpvWord{5269}}, + {"boNoAliasINTEL", SpvWord{5915}}, + {"cdDemoteToHelperInvocation", SpvWord{5379}}, + {"adIterationMultiple", SpvWord{64}}, + {"cdCooperativeMatrixKHR", SpvWord{6022}}, + {"cdDotProductInput4x8BitPacked", SpvWord{6018}}, + {"bpGlobalLinearId", SpvWord{34}}, + {"apIncomingCallableDataKHR", SpvWord{5329}}, + {"cdDebugInfoModuleINTEL", SpvWord{6114}}, + {"aaBias", SpvWord{1}}, + {"bfUnormInt24", SpvWord{15}}, + {"aoInvocations", SpvWord{0}}, + {"apIncomingRayPayloadNV", SpvWord{5342}}, + {"aiForceOpacityMicromap2StateEXT", SpvWord{1024}}, + {"ciMatrixCSignedComponentsKHR", SpvWord{4}}, + {"cdBindlessTextureNV", SpvWord{5390}}, + {"cdCoreBuiltinsARM", SpvWord{4165}}, + {"cdFPGAArgumentInterfacesINTEL", SpvWord{6174}}, + {"boInitiationIntervalINTEL", SpvWord{5917}}, + {"akHERO_C", SpvWord{8}}, + {"boAliasedPointerEXT", SpvWord{5356}}, + {"afUniformMemory", SpvWord{64}}, + {"apInput", SpvWord{1}}, + {"bpObjectToWorldKHR", SpvWord{5330}}, + {"bdRgba8Snorm", SpvWord{5}}, + {"boRegisterMapKernelArgumentINTEL", SpvWord{6176}}, + {"bpDrawIndex", SpvWord{4426}}, + {"boMMHostInterfaceWaitRequestINTEL", SpvWord{6182}}, + {"boPipelineEnableINTEL", SpvWord{5919}}, + {"cdFragmentShaderPixelInterlockEXT", SpvWord{5378}}, + {"bfSignedInt8", SpvWord{7}}, + {"aaGrad", SpvWord{4}}, + {"aoOutputPrimitivesEXT", SpvWord{5270}}, + {"besBGRA", SpvWord{18}}, + {"bpViewportIndex", SpvWord{10}}, + {"afSequentiallyConsistent", SpvWord{16}}, + {"alRayGenerationNV", SpvWord{5313}}, + {"abNone", SpvWord{0}}, + {"alMeshNV", SpvWord{5268}}, + {"boConduitKernelArgumentINTEL", SpvWord{6175}}, + {"bbRepeat", SpvWord{3}}, + {"bbNone", SpvWord{0}}, + {"adMaxInterleavingINTEL", SpvWord{2097152}}, + {"cdInputAttachmentArrayDynamicIndexing", SpvWord{5303}}, + {"cdSubgroupImageMediaBlockIOINTEL", SpvWord{5579}}, + {"apShaderRecordBufferNV", SpvWord{5343}}, + {"cdDenormFlushToZero", SpvWord{4465}}, + {"ahCmdExecTime", SpvWord{1}}, + {"cdStorageImageWriteWithoutFormat", SpvWord{56}}, + {"cdPipeStorage", SpvWord{60}}, + {"boSinglepumpINTEL", SpvWord{5830}}, + {"cdUniformTexelBufferArrayNonUniformIndexingEXT", SpvWord{5311}}, + {"beDepth", SpvWord{13}}, + {"boSaturatedConversion", SpvWord{28}}, + {"cdDerivativeControl", SpvWord{51}}, + {"cdRayTracingMotionBlurNV", SpvWord{5341}}, + {"apCrossWorkgroup", SpvWord{5}}, + {"bpSubgroupGtMask", SpvWord{4418}}, + {"bpBaryCoordSmoothAMD", SpvWord{4995}}, + {"bpLaunchIdKHR", SpvWord{5319}}, + {"cfRayQueryCommittedIntersectionNoneKHR", SpvWord{0}}, + {"cbExclusiveScan", SpvWord{2}}, + {"aaConstOffset", SpvWord{8}}, + {"cdGeometryShaderPassthroughNV", SpvWord{5251}}, + {"boForcePow2DepthINTEL", SpvWord{5836}}, + {"bnSext", SpvWord{1}}, + {"bpBaryCoordPullModelAMD", SpvWord{4998}}, + {"agNonPrivatePointerKHR", SpvWord{32}}, + {"biRND_CONV_ODD", SpvWord{7}}, + {"cdStorageImageArrayNonUniformIndexing", SpvWord{5309}}, + {"boIOPipeStorageINTEL", SpvWord{5944}}, + {"apPrivate", SpvWord{6}}, + {"cdFPGADSPControlINTEL", SpvWord{5908}}, + {"bmReadOnly", SpvWord{0}}, + {"cdVariablePointers", SpvWord{4442}}, + {"bpTessCoord", SpvWord{13}}, + {"ahNone", SpvWord{0}}, + {"bpNumSubgroups", SpvWord{38}}, + {"bkSAT_SYM", SpvWord{3}}, + {"adDontUnroll", SpvWord{2}}, + {"caCrossDevice", SpvWord{0}}, + {"cdShaderViewportMaskNV", SpvWord{5255}}, + {"cdGroupNonUniformVote", SpvWord{62}}, + {"cdAddresses", SpvWord{4}}, + {"afOutputMemoryKHR", SpvWord{4096}}, + {"cdMatrix", SpvWord{0}}, + {"akNZSL", SpvWord{9}}, + {"cdRayQueryPositionFetchKHR", SpvWord{5391}}, + {"biRND_INF", SpvWord{4}}, + {"cdSampledImageArrayDynamicIndexing", SpvWord{29}}, + {"adDependencyInfinite", SpvWord{4}}, + {"aiCullOpaqueKHR", SpvWord{64}}, + {"cdFPGAInvocationPipeliningAttributesINTEL", SpvWord{5916}}, + {"abAllowReassocINTEL", SpvWord{131072}}, + {"cdDrawParameters", SpvWord{4427}}, + {"boPerViewNV", SpvWord{5272}}, + {"aoRoundingModeRTZ", SpvWord{4463}}, + {"afMakeAvailableKHR", SpvWord{8192}}, + {"bpWorkDim", SpvWord{30}}, + {"agMakePointerAvailable", SpvWord{8}}, + {"bpSubgroupGtMaskKHR", SpvWord{4418}}, + {"aiSkipAABBsKHR", SpvWord{512}}, + {"bdRgba16f", SpvWord{2}}, + {"boMMHostInterfaceAddressWidthINTEL", SpvWord{6177}}, + {"afMakeVisibleKHR", SpvWord{16384}}, + {"beABGR", SpvWord{19}}, + {"cdInterpolationFunction", SpvWord{52}}, + {"aoStencilRefReplacingEXT", SpvWord{5027}}, + {"bfHalfFloat", SpvWord{13}}, + {"cdRuntimeDescriptorArrayEXT", SpvWord{5302}}, + {"apHitAttributeNV", SpvWord{5339}}, + {"bpBaryCoordNoPerspNV", SpvWord{5287}}, + {"cdUniformDecoration", SpvWord{71}}, + {"afNone", SpvWord{0}}, + {"bdR8Snorm", SpvWord{20}}, + {"bpWorldRayDirectionNV", SpvWord{5322}}, + {"cdDotProductInputAll", SpvWord{6016}}, + {"bpLaunchSizeNV", SpvWord{5320}}, + {"boSpecId", SpvWord{1}}, + {"cdSampledRect", SpvWord{37}}, + {"cdStorageBufferArrayNonUniformIndexingEXT", SpvWord{5308}}, + {"cdFPGALatencyControlINTEL", SpvWord{6171}}, + {"bgRTE", SpvWord{0}}, + {"cdLiteralSampler", SpvWord{20}}, + {"apRayPayloadKHR", SpvWord{5338}}, + {"cdSampledBuffer", SpvWord{46}}, + {"cdWorkgroupMemoryExplicitLayout16BitAccessKHR", SpvWord{4430}}, + {"cdGroupNonUniformPartitionedNV", SpvWord{5297}}, + {"boAliasScopeINTEL", SpvWord{5914}}, + {"boHlslSemanticGOOGLE", SpvWord{5635}}, + {"boMaxReplicatesINTEL", SpvWord{5832}}, + {"bfUnsignedIntRaw12EXT", SpvWord{20}}, + {"aoInputLinesAdjacency", SpvWord{21}}, + {"aoPointMode", SpvWord{10}}, + {"cdDotProductInput4x8BitPackedKHR", SpvWord{6018}}, + {"cdGroupNonUniform", SpvWord{61}}, + {"afAcquire", SpvWord{2}}, + {"boBoundImageNV", SpvWord{5401}}, + {"aoNonCoherentColorAttachmentReadEXT", SpvWord{4169}}, + {"apCodeSectionINTEL", SpvWord{5605}}, + {"apHitAttributeKHR", SpvWord{5339}}, + {"boPatch", SpvWord{15}}, + {"abAllowContractFastINTEL", SpvWord{65536}}, + {"boFuncParamAttr", SpvWord{38}}, + {"bdRg8i", SpvWord{27}}, + {"boRegisterINTEL", SpvWord{5825}}, + {"aoStencilRefLessFrontAMD", SpvWord{5081}}, + {"boMergeINTEL", SpvWord{5834}}, + {"boClobberINTEL", SpvWord{5607}}, + {"bpCurrentRayTimeNV", SpvWord{5334}}, + {"boNonUniformEXT", SpvWord{5300}}, + {"adNone", SpvWord{0}}, + {"boSingleElementVectorINTEL", SpvWord{6085}}, + {"akOpenCL_CPP", SpvWord{4}}, + {"cdFPMaxErrorINTEL", SpvWord{6169}}, + {"bpLaunchSizeKHR", SpvWord{5320}}, + {"cdStorageUniform16", SpvWord{4434}}, + {"beIntensity", SpvWord{8}}, + {"bpLaunchIdNV", SpvWord{5319}}, + {"chPackedVectorFormat4x8Bit", SpvWord{0}}, + {"cdSampleRateShading", SpvWord{35}}, + {"cdStoragePushConstant8", SpvWord{4450}}, + {"cdTextureBoxFilterQCOM", SpvWord{4485}}, + {"bpViewportMaskPerViewNV", SpvWord{5262}}, + {"cdGroupNonUniformBallot", SpvWord{64}}, + {"ajVertical4Pixels", SpvWord{2}}, + {"cdTextureSampleWeightedQCOM", SpvWord{4484}}, + {"cdImageGatherExtended", SpvWord{25}}, + {"cdAsmINTEL", SpvWord{5606}}, + {"boNonReadable", SpvWord{25}}, + {"boBuiltIn", SpvWord{11}}, + {"bpHitKindKHR", SpvWord{5333}}, + {"aoRoundingModeRTNINTEL", SpvWord{5621}}, + {"cdWorkgroupMemoryExplicitLayoutKHR", SpvWord{4428}}, + {"caQueueFamily", SpvWord{5}}, + {"beDepthStencil", SpvWord{14}}, + {"aoOriginLowerLeft", SpvWord{8}}, + {"cdUniformTexelBufferArrayNonUniformIndexing", SpvWord{5311}}, + {"alClosestHitKHR", SpvWord{5316}}, + {"biTRN_ZERO", SpvWord{1}}, + {"aaLod", SpvWord{2}}, + {"cdUniformBufferArrayDynamicIndexing", SpvWord{28}}, + {"boSimpleDualPortINTEL", SpvWord{5833}}, + {"ceRayQueryCandidateIntersectionKHR", SpvWord{0}}, + {"cdAtomicFloat16AddEXT", SpvWord{6095}}, + {"beRGx", SpvWord{11}}, + {"bpBaryCoordNoPerspSampleAMD", SpvWord{4994}}, + {"afMakeVisible", SpvWord{16384}}, + {"ciSaturatingAccumulationKHR", SpvWord{16}}, + {"cdDotProductInput4x8BitKHR", SpvWord{6017}}, + {"cdNamedBarrier", SpvWord{59}}, + {"boLinkageAttributes", SpvWord{41}}, + {"caWorkgroup", SpvWord{2}}, + {"apTileImageEXT", SpvWord{4172}}, + {"boCacheSizeINTEL", SpvWord{5900}}, + {"beRGB", SpvWord{4}}, + {"boMMHostInterfaceLatencyINTEL", SpvWord{6179}}, + {"boNoContraction", SpvWord{42}}, + {"aoRegisterMapInterfaceINTEL", SpvWord{6160}}, + {"ceRayQueryCommittedIntersectionKHR", SpvWord{1}}, + {"cdFPGAMemoryAttributesINTEL", SpvWord{5824}}, + {"bfSnormInt16", SpvWord{1}}, + {"bnRuntimeAlignedINTEL", SpvWord{5940}}, + {"bpGlobalInvocationId", SpvWord{28}}, + {"cdImageReadWrite", SpvWord{14}}, + {"bpInstanceCustomIndexNV", SpvWord{5327}}, + {"bpSubgroupMaxSize", SpvWord{37}}, + {"cdVectorComputeINTEL", SpvWord{5617}}, + {"beR", SpvWord{0}}, + {"bhPreserve", SpvWord{0}}, + {"cdSubgroupDispatch", SpvWord{58}}, + {"apTaskPayloadWorkgroupEXT", SpvWord{5402}}, + {"bdRg32ui", SpvWord{35}}, + {"alMissNV", SpvWord{5317}}, + {"aoPixelInterlockOrderedEXT", SpvWord{5366}}, + {"cdDenormPreserve", SpvWord{4464}}, + {"aeOptNoneINTEL", SpvWord{65536}}, + {"cdPhysicalStorageBufferAddresses", SpvWord{5347}}, + {"bdR64i", SpvWord{41}}, + {"boNumbanksINTEL", SpvWord{5827}}, + {"cdFragmentShaderSampleInterlockEXT", SpvWord{5363}}, + {"cdOptNoneINTEL", SpvWord{6094}}, + {"aiSkipTrianglesKHR", SpvWord{256}}, + {"cdStorageTexelBufferArrayNonUniformIndexing", SpvWord{5312}}, + {"beRGBx", SpvWord{12}}, + {"bpIncomingRayFlagsKHR", SpvWord{5351}}, + {"aoStencilRefGreaterBackAMD", SpvWord{5083}}, + {"boMMHostInterfaceMaxBurstINTEL", SpvWord{6181}}, + {"aoFloatingPointModeIEEEINTEL", SpvWord{5623}}, + {"alMeshEXT", SpvWord{5365}}, + {"cdShaderLayer", SpvWord{69}}, + {"cdFPGAMemoryAccessesINTEL", SpvWord{5898}}, + {"bpSecondaryViewportMaskNV", SpvWord{5258}}, + {"cdArbitraryPrecisionIntegersINTEL", SpvWord{5844}}, + {"ccWaitWorkGroup", SpvWord{2}}, + {"aoOutputLinesNV", SpvWord{5269}}, + {"aoOutputTriangleStrip", SpvWord{29}}, + {"baRect", SpvWord{4}}, + {"bpFragStencilRefEXT", SpvWord{5014}}, + {"blLinkOnceODR", SpvWord{2}}, + {"aoLocalSizeId", SpvWord{38}}, + {"abNSZ", SpvWord{4}}, + {"bdRg16i", SpvWord{26}}, + {"boMaxConcurrencyINTEL", SpvWord{5918}}, + {"akESSL", SpvWord{1}}, + {"caSubgroup", SpvWord{3}}, + {"bpFrontFacing", SpvWord{17}}, + {"boWeightTextureQCOM", SpvWord{4487}}, + {"aoNoGlobalOffsetINTEL", SpvWord{5895}}, + {"bpViewportMaskNV", SpvWord{5253}}, + {"bdRgb10A2", SpvWord{11}}, + {"aaNonPrivateTexel", SpvWord{1024}}, + {"cdUniformTexelBufferArrayDynamicIndexing", SpvWord{5304}}, + {"bpViewIndex", SpvWord{4440}}, + {"afAtomicCounterMemory", SpvWord{1024}}, + {"bpGlobalSize", SpvWord{31}}, + {"bpMeshViewCountNV", SpvWord{5280}}, + {"cdImageBuffer", SpvWord{47}}, + {"alGeometry", SpvWord{3}}, + {"agVolatile", SpvWord{1}}, + {"bdRg8", SpvWord{13}}, + {"cdIndirectReferencesINTEL", SpvWord{5604}}, + {"biRND_MIN_INF", SpvWord{5}}, + {"bpBaryCoordSmoothSampleAMD", SpvWord{4997}}, + {"cdVulkanMemoryModelKHR", SpvWord{5345}}, + {"aoNamedBarrierCountINTEL", SpvWord{6417}}, + {"cdShaderNonUniform", SpvWord{5301}}, + {"adMaxIterations", SpvWord{32}}, + {"aaMinLod", SpvWord{128}}, + {"boFPFastMathMode", SpvWord{40}}, + {"bpFullyCoveredEXT", SpvWord{5264}}, + {"bpClipDistance", SpvWord{3}}, + {"cdArbitraryPrecisionFixedPointINTEL", SpvWord{5922}}, + {"bpBaseInstance", SpvWord{4425}}, + {"cdMultiView", SpvWord{4439}}, + {"bpInstanceIndex", SpvWord{43}}, + {"bdRg8ui", SpvWord{37}}, + {"aoMaxWorkDimINTEL", SpvWord{5894}}, + {"cdInputAttachmentArrayNonUniformIndexingEXT", SpvWord{5310}}, + {"amPhysicalStorageBuffer64", SpvWord{5348}}, + {"aaMakeTexelVisibleKHR", SpvWord{512}}, + {"cdUniformTexelBufferArrayDynamicIndexingEXT", SpvWord{5304}}, + {"besRGB", SpvWord{15}}, + {"aaNone", SpvWord{0}}, + {"alGLCompute", SpvWord{5}}, + {"bbRepeatMirrored", SpvWord{4}}, + {"baBuffer", SpvWord{5}}, + {"cdGeometryStreams", SpvWord{54}}, + {"boDescriptorSet", SpvWord{34}}, + {"aoLocalSize", SpvWord{17}}, + {"cdShaderViewportIndex", SpvWord{70}}, + {"cdStorageTexelBufferArrayNonUniformIndexingEXT", SpvWord{5312}}, + {"boBankwidthINTEL", SpvWord{5828}}, + {"bfFloat", SpvWord{14}}, + {"beARGB", SpvWord{7}}, + {"cdStorageImageReadWithoutFormat", SpvWord{55}}, + {"bpCoreMaxIDARM", SpvWord{4162}}, + {"cdRayCullMaskKHR", SpvWord{6020}}, + {"cdShaderSMBuiltinsNV", SpvWord{5373}}, + {"aiTerminateOnFirstHitKHR", SpvWord{4}}, + {"cdWorkgroupMemoryExplicitLayout8BitAccessKHR", SpvWord{4429}}, + {"bpWarpMaxIDARM", SpvWord{4164}}, + {"aoDepthUnchanged", SpvWord{16}}, + {"alTessellationEvaluation", SpvWord{2}}, + {"cdStorageBuffer16BitAccess", SpvWord{4433}}, + {"aoSampleInterlockUnorderedEXT", SpvWord{5369}}, + {"bpHitTNV", SpvWord{5332}}, + {"bdR16f", SpvWord{9}}, + {"aaMakeTexelAvailable", SpvWord{256}}, + {"aoDerivativeGroupLinearNV", SpvWord{5290}}, + {"apWorkgroup", SpvWord{4}}, + {"bnNoCapture", SpvWord{5}}, + {"cdFloat16ImageAMD", SpvWord{5008}}, + {"aoOutputTrianglesEXT", SpvWord{5298}}, + {"bfUnsignedInt16", SpvWord{11}}, + {"cdTessellation", SpvWord{3}}, + {"cdImageGatherBiasLodAMD", SpvWord{5009}}, + {"bpLocalInvocationId", SpvWord{27}}, + {"anGLSL450", SpvWord{1}}, + {"aoShadingRateInterlockUnorderedEXT", SpvWord{5371}}, + {"boStream", SpvWord{29}}, + {"boFPMaxErrorDecorationINTEL", SpvWord{6170}}, + {"cdCooperativeMatrixNV", SpvWord{5357}}, + {"cdInt64Atomics", SpvWord{12}}, + {"amLogical", SpvWord{0}}, + {"cdPhysicalStorageBufferAddressesEXT", SpvWord{5347}}, + {"alKernel", SpvWord{6}}, + {"cdTransformFeedback", SpvWord{53}}, + {"aoXfb", SpvWord{11}}, + {"aePure", SpvWord{4}}, + {"bpFragDepth", SpvWord{22}}, + {"ajVertical2Pixels", SpvWord{1}}, + {"aoInitializer", SpvWord{33}}, + {"bpBaryCoordNoPerspKHR", SpvWord{5287}}, + {"adPartialCount", SpvWord{256}}, + {"cdRayTracingPositionFetchKHR", SpvWord{5336}}, + {"cdAtomicFloat64MinMaxEXT", SpvWord{5613}}, + {"cfRayQueryCommittedIntersectionTriangleKHR", SpvWord{1}}, + {"aoInputPoints", SpvWord{19}}, + {"alAnyHitNV", SpvWord{5315}}, + {"cdTessellationPointSize", SpvWord{23}}, + {"aaOffsets", SpvWord{65536}}, + {"cdInt16", SpvWord{22}}, + {"cdRayTracingKHR", SpvWord{4479}}, + {"cdImageRect", SpvWord{36}}, + {"cdInt8", SpvWord{39}}, + {"bpObjectRayDirectionKHR", SpvWord{5324}}, + {"bpSubgroupId", SpvWord{40}}, + {"cdFragmentBarycentricNV", SpvWord{5284}}, + {"cdDotProductInputAllKHR", SpvWord{6016}}, + {"aoFloatingPointModeALTINTEL", SpvWord{5622}}, + {"cdMultiViewport", SpvWord{57}}, + {"boVectorComputeVariableINTEL", SpvWord{5624}}, + {"cdGroupUniformArithmeticKHR", SpvWord{6400}}, + {"bpMeshViewIndicesNV", SpvWord{5281}}, + {"cdFPFastMathModeINTEL", SpvWord{5837}}, + {"aoSpacingEqual", SpvWord{1}}, + {"bpPrimitivePointIndicesEXT", SpvWord{5294}}, + {"bpWorldToObjectKHR", SpvWord{5331}}, + {"boBinding", SpvWord{33}}, + {"cdGroupNonUniformClustered", SpvWord{67}}, + {"boUserSemantic", SpvWord{5635}}, + {"aoDepthLess", SpvWord{15}}, + {"adMinIterations", SpvWord{16}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 944; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupQualifiedEnum(const QualifiedEnumName& k, SpvWord& v) +{ + static_assert(sizeof(k.kind.index) == 1); + if(k.name.getLength() > 46) + return false; + char name[48]; + name[0] = char((k.kind.index >> 4) + 'a'); + name[1] = char((k.kind.index & 0xf) + 'a'); + memcpy(name+2, k.name.begin(), k.name.getLength()); + return lookupEnumWithHexPrefix(UnownedStringSlice(name, k.name.getLength() + 2), v); +} + +static bool getQualifiedEnumName(const QualifiedEnumValue& k, UnownedStringSlice& v) +{ + const auto& [k1, k2] = k; + switch(k1.index) + { + case 0: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Bias"}; return true; + case 2: v = UnownedStringSlice{"Lod"}; return true; + case 4: v = UnownedStringSlice{"Grad"}; return true; + case 8: v = UnownedStringSlice{"ConstOffset"}; return true; + case 16: v = UnownedStringSlice{"Offset"}; return true; + case 32: v = UnownedStringSlice{"ConstOffsets"}; return true; + case 64: v = UnownedStringSlice{"Sample"}; return true; + case 128: v = UnownedStringSlice{"MinLod"}; return true; + case 256: v = UnownedStringSlice{"MakeTexelAvailable"}; return true; + case 512: v = UnownedStringSlice{"MakeTexelVisible"}; return true; + case 1024: v = UnownedStringSlice{"NonPrivateTexel"}; return true; + case 2048: v = UnownedStringSlice{"VolatileTexel"}; return true; + case 4096: v = UnownedStringSlice{"SignExtend"}; return true; + case 8192: v = UnownedStringSlice{"ZeroExtend"}; return true; + case 16384: v = UnownedStringSlice{"Nontemporal"}; return true; + case 65536: v = UnownedStringSlice{"Offsets"}; return true; + default: return false; + } + case 1: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"NotNaN"}; return true; + case 2: v = UnownedStringSlice{"NotInf"}; return true; + case 4: v = UnownedStringSlice{"NSZ"}; return true; + case 8: v = UnownedStringSlice{"AllowRecip"}; return true; + case 16: v = UnownedStringSlice{"Fast"}; return true; + case 65536: v = UnownedStringSlice{"AllowContractFastINTEL"}; return true; + case 131072: v = UnownedStringSlice{"AllowReassocINTEL"}; return true; + default: return false; + } + case 2: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Flatten"}; return true; + case 2: v = UnownedStringSlice{"DontFlatten"}; return true; + default: return false; + } + case 3: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Unroll"}; return true; + case 2: v = UnownedStringSlice{"DontUnroll"}; return true; + case 4: v = UnownedStringSlice{"DependencyInfinite"}; return true; + case 8: v = UnownedStringSlice{"DependencyLength"}; return true; + case 16: v = UnownedStringSlice{"MinIterations"}; return true; + case 32: v = UnownedStringSlice{"MaxIterations"}; return true; + case 64: v = UnownedStringSlice{"IterationMultiple"}; return true; + case 128: v = UnownedStringSlice{"PeelCount"}; return true; + case 256: v = UnownedStringSlice{"PartialCount"}; return true; + case 65536: v = UnownedStringSlice{"InitiationIntervalINTEL"}; return true; + case 131072: v = UnownedStringSlice{"MaxConcurrencyINTEL"}; return true; + case 262144: v = UnownedStringSlice{"DependencyArrayINTEL"}; return true; + case 524288: v = UnownedStringSlice{"PipelineEnableINTEL"}; return true; + case 1048576: v = UnownedStringSlice{"LoopCoalesceINTEL"}; return true; + case 2097152: v = UnownedStringSlice{"MaxInterleavingINTEL"}; return true; + case 4194304: v = UnownedStringSlice{"SpeculatedIterationsINTEL"}; return true; + case 8388608: v = UnownedStringSlice{"NoFusionINTEL"}; return true; + case 16777216: v = UnownedStringSlice{"LoopCountINTEL"}; return true; + case 33554432: v = UnownedStringSlice{"MaxReinvocationDelayINTEL"}; return true; + default: return false; + } + case 4: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Inline"}; return true; + case 2: v = UnownedStringSlice{"DontInline"}; return true; + case 4: v = UnownedStringSlice{"Pure"}; return true; + case 8: v = UnownedStringSlice{"Const"}; return true; + case 65536: v = UnownedStringSlice{"OptNoneINTEL"}; return true; + default: return false; + } + case 5: + switch(k2) + { + case 0: v = UnownedStringSlice{"Relaxed"}; return true; + case 2: v = UnownedStringSlice{"Acquire"}; return true; + case 4: v = UnownedStringSlice{"Release"}; return true; + case 8: v = UnownedStringSlice{"AcquireRelease"}; return true; + case 16: v = UnownedStringSlice{"SequentiallyConsistent"}; return true; + case 64: v = UnownedStringSlice{"UniformMemory"}; return true; + case 128: v = UnownedStringSlice{"SubgroupMemory"}; return true; + case 256: v = UnownedStringSlice{"WorkgroupMemory"}; return true; + case 512: v = UnownedStringSlice{"CrossWorkgroupMemory"}; return true; + case 1024: v = UnownedStringSlice{"AtomicCounterMemory"}; return true; + case 2048: v = UnownedStringSlice{"ImageMemory"}; return true; + case 4096: v = UnownedStringSlice{"OutputMemory"}; return true; + case 8192: v = UnownedStringSlice{"MakeAvailable"}; return true; + case 16384: v = UnownedStringSlice{"MakeVisible"}; return true; + case 32768: v = UnownedStringSlice{"Volatile"}; return true; + default: return false; + } + case 6: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Volatile"}; return true; + case 2: v = UnownedStringSlice{"Aligned"}; return true; + case 4: v = UnownedStringSlice{"Nontemporal"}; return true; + case 8: v = UnownedStringSlice{"MakePointerAvailable"}; return true; + case 16: v = UnownedStringSlice{"MakePointerVisible"}; return true; + case 32: v = UnownedStringSlice{"NonPrivatePointer"}; return true; + case 65536: v = UnownedStringSlice{"AliasScopeINTELMask"}; return true; + case 131072: v = UnownedStringSlice{"NoAliasINTELMask"}; return true; + default: return false; + } + case 7: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"CmdExecTime"}; return true; + default: return false; + } + case 8: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoneKHR"}; return true; + case 1: v = UnownedStringSlice{"OpaqueKHR"}; return true; + case 2: v = UnownedStringSlice{"NoOpaqueKHR"}; return true; + case 4: v = UnownedStringSlice{"TerminateOnFirstHitKHR"}; return true; + case 8: v = UnownedStringSlice{"SkipClosestHitShaderKHR"}; return true; + case 16: v = UnownedStringSlice{"CullBackFacingTrianglesKHR"}; return true; + case 32: v = UnownedStringSlice{"CullFrontFacingTrianglesKHR"}; return true; + case 64: v = UnownedStringSlice{"CullOpaqueKHR"}; return true; + case 128: v = UnownedStringSlice{"CullNoOpaqueKHR"}; return true; + case 256: v = UnownedStringSlice{"SkipTrianglesKHR"}; return true; + case 512: v = UnownedStringSlice{"SkipAABBsKHR"}; return true; + case 1024: v = UnownedStringSlice{"ForceOpacityMicromap2StateEXT"}; return true; + default: return false; + } + case 9: + switch(k2) + { + case 1: v = UnownedStringSlice{"Vertical2Pixels"}; return true; + case 2: v = UnownedStringSlice{"Vertical4Pixels"}; return true; + case 4: v = UnownedStringSlice{"Horizontal2Pixels"}; return true; + case 8: v = UnownedStringSlice{"Horizontal4Pixels"}; return true; + default: return false; + } + case 10: + switch(k2) + { + case 0: v = UnownedStringSlice{"Unknown"}; return true; + case 1: v = UnownedStringSlice{"ESSL"}; return true; + case 2: v = UnownedStringSlice{"GLSL"}; return true; + case 3: v = UnownedStringSlice{"OpenCL_C"}; return true; + case 4: v = UnownedStringSlice{"OpenCL_CPP"}; return true; + case 5: v = UnownedStringSlice{"HLSL"}; return true; + case 6: v = UnownedStringSlice{"CPP_for_OpenCL"}; return true; + case 7: v = UnownedStringSlice{"SYCL"}; return true; + case 8: v = UnownedStringSlice{"HERO_C"}; return true; + case 9: v = UnownedStringSlice{"NZSL"}; return true; + case 10: v = UnownedStringSlice{"WGSL"}; return true; + default: return false; + } + case 11: + switch(k2) + { + case 0: v = UnownedStringSlice{"Vertex"}; return true; + case 1: v = UnownedStringSlice{"TessellationControl"}; return true; + case 2: v = UnownedStringSlice{"TessellationEvaluation"}; return true; + case 3: v = UnownedStringSlice{"Geometry"}; return true; + case 4: v = UnownedStringSlice{"Fragment"}; return true; + case 5: v = UnownedStringSlice{"GLCompute"}; return true; + case 6: v = UnownedStringSlice{"Kernel"}; return true; + case 5267: v = UnownedStringSlice{"TaskNV"}; return true; + case 5268: v = UnownedStringSlice{"MeshNV"}; return true; + case 5313: v = UnownedStringSlice{"RayGenerationNV"}; return true; + case 5314: v = UnownedStringSlice{"IntersectionNV"}; return true; + case 5315: v = UnownedStringSlice{"AnyHitNV"}; return true; + case 5316: v = UnownedStringSlice{"ClosestHitNV"}; return true; + case 5317: v = UnownedStringSlice{"MissNV"}; return true; + case 5318: v = UnownedStringSlice{"CallableNV"}; return true; + case 5364: v = UnownedStringSlice{"TaskEXT"}; return true; + case 5365: v = UnownedStringSlice{"MeshEXT"}; return true; + default: return false; + } + case 12: + switch(k2) + { + case 0: v = UnownedStringSlice{"Logical"}; return true; + case 1: v = UnownedStringSlice{"Physical32"}; return true; + case 2: v = UnownedStringSlice{"Physical64"}; return true; + case 5348: v = UnownedStringSlice{"PhysicalStorageBuffer64"}; return true; + default: return false; + } + case 13: + switch(k2) + { + case 0: v = UnownedStringSlice{"Simple"}; return true; + case 1: v = UnownedStringSlice{"GLSL450"}; return true; + case 2: v = UnownedStringSlice{"OpenCL"}; return true; + case 3: v = UnownedStringSlice{"Vulkan"}; return true; + default: return false; + } + case 14: + switch(k2) + { + case 0: v = UnownedStringSlice{"Invocations"}; return true; + case 1: v = UnownedStringSlice{"SpacingEqual"}; return true; + case 2: v = UnownedStringSlice{"SpacingFractionalEven"}; return true; + case 3: v = UnownedStringSlice{"SpacingFractionalOdd"}; return true; + case 4: v = UnownedStringSlice{"VertexOrderCw"}; return true; + case 5: v = UnownedStringSlice{"VertexOrderCcw"}; return true; + case 6: v = UnownedStringSlice{"PixelCenterInteger"}; return true; + case 7: v = UnownedStringSlice{"OriginUpperLeft"}; return true; + case 8: v = UnownedStringSlice{"OriginLowerLeft"}; return true; + case 9: v = UnownedStringSlice{"EarlyFragmentTests"}; return true; + case 10: v = UnownedStringSlice{"PointMode"}; return true; + case 11: v = UnownedStringSlice{"Xfb"}; return true; + case 12: v = UnownedStringSlice{"DepthReplacing"}; return true; + case 14: v = UnownedStringSlice{"DepthGreater"}; return true; + case 15: v = UnownedStringSlice{"DepthLess"}; return true; + case 16: v = UnownedStringSlice{"DepthUnchanged"}; return true; + case 17: v = UnownedStringSlice{"LocalSize"}; return true; + case 18: v = UnownedStringSlice{"LocalSizeHint"}; return true; + case 19: v = UnownedStringSlice{"InputPoints"}; return true; + case 20: v = UnownedStringSlice{"InputLines"}; return true; + case 21: v = UnownedStringSlice{"InputLinesAdjacency"}; return true; + case 22: v = UnownedStringSlice{"Triangles"}; return true; + case 23: v = UnownedStringSlice{"InputTrianglesAdjacency"}; return true; + case 24: v = UnownedStringSlice{"Quads"}; return true; + case 25: v = UnownedStringSlice{"Isolines"}; return true; + case 26: v = UnownedStringSlice{"OutputVertices"}; return true; + case 27: v = UnownedStringSlice{"OutputPoints"}; return true; + case 28: v = UnownedStringSlice{"OutputLineStrip"}; return true; + case 29: v = UnownedStringSlice{"OutputTriangleStrip"}; return true; + case 30: v = UnownedStringSlice{"VecTypeHint"}; return true; + case 31: v = UnownedStringSlice{"ContractionOff"}; return true; + case 33: v = UnownedStringSlice{"Initializer"}; return true; + case 34: v = UnownedStringSlice{"Finalizer"}; return true; + case 35: v = UnownedStringSlice{"SubgroupSize"}; return true; + case 36: v = UnownedStringSlice{"SubgroupsPerWorkgroup"}; return true; + case 37: v = UnownedStringSlice{"SubgroupsPerWorkgroupId"}; return true; + case 38: v = UnownedStringSlice{"LocalSizeId"}; return true; + case 39: v = UnownedStringSlice{"LocalSizeHintId"}; return true; + case 4169: v = UnownedStringSlice{"NonCoherentColorAttachmentReadEXT"}; return true; + case 4170: v = UnownedStringSlice{"NonCoherentDepthAttachmentReadEXT"}; return true; + case 4171: v = UnownedStringSlice{"NonCoherentStencilAttachmentReadEXT"}; return true; + case 4421: v = UnownedStringSlice{"SubgroupUniformControlFlowKHR"}; return true; + case 4446: v = UnownedStringSlice{"PostDepthCoverage"}; return true; + case 4459: v = UnownedStringSlice{"DenormPreserve"}; return true; + case 4460: v = UnownedStringSlice{"DenormFlushToZero"}; return true; + case 4461: v = UnownedStringSlice{"SignedZeroInfNanPreserve"}; return true; + case 4462: v = UnownedStringSlice{"RoundingModeRTE"}; return true; + case 4463: v = UnownedStringSlice{"RoundingModeRTZ"}; return true; + case 5017: v = UnownedStringSlice{"EarlyAndLateFragmentTestsAMD"}; return true; + case 5027: v = UnownedStringSlice{"StencilRefReplacingEXT"}; return true; + case 5079: v = UnownedStringSlice{"StencilRefUnchangedFrontAMD"}; return true; + case 5080: v = UnownedStringSlice{"StencilRefGreaterFrontAMD"}; return true; + case 5081: v = UnownedStringSlice{"StencilRefLessFrontAMD"}; return true; + case 5082: v = UnownedStringSlice{"StencilRefUnchangedBackAMD"}; return true; + case 5083: v = UnownedStringSlice{"StencilRefGreaterBackAMD"}; return true; + case 5084: v = UnownedStringSlice{"StencilRefLessBackAMD"}; return true; + case 5269: v = UnownedStringSlice{"OutputLinesNV"}; return true; + case 5270: v = UnownedStringSlice{"OutputPrimitivesNV"}; return true; + case 5289: v = UnownedStringSlice{"DerivativeGroupQuadsNV"}; return true; + case 5290: v = UnownedStringSlice{"DerivativeGroupLinearNV"}; return true; + case 5298: v = UnownedStringSlice{"OutputTrianglesNV"}; return true; + case 5366: v = UnownedStringSlice{"PixelInterlockOrderedEXT"}; return true; + case 5367: v = UnownedStringSlice{"PixelInterlockUnorderedEXT"}; return true; + case 5368: v = UnownedStringSlice{"SampleInterlockOrderedEXT"}; return true; + case 5369: v = UnownedStringSlice{"SampleInterlockUnorderedEXT"}; return true; + case 5370: v = UnownedStringSlice{"ShadingRateInterlockOrderedEXT"}; return true; + case 5371: v = UnownedStringSlice{"ShadingRateInterlockUnorderedEXT"}; return true; + case 5618: v = UnownedStringSlice{"SharedLocalMemorySizeINTEL"}; return true; + case 5620: v = UnownedStringSlice{"RoundingModeRTPINTEL"}; return true; + case 5621: v = UnownedStringSlice{"RoundingModeRTNINTEL"}; return true; + case 5622: v = UnownedStringSlice{"FloatingPointModeALTINTEL"}; return true; + case 5623: v = UnownedStringSlice{"FloatingPointModeIEEEINTEL"}; return true; + case 5893: v = UnownedStringSlice{"MaxWorkgroupSizeINTEL"}; return true; + case 5894: v = UnownedStringSlice{"MaxWorkDimINTEL"}; return true; + case 5895: v = UnownedStringSlice{"NoGlobalOffsetINTEL"}; return true; + case 5896: v = UnownedStringSlice{"NumSIMDWorkitemsINTEL"}; return true; + case 5903: v = UnownedStringSlice{"SchedulerTargetFmaxMhzINTEL"}; return true; + case 6154: v = UnownedStringSlice{"StreamingInterfaceINTEL"}; return true; + case 6160: v = UnownedStringSlice{"RegisterMapInterfaceINTEL"}; return true; + case 6417: v = UnownedStringSlice{"NamedBarrierCountINTEL"}; return true; + default: return false; + } + case 15: + switch(k2) + { + case 0: v = UnownedStringSlice{"UniformConstant"}; return true; + case 1: v = UnownedStringSlice{"Input"}; return true; + case 2: v = UnownedStringSlice{"Uniform"}; return true; + case 3: v = UnownedStringSlice{"Output"}; return true; + case 4: v = UnownedStringSlice{"Workgroup"}; return true; + case 5: v = UnownedStringSlice{"CrossWorkgroup"}; return true; + case 6: v = UnownedStringSlice{"Private"}; return true; + case 7: v = UnownedStringSlice{"Function"}; return true; + case 8: v = UnownedStringSlice{"Generic"}; return true; + case 9: v = UnownedStringSlice{"PushConstant"}; return true; + case 10: v = UnownedStringSlice{"AtomicCounter"}; return true; + case 11: v = UnownedStringSlice{"Image"}; return true; + case 12: v = UnownedStringSlice{"StorageBuffer"}; return true; + case 4172: v = UnownedStringSlice{"TileImageEXT"}; return true; + case 5328: v = UnownedStringSlice{"CallableDataNV"}; return true; + case 5329: v = UnownedStringSlice{"IncomingCallableDataNV"}; return true; + case 5338: v = UnownedStringSlice{"RayPayloadNV"}; return true; + case 5339: v = UnownedStringSlice{"HitAttributeNV"}; return true; + case 5342: v = UnownedStringSlice{"IncomingRayPayloadNV"}; return true; + case 5343: v = UnownedStringSlice{"ShaderRecordBufferNV"}; return true; + case 5349: v = UnownedStringSlice{"PhysicalStorageBuffer"}; return true; + case 5385: v = UnownedStringSlice{"HitObjectAttributeNV"}; return true; + case 5402: v = UnownedStringSlice{"TaskPayloadWorkgroupEXT"}; return true; + case 5605: v = UnownedStringSlice{"CodeSectionINTEL"}; return true; + case 5936: v = UnownedStringSlice{"DeviceOnlyINTEL"}; return true; + case 5937: v = UnownedStringSlice{"HostOnlyINTEL"}; return true; + default: return false; + } + case 16: + switch(k2) + { + case 0: v = UnownedStringSlice{"1D"}; return true; + case 1: v = UnownedStringSlice{"2D"}; return true; + case 2: v = UnownedStringSlice{"3D"}; return true; + case 3: v = UnownedStringSlice{"Cube"}; return true; + case 4: v = UnownedStringSlice{"Rect"}; return true; + case 5: v = UnownedStringSlice{"Buffer"}; return true; + case 6: v = UnownedStringSlice{"SubpassData"}; return true; + case 4173: v = UnownedStringSlice{"TileImageDataEXT"}; return true; + default: return false; + } + case 17: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"ClampToEdge"}; return true; + case 2: v = UnownedStringSlice{"Clamp"}; return true; + case 3: v = UnownedStringSlice{"Repeat"}; return true; + case 4: v = UnownedStringSlice{"RepeatMirrored"}; return true; + default: return false; + } + case 18: + switch(k2) + { + case 0: v = UnownedStringSlice{"Nearest"}; return true; + case 1: v = UnownedStringSlice{"Linear"}; return true; + default: return false; + } + case 19: + switch(k2) + { + case 0: v = UnownedStringSlice{"Unknown"}; return true; + case 1: v = UnownedStringSlice{"Rgba32f"}; return true; + case 2: v = UnownedStringSlice{"Rgba16f"}; return true; + case 3: v = UnownedStringSlice{"R32f"}; return true; + case 4: v = UnownedStringSlice{"Rgba8"}; return true; + case 5: v = UnownedStringSlice{"Rgba8Snorm"}; return true; + case 6: v = UnownedStringSlice{"Rg32f"}; return true; + case 7: v = UnownedStringSlice{"Rg16f"}; return true; + case 8: v = UnownedStringSlice{"R11fG11fB10f"}; return true; + case 9: v = UnownedStringSlice{"R16f"}; return true; + case 10: v = UnownedStringSlice{"Rgba16"}; return true; + case 11: v = UnownedStringSlice{"Rgb10A2"}; return true; + case 12: v = UnownedStringSlice{"Rg16"}; return true; + case 13: v = UnownedStringSlice{"Rg8"}; return true; + case 14: v = UnownedStringSlice{"R16"}; return true; + case 15: v = UnownedStringSlice{"R8"}; return true; + case 16: v = UnownedStringSlice{"Rgba16Snorm"}; return true; + case 17: v = UnownedStringSlice{"Rg16Snorm"}; return true; + case 18: v = UnownedStringSlice{"Rg8Snorm"}; return true; + case 19: v = UnownedStringSlice{"R16Snorm"}; return true; + case 20: v = UnownedStringSlice{"R8Snorm"}; return true; + case 21: v = UnownedStringSlice{"Rgba32i"}; return true; + case 22: v = UnownedStringSlice{"Rgba16i"}; return true; + case 23: v = UnownedStringSlice{"Rgba8i"}; return true; + case 24: v = UnownedStringSlice{"R32i"}; return true; + case 25: v = UnownedStringSlice{"Rg32i"}; return true; + case 26: v = UnownedStringSlice{"Rg16i"}; return true; + case 27: v = UnownedStringSlice{"Rg8i"}; return true; + case 28: v = UnownedStringSlice{"R16i"}; return true; + case 29: v = UnownedStringSlice{"R8i"}; return true; + case 30: v = UnownedStringSlice{"Rgba32ui"}; return true; + case 31: v = UnownedStringSlice{"Rgba16ui"}; return true; + case 32: v = UnownedStringSlice{"Rgba8ui"}; return true; + case 33: v = UnownedStringSlice{"R32ui"}; return true; + case 34: v = UnownedStringSlice{"Rgb10a2ui"}; return true; + case 35: v = UnownedStringSlice{"Rg32ui"}; return true; + case 36: v = UnownedStringSlice{"Rg16ui"}; return true; + case 37: v = UnownedStringSlice{"Rg8ui"}; return true; + case 38: v = UnownedStringSlice{"R16ui"}; return true; + case 39: v = UnownedStringSlice{"R8ui"}; return true; + case 40: v = UnownedStringSlice{"R64ui"}; return true; + case 41: v = UnownedStringSlice{"R64i"}; return true; + default: return false; + } + case 20: + switch(k2) + { + case 0: v = UnownedStringSlice{"R"}; return true; + case 1: v = UnownedStringSlice{"A"}; return true; + case 2: v = UnownedStringSlice{"RG"}; return true; + case 3: v = UnownedStringSlice{"RA"}; return true; + case 4: v = UnownedStringSlice{"RGB"}; return true; + case 5: v = UnownedStringSlice{"RGBA"}; return true; + case 6: v = UnownedStringSlice{"BGRA"}; return true; + case 7: v = UnownedStringSlice{"ARGB"}; return true; + case 8: v = UnownedStringSlice{"Intensity"}; return true; + case 9: v = UnownedStringSlice{"Luminance"}; return true; + case 10: v = UnownedStringSlice{"Rx"}; return true; + case 11: v = UnownedStringSlice{"RGx"}; return true; + case 12: v = UnownedStringSlice{"RGBx"}; return true; + case 13: v = UnownedStringSlice{"Depth"}; return true; + case 14: v = UnownedStringSlice{"DepthStencil"}; return true; + case 15: v = UnownedStringSlice{"sRGB"}; return true; + case 16: v = UnownedStringSlice{"sRGBx"}; return true; + case 17: v = UnownedStringSlice{"sRGBA"}; return true; + case 18: v = UnownedStringSlice{"sBGRA"}; return true; + case 19: v = UnownedStringSlice{"ABGR"}; return true; + default: return false; + } + case 21: + switch(k2) + { + case 0: v = UnownedStringSlice{"SnormInt8"}; return true; + case 1: v = UnownedStringSlice{"SnormInt16"}; return true; + case 2: v = UnownedStringSlice{"UnormInt8"}; return true; + case 3: v = UnownedStringSlice{"UnormInt16"}; return true; + case 4: v = UnownedStringSlice{"UnormShort565"}; return true; + case 5: v = UnownedStringSlice{"UnormShort555"}; return true; + case 6: v = UnownedStringSlice{"UnormInt101010"}; return true; + case 7: v = UnownedStringSlice{"SignedInt8"}; return true; + case 8: v = UnownedStringSlice{"SignedInt16"}; return true; + case 9: v = UnownedStringSlice{"SignedInt32"}; return true; + case 10: v = UnownedStringSlice{"UnsignedInt8"}; return true; + case 11: v = UnownedStringSlice{"UnsignedInt16"}; return true; + case 12: v = UnownedStringSlice{"UnsignedInt32"}; return true; + case 13: v = UnownedStringSlice{"HalfFloat"}; return true; + case 14: v = UnownedStringSlice{"Float"}; return true; + case 15: v = UnownedStringSlice{"UnormInt24"}; return true; + case 16: v = UnownedStringSlice{"UnormInt101010_2"}; return true; + case 19: v = UnownedStringSlice{"UnsignedIntRaw10EXT"}; return true; + case 20: v = UnownedStringSlice{"UnsignedIntRaw12EXT"}; return true; + default: return false; + } + case 22: + switch(k2) + { + case 0: v = UnownedStringSlice{"RTE"}; return true; + case 1: v = UnownedStringSlice{"RTZ"}; return true; + case 2: v = UnownedStringSlice{"RTP"}; return true; + case 3: v = UnownedStringSlice{"RTN"}; return true; + default: return false; + } + case 23: + switch(k2) + { + case 0: v = UnownedStringSlice{"Preserve"}; return true; + case 1: v = UnownedStringSlice{"FlushToZero"}; return true; + default: return false; + } + case 24: + switch(k2) + { + case 0: v = UnownedStringSlice{"TRN"}; return true; + case 1: v = UnownedStringSlice{"TRN_ZERO"}; return true; + case 2: v = UnownedStringSlice{"RND"}; return true; + case 3: v = UnownedStringSlice{"RND_ZERO"}; return true; + case 4: v = UnownedStringSlice{"RND_INF"}; return true; + case 5: v = UnownedStringSlice{"RND_MIN_INF"}; return true; + case 6: v = UnownedStringSlice{"RND_CONV"}; return true; + case 7: v = UnownedStringSlice{"RND_CONV_ODD"}; return true; + default: return false; + } + case 25: + switch(k2) + { + case 0: v = UnownedStringSlice{"IEEE"}; return true; + case 1: v = UnownedStringSlice{"ALT"}; return true; + default: return false; + } + case 26: + switch(k2) + { + case 0: v = UnownedStringSlice{"WRAP"}; return true; + case 1: v = UnownedStringSlice{"SAT"}; return true; + case 2: v = UnownedStringSlice{"SAT_ZERO"}; return true; + case 3: v = UnownedStringSlice{"SAT_SYM"}; return true; + default: return false; + } + case 27: + switch(k2) + { + case 0: v = UnownedStringSlice{"Export"}; return true; + case 1: v = UnownedStringSlice{"Import"}; return true; + case 2: v = UnownedStringSlice{"LinkOnceODR"}; return true; + default: return false; + } + case 28: + switch(k2) + { + case 0: v = UnownedStringSlice{"ReadOnly"}; return true; + case 1: v = UnownedStringSlice{"WriteOnly"}; return true; + case 2: v = UnownedStringSlice{"ReadWrite"}; return true; + default: return false; + } + case 29: + switch(k2) + { + case 0: v = UnownedStringSlice{"Zext"}; return true; + case 1: v = UnownedStringSlice{"Sext"}; return true; + case 2: v = UnownedStringSlice{"ByVal"}; return true; + case 3: v = UnownedStringSlice{"Sret"}; return true; + case 4: v = UnownedStringSlice{"NoAlias"}; return true; + case 5: v = UnownedStringSlice{"NoCapture"}; return true; + case 6: v = UnownedStringSlice{"NoWrite"}; return true; + case 7: v = UnownedStringSlice{"NoReadWrite"}; return true; + case 5940: v = UnownedStringSlice{"RuntimeAlignedINTEL"}; return true; + default: return false; + } + case 30: + switch(k2) + { + case 0: v = UnownedStringSlice{"RelaxedPrecision"}; return true; + case 1: v = UnownedStringSlice{"SpecId"}; return true; + case 2: v = UnownedStringSlice{"Block"}; return true; + case 3: v = UnownedStringSlice{"BufferBlock"}; return true; + case 4: v = UnownedStringSlice{"RowMajor"}; return true; + case 5: v = UnownedStringSlice{"ColMajor"}; return true; + case 6: v = UnownedStringSlice{"ArrayStride"}; return true; + case 7: v = UnownedStringSlice{"MatrixStride"}; return true; + case 8: v = UnownedStringSlice{"GLSLShared"}; return true; + case 9: v = UnownedStringSlice{"GLSLPacked"}; return true; + case 10: v = UnownedStringSlice{"CPacked"}; return true; + case 11: v = UnownedStringSlice{"BuiltIn"}; return true; + case 13: v = UnownedStringSlice{"NoPerspective"}; return true; + case 14: v = UnownedStringSlice{"Flat"}; return true; + case 15: v = UnownedStringSlice{"Patch"}; return true; + case 16: v = UnownedStringSlice{"Centroid"}; return true; + case 17: v = UnownedStringSlice{"Sample"}; return true; + case 18: v = UnownedStringSlice{"Invariant"}; return true; + case 19: v = UnownedStringSlice{"Restrict"}; return true; + case 20: v = UnownedStringSlice{"Aliased"}; return true; + case 21: v = UnownedStringSlice{"Volatile"}; return true; + case 22: v = UnownedStringSlice{"Constant"}; return true; + case 23: v = UnownedStringSlice{"Coherent"}; return true; + case 24: v = UnownedStringSlice{"NonWritable"}; return true; + case 25: v = UnownedStringSlice{"NonReadable"}; return true; + case 26: v = UnownedStringSlice{"Uniform"}; return true; + case 27: v = UnownedStringSlice{"UniformId"}; return true; + case 28: v = UnownedStringSlice{"SaturatedConversion"}; return true; + case 29: v = UnownedStringSlice{"Stream"}; return true; + case 30: v = UnownedStringSlice{"Location"}; return true; + case 31: v = UnownedStringSlice{"Component"}; return true; + case 32: v = UnownedStringSlice{"Index"}; return true; + case 33: v = UnownedStringSlice{"Binding"}; return true; + case 34: v = UnownedStringSlice{"DescriptorSet"}; return true; + case 35: v = UnownedStringSlice{"Offset"}; return true; + case 36: v = UnownedStringSlice{"XfbBuffer"}; return true; + case 37: v = UnownedStringSlice{"XfbStride"}; return true; + case 38: v = UnownedStringSlice{"FuncParamAttr"}; return true; + case 39: v = UnownedStringSlice{"FPRoundingMode"}; return true; + case 40: v = UnownedStringSlice{"FPFastMathMode"}; return true; + case 41: v = UnownedStringSlice{"LinkageAttributes"}; return true; + case 42: v = UnownedStringSlice{"NoContraction"}; return true; + case 43: v = UnownedStringSlice{"InputAttachmentIndex"}; return true; + case 44: v = UnownedStringSlice{"Alignment"}; return true; + case 45: v = UnownedStringSlice{"MaxByteOffset"}; return true; + case 46: v = UnownedStringSlice{"AlignmentId"}; return true; + case 47: v = UnownedStringSlice{"MaxByteOffsetId"}; return true; + case 4469: v = UnownedStringSlice{"NoSignedWrap"}; return true; + case 4470: v = UnownedStringSlice{"NoUnsignedWrap"}; return true; + case 4487: v = UnownedStringSlice{"WeightTextureQCOM"}; return true; + case 4488: v = UnownedStringSlice{"BlockMatchTextureQCOM"}; return true; + case 4999: v = UnownedStringSlice{"ExplicitInterpAMD"}; return true; + case 5248: v = UnownedStringSlice{"OverrideCoverageNV"}; return true; + case 5250: v = UnownedStringSlice{"PassthroughNV"}; return true; + case 5252: v = UnownedStringSlice{"ViewportRelativeNV"}; return true; + case 5256: v = UnownedStringSlice{"SecondaryViewportRelativeNV"}; return true; + case 5271: v = UnownedStringSlice{"PerPrimitiveNV"}; return true; + case 5272: v = UnownedStringSlice{"PerViewNV"}; return true; + case 5273: v = UnownedStringSlice{"PerTaskNV"}; return true; + case 5285: v = UnownedStringSlice{"PerVertexKHR"}; return true; + case 5300: v = UnownedStringSlice{"NonUniform"}; return true; + case 5355: v = UnownedStringSlice{"RestrictPointer"}; return true; + case 5356: v = UnownedStringSlice{"AliasedPointer"}; return true; + case 5386: v = UnownedStringSlice{"HitObjectShaderRecordBufferNV"}; return true; + case 5398: v = UnownedStringSlice{"BindlessSamplerNV"}; return true; + case 5399: v = UnownedStringSlice{"BindlessImageNV"}; return true; + case 5400: v = UnownedStringSlice{"BoundSamplerNV"}; return true; + case 5401: v = UnownedStringSlice{"BoundImageNV"}; return true; + case 5599: v = UnownedStringSlice{"SIMTCallINTEL"}; return true; + case 5602: v = UnownedStringSlice{"ReferencedIndirectlyINTEL"}; return true; + case 5607: v = UnownedStringSlice{"ClobberINTEL"}; return true; + case 5608: v = UnownedStringSlice{"SideEffectsINTEL"}; return true; + case 5624: v = UnownedStringSlice{"VectorComputeVariableINTEL"}; return true; + case 5625: v = UnownedStringSlice{"FuncParamIOKindINTEL"}; return true; + case 5626: v = UnownedStringSlice{"VectorComputeFunctionINTEL"}; return true; + case 5627: v = UnownedStringSlice{"StackCallINTEL"}; return true; + case 5628: v = UnownedStringSlice{"GlobalVariableOffsetINTEL"}; return true; + case 5634: v = UnownedStringSlice{"CounterBuffer"}; return true; + case 5635: v = UnownedStringSlice{"UserSemantic"}; return true; + case 5636: v = UnownedStringSlice{"UserTypeGOOGLE"}; return true; + case 5822: v = UnownedStringSlice{"FunctionRoundingModeINTEL"}; return true; + case 5823: v = UnownedStringSlice{"FunctionDenormModeINTEL"}; return true; + case 5825: v = UnownedStringSlice{"RegisterINTEL"}; return true; + case 5826: v = UnownedStringSlice{"MemoryINTEL"}; return true; + case 5827: v = UnownedStringSlice{"NumbanksINTEL"}; return true; + case 5828: v = UnownedStringSlice{"BankwidthINTEL"}; return true; + case 5829: v = UnownedStringSlice{"MaxPrivateCopiesINTEL"}; return true; + case 5830: v = UnownedStringSlice{"SinglepumpINTEL"}; return true; + case 5831: v = UnownedStringSlice{"DoublepumpINTEL"}; return true; + case 5832: v = UnownedStringSlice{"MaxReplicatesINTEL"}; return true; + case 5833: v = UnownedStringSlice{"SimpleDualPortINTEL"}; return true; + case 5834: v = UnownedStringSlice{"MergeINTEL"}; return true; + case 5835: v = UnownedStringSlice{"BankBitsINTEL"}; return true; + case 5836: v = UnownedStringSlice{"ForcePow2DepthINTEL"}; return true; + case 5899: v = UnownedStringSlice{"BurstCoalesceINTEL"}; return true; + case 5900: v = UnownedStringSlice{"CacheSizeINTEL"}; return true; + case 5901: v = UnownedStringSlice{"DontStaticallyCoalesceINTEL"}; return true; + case 5902: v = UnownedStringSlice{"PrefetchINTEL"}; return true; + case 5905: v = UnownedStringSlice{"StallEnableINTEL"}; return true; + case 5907: v = UnownedStringSlice{"FuseLoopsInFunctionINTEL"}; return true; + case 5909: v = UnownedStringSlice{"MathOpDSPModeINTEL"}; return true; + case 5914: v = UnownedStringSlice{"AliasScopeINTEL"}; return true; + case 5915: v = UnownedStringSlice{"NoAliasINTEL"}; return true; + case 5917: v = UnownedStringSlice{"InitiationIntervalINTEL"}; return true; + case 5918: v = UnownedStringSlice{"MaxConcurrencyINTEL"}; return true; + case 5919: v = UnownedStringSlice{"PipelineEnableINTEL"}; return true; + case 5921: v = UnownedStringSlice{"BufferLocationINTEL"}; return true; + case 5944: v = UnownedStringSlice{"IOPipeStorageINTEL"}; return true; + case 6080: v = UnownedStringSlice{"FunctionFloatingPointModeINTEL"}; return true; + case 6085: v = UnownedStringSlice{"SingleElementVectorINTEL"}; return true; + case 6087: v = UnownedStringSlice{"VectorComputeCallableFunctionINTEL"}; return true; + case 6140: v = UnownedStringSlice{"MediaBlockIOINTEL"}; return true; + case 6170: v = UnownedStringSlice{"FPMaxErrorDecorationINTEL"}; return true; + case 6172: v = UnownedStringSlice{"LatencyControlLabelINTEL"}; return true; + case 6173: v = UnownedStringSlice{"LatencyControlConstraintINTEL"}; return true; + case 6175: v = UnownedStringSlice{"ConduitKernelArgumentINTEL"}; return true; + case 6176: v = UnownedStringSlice{"RegisterMapKernelArgumentINTEL"}; return true; + case 6177: v = UnownedStringSlice{"MMHostInterfaceAddressWidthINTEL"}; return true; + case 6178: v = UnownedStringSlice{"MMHostInterfaceDataWidthINTEL"}; return true; + case 6179: v = UnownedStringSlice{"MMHostInterfaceLatencyINTEL"}; return true; + case 6180: v = UnownedStringSlice{"MMHostInterfaceReadWriteModeINTEL"}; return true; + case 6181: v = UnownedStringSlice{"MMHostInterfaceMaxBurstINTEL"}; return true; + case 6182: v = UnownedStringSlice{"MMHostInterfaceWaitRequestINTEL"}; return true; + case 6183: v = UnownedStringSlice{"StableKernelArgumentINTEL"}; return true; + default: return false; + } + case 31: + switch(k2) + { + case 0: v = UnownedStringSlice{"Position"}; return true; + case 1: v = UnownedStringSlice{"PointSize"}; return true; + case 3: v = UnownedStringSlice{"ClipDistance"}; return true; + case 4: v = UnownedStringSlice{"CullDistance"}; return true; + case 5: v = UnownedStringSlice{"VertexId"}; return true; + case 6: v = UnownedStringSlice{"InstanceId"}; return true; + case 7: v = UnownedStringSlice{"PrimitiveId"}; return true; + case 8: v = UnownedStringSlice{"InvocationId"}; return true; + case 9: v = UnownedStringSlice{"Layer"}; return true; + case 10: v = UnownedStringSlice{"ViewportIndex"}; return true; + case 11: v = UnownedStringSlice{"TessLevelOuter"}; return true; + case 12: v = UnownedStringSlice{"TessLevelInner"}; return true; + case 13: v = UnownedStringSlice{"TessCoord"}; return true; + case 14: v = UnownedStringSlice{"PatchVertices"}; return true; + case 15: v = UnownedStringSlice{"FragCoord"}; return true; + case 16: v = UnownedStringSlice{"PointCoord"}; return true; + case 17: v = UnownedStringSlice{"FrontFacing"}; return true; + case 18: v = UnownedStringSlice{"SampleId"}; return true; + case 19: v = UnownedStringSlice{"SamplePosition"}; return true; + case 20: v = UnownedStringSlice{"SampleMask"}; return true; + case 22: v = UnownedStringSlice{"FragDepth"}; return true; + case 23: v = UnownedStringSlice{"HelperInvocation"}; return true; + case 24: v = UnownedStringSlice{"NumWorkgroups"}; return true; + case 25: v = UnownedStringSlice{"WorkgroupSize"}; return true; + case 26: v = UnownedStringSlice{"WorkgroupId"}; return true; + case 27: v = UnownedStringSlice{"LocalInvocationId"}; return true; + case 28: v = UnownedStringSlice{"GlobalInvocationId"}; return true; + case 29: v = UnownedStringSlice{"LocalInvocationIndex"}; return true; + case 30: v = UnownedStringSlice{"WorkDim"}; return true; + case 31: v = UnownedStringSlice{"GlobalSize"}; return true; + case 32: v = UnownedStringSlice{"EnqueuedWorkgroupSize"}; return true; + case 33: v = UnownedStringSlice{"GlobalOffset"}; return true; + case 34: v = UnownedStringSlice{"GlobalLinearId"}; return true; + case 36: v = UnownedStringSlice{"SubgroupSize"}; return true; + case 37: v = UnownedStringSlice{"SubgroupMaxSize"}; return true; + case 38: v = UnownedStringSlice{"NumSubgroups"}; return true; + case 39: v = UnownedStringSlice{"NumEnqueuedSubgroups"}; return true; + case 40: v = UnownedStringSlice{"SubgroupId"}; return true; + case 41: v = UnownedStringSlice{"SubgroupLocalInvocationId"}; return true; + case 42: v = UnownedStringSlice{"VertexIndex"}; return true; + case 43: v = UnownedStringSlice{"InstanceIndex"}; return true; + case 4160: v = UnownedStringSlice{"CoreIDARM"}; return true; + case 4161: v = UnownedStringSlice{"CoreCountARM"}; return true; + case 4162: v = UnownedStringSlice{"CoreMaxIDARM"}; return true; + case 4163: v = UnownedStringSlice{"WarpIDARM"}; return true; + case 4164: v = UnownedStringSlice{"WarpMaxIDARM"}; return true; + case 4416: v = UnownedStringSlice{"SubgroupEqMask"}; return true; + case 4417: v = UnownedStringSlice{"SubgroupGeMask"}; return true; + case 4418: v = UnownedStringSlice{"SubgroupGtMask"}; return true; + case 4419: v = UnownedStringSlice{"SubgroupLeMask"}; return true; + case 4420: v = UnownedStringSlice{"SubgroupLtMask"}; return true; + case 4424: v = UnownedStringSlice{"BaseVertex"}; return true; + case 4425: v = UnownedStringSlice{"BaseInstance"}; return true; + case 4426: v = UnownedStringSlice{"DrawIndex"}; return true; + case 4432: v = UnownedStringSlice{"PrimitiveShadingRateKHR"}; return true; + case 4438: v = UnownedStringSlice{"DeviceIndex"}; return true; + case 4440: v = UnownedStringSlice{"ViewIndex"}; return true; + case 4444: v = UnownedStringSlice{"ShadingRateKHR"}; return true; + case 4992: v = UnownedStringSlice{"BaryCoordNoPerspAMD"}; return true; + case 4993: v = UnownedStringSlice{"BaryCoordNoPerspCentroidAMD"}; return true; + case 4994: v = UnownedStringSlice{"BaryCoordNoPerspSampleAMD"}; return true; + case 4995: v = UnownedStringSlice{"BaryCoordSmoothAMD"}; return true; + case 4996: v = UnownedStringSlice{"BaryCoordSmoothCentroidAMD"}; return true; + case 4997: v = UnownedStringSlice{"BaryCoordSmoothSampleAMD"}; return true; + case 4998: v = UnownedStringSlice{"BaryCoordPullModelAMD"}; return true; + case 5014: v = UnownedStringSlice{"FragStencilRefEXT"}; return true; + case 5253: v = UnownedStringSlice{"ViewportMaskNV"}; return true; + case 5257: v = UnownedStringSlice{"SecondaryPositionNV"}; return true; + case 5258: v = UnownedStringSlice{"SecondaryViewportMaskNV"}; return true; + case 5261: v = UnownedStringSlice{"PositionPerViewNV"}; return true; + case 5262: v = UnownedStringSlice{"ViewportMaskPerViewNV"}; return true; + case 5264: v = UnownedStringSlice{"FullyCoveredEXT"}; return true; + case 5274: v = UnownedStringSlice{"TaskCountNV"}; return true; + case 5275: v = UnownedStringSlice{"PrimitiveCountNV"}; return true; + case 5276: v = UnownedStringSlice{"PrimitiveIndicesNV"}; return true; + case 5277: v = UnownedStringSlice{"ClipDistancePerViewNV"}; return true; + case 5278: v = UnownedStringSlice{"CullDistancePerViewNV"}; return true; + case 5279: v = UnownedStringSlice{"LayerPerViewNV"}; return true; + case 5280: v = UnownedStringSlice{"MeshViewCountNV"}; return true; + case 5281: v = UnownedStringSlice{"MeshViewIndicesNV"}; return true; + case 5286: v = UnownedStringSlice{"BaryCoordKHR"}; return true; + case 5287: v = UnownedStringSlice{"BaryCoordNoPerspKHR"}; return true; + case 5292: v = UnownedStringSlice{"FragSizeEXT"}; return true; + case 5293: v = UnownedStringSlice{"FragInvocationCountEXT"}; return true; + case 5294: v = UnownedStringSlice{"PrimitivePointIndicesEXT"}; return true; + case 5295: v = UnownedStringSlice{"PrimitiveLineIndicesEXT"}; return true; + case 5296: v = UnownedStringSlice{"PrimitiveTriangleIndicesEXT"}; return true; + case 5299: v = UnownedStringSlice{"CullPrimitiveEXT"}; return true; + case 5319: v = UnownedStringSlice{"LaunchIdNV"}; return true; + case 5320: v = UnownedStringSlice{"LaunchSizeNV"}; return true; + case 5321: v = UnownedStringSlice{"WorldRayOriginNV"}; return true; + case 5322: v = UnownedStringSlice{"WorldRayDirectionNV"}; return true; + case 5323: v = UnownedStringSlice{"ObjectRayOriginNV"}; return true; + case 5324: v = UnownedStringSlice{"ObjectRayDirectionNV"}; return true; + case 5325: v = UnownedStringSlice{"RayTminNV"}; return true; + case 5326: v = UnownedStringSlice{"RayTmaxNV"}; return true; + case 5327: v = UnownedStringSlice{"InstanceCustomIndexNV"}; return true; + case 5330: v = UnownedStringSlice{"ObjectToWorldNV"}; return true; + case 5331: v = UnownedStringSlice{"WorldToObjectNV"}; return true; + case 5332: v = UnownedStringSlice{"HitTNV"}; return true; + case 5333: v = UnownedStringSlice{"HitKindNV"}; return true; + case 5334: v = UnownedStringSlice{"CurrentRayTimeNV"}; return true; + case 5335: v = UnownedStringSlice{"HitTriangleVertexPositionsKHR"}; return true; + case 5351: v = UnownedStringSlice{"IncomingRayFlagsNV"}; return true; + case 5352: v = UnownedStringSlice{"RayGeometryIndexKHR"}; return true; + case 5374: v = UnownedStringSlice{"WarpsPerSMNV"}; return true; + case 5375: v = UnownedStringSlice{"SMCountNV"}; return true; + case 5376: v = UnownedStringSlice{"WarpIDNV"}; return true; + case 5377: v = UnownedStringSlice{"SMIDNV"}; return true; + case 6021: v = UnownedStringSlice{"CullMaskKHR"}; return true; + default: return false; + } + case 32: + switch(k2) + { + case 0: v = UnownedStringSlice{"CrossDevice"}; return true; + case 1: v = UnownedStringSlice{"Device"}; return true; + case 2: v = UnownedStringSlice{"Workgroup"}; return true; + case 3: v = UnownedStringSlice{"Subgroup"}; return true; + case 4: v = UnownedStringSlice{"Invocation"}; return true; + case 5: v = UnownedStringSlice{"QueueFamily"}; return true; + case 6: v = UnownedStringSlice{"ShaderCallKHR"}; return true; + default: return false; + } + case 33: + switch(k2) + { + case 0: v = UnownedStringSlice{"Reduce"}; return true; + case 1: v = UnownedStringSlice{"InclusiveScan"}; return true; + case 2: v = UnownedStringSlice{"ExclusiveScan"}; return true; + case 3: v = UnownedStringSlice{"ClusteredReduce"}; return true; + case 6: v = UnownedStringSlice{"PartitionedReduceNV"}; return true; + case 7: v = UnownedStringSlice{"PartitionedInclusiveScanNV"}; return true; + case 8: v = UnownedStringSlice{"PartitionedExclusiveScanNV"}; return true; + default: return false; + } + case 34: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoWait"}; return true; + case 1: v = UnownedStringSlice{"WaitKernel"}; return true; + case 2: v = UnownedStringSlice{"WaitWorkGroup"}; return true; + default: return false; + } + case 35: + switch(k2) + { + case 0: v = UnownedStringSlice{"Matrix"}; return true; + case 1: v = UnownedStringSlice{"Shader"}; return true; + case 2: v = UnownedStringSlice{"Geometry"}; return true; + case 3: v = UnownedStringSlice{"Tessellation"}; return true; + case 4: v = UnownedStringSlice{"Addresses"}; return true; + case 5: v = UnownedStringSlice{"Linkage"}; return true; + case 6: v = UnownedStringSlice{"Kernel"}; return true; + case 7: v = UnownedStringSlice{"Vector16"}; return true; + case 8: v = UnownedStringSlice{"Float16Buffer"}; return true; + case 9: v = UnownedStringSlice{"Float16"}; return true; + case 10: v = UnownedStringSlice{"Float64"}; return true; + case 11: v = UnownedStringSlice{"Int64"}; return true; + case 12: v = UnownedStringSlice{"Int64Atomics"}; return true; + case 13: v = UnownedStringSlice{"ImageBasic"}; return true; + case 14: v = UnownedStringSlice{"ImageReadWrite"}; return true; + case 15: v = UnownedStringSlice{"ImageMipmap"}; return true; + case 17: v = UnownedStringSlice{"Pipes"}; return true; + case 18: v = UnownedStringSlice{"Groups"}; return true; + case 19: v = UnownedStringSlice{"DeviceEnqueue"}; return true; + case 20: v = UnownedStringSlice{"LiteralSampler"}; return true; + case 21: v = UnownedStringSlice{"AtomicStorage"}; return true; + case 22: v = UnownedStringSlice{"Int16"}; return true; + case 23: v = UnownedStringSlice{"TessellationPointSize"}; return true; + case 24: v = UnownedStringSlice{"GeometryPointSize"}; return true; + case 25: v = UnownedStringSlice{"ImageGatherExtended"}; return true; + case 27: v = UnownedStringSlice{"StorageImageMultisample"}; return true; + case 28: v = UnownedStringSlice{"UniformBufferArrayDynamicIndexing"}; return true; + case 29: v = UnownedStringSlice{"SampledImageArrayDynamicIndexing"}; return true; + case 30: v = UnownedStringSlice{"StorageBufferArrayDynamicIndexing"}; return true; + case 31: v = UnownedStringSlice{"StorageImageArrayDynamicIndexing"}; return true; + case 32: v = UnownedStringSlice{"ClipDistance"}; return true; + case 33: v = UnownedStringSlice{"CullDistance"}; return true; + case 34: v = UnownedStringSlice{"ImageCubeArray"}; return true; + case 35: v = UnownedStringSlice{"SampleRateShading"}; return true; + case 36: v = UnownedStringSlice{"ImageRect"}; return true; + case 37: v = UnownedStringSlice{"SampledRect"}; return true; + case 38: v = UnownedStringSlice{"GenericPointer"}; return true; + case 39: v = UnownedStringSlice{"Int8"}; return true; + case 40: v = UnownedStringSlice{"InputAttachment"}; return true; + case 41: v = UnownedStringSlice{"SparseResidency"}; return true; + case 42: v = UnownedStringSlice{"MinLod"}; return true; + case 43: v = UnownedStringSlice{"Sampled1D"}; return true; + case 44: v = UnownedStringSlice{"Image1D"}; return true; + case 45: v = UnownedStringSlice{"SampledCubeArray"}; return true; + case 46: v = UnownedStringSlice{"SampledBuffer"}; return true; + case 47: v = UnownedStringSlice{"ImageBuffer"}; return true; + case 48: v = UnownedStringSlice{"ImageMSArray"}; return true; + case 49: v = UnownedStringSlice{"StorageImageExtendedFormats"}; return true; + case 50: v = UnownedStringSlice{"ImageQuery"}; return true; + case 51: v = UnownedStringSlice{"DerivativeControl"}; return true; + case 52: v = UnownedStringSlice{"InterpolationFunction"}; return true; + case 53: v = UnownedStringSlice{"TransformFeedback"}; return true; + case 54: v = UnownedStringSlice{"GeometryStreams"}; return true; + case 55: v = UnownedStringSlice{"StorageImageReadWithoutFormat"}; return true; + case 56: v = UnownedStringSlice{"StorageImageWriteWithoutFormat"}; return true; + case 57: v = UnownedStringSlice{"MultiViewport"}; return true; + case 58: v = UnownedStringSlice{"SubgroupDispatch"}; return true; + case 59: v = UnownedStringSlice{"NamedBarrier"}; return true; + case 60: v = UnownedStringSlice{"PipeStorage"}; return true; + case 61: v = UnownedStringSlice{"GroupNonUniform"}; return true; + case 62: v = UnownedStringSlice{"GroupNonUniformVote"}; return true; + case 63: v = UnownedStringSlice{"GroupNonUniformArithmetic"}; return true; + case 64: v = UnownedStringSlice{"GroupNonUniformBallot"}; return true; + case 65: v = UnownedStringSlice{"GroupNonUniformShuffle"}; return true; + case 66: v = UnownedStringSlice{"GroupNonUniformShuffleRelative"}; return true; + case 67: v = UnownedStringSlice{"GroupNonUniformClustered"}; return true; + case 68: v = UnownedStringSlice{"GroupNonUniformQuad"}; return true; + case 69: v = UnownedStringSlice{"ShaderLayer"}; return true; + case 70: v = UnownedStringSlice{"ShaderViewportIndex"}; return true; + case 71: v = UnownedStringSlice{"UniformDecoration"}; return true; + case 4165: v = UnownedStringSlice{"CoreBuiltinsARM"}; return true; + case 4166: v = UnownedStringSlice{"TileImageColorReadAccessEXT"}; return true; + case 4167: v = UnownedStringSlice{"TileImageDepthReadAccessEXT"}; return true; + case 4168: v = UnownedStringSlice{"TileImageStencilReadAccessEXT"}; return true; + case 4422: v = UnownedStringSlice{"FragmentShadingRateKHR"}; return true; + case 4423: v = UnownedStringSlice{"SubgroupBallotKHR"}; return true; + case 4427: v = UnownedStringSlice{"DrawParameters"}; return true; + case 4428: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayoutKHR"}; return true; + case 4429: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayout8BitAccessKHR"}; return true; + case 4430: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayout16BitAccessKHR"}; return true; + case 4431: v = UnownedStringSlice{"SubgroupVoteKHR"}; return true; + case 4433: v = UnownedStringSlice{"StorageBuffer16BitAccess"}; return true; + case 4434: v = UnownedStringSlice{"UniformAndStorageBuffer16BitAccess"}; return true; + case 4435: v = UnownedStringSlice{"StoragePushConstant16"}; return true; + case 4436: v = UnownedStringSlice{"StorageInputOutput16"}; return true; + case 4437: v = UnownedStringSlice{"DeviceGroup"}; return true; + case 4439: v = UnownedStringSlice{"MultiView"}; return true; + case 4441: v = UnownedStringSlice{"VariablePointersStorageBuffer"}; return true; + case 4442: v = UnownedStringSlice{"VariablePointers"}; return true; + case 4445: v = UnownedStringSlice{"AtomicStorageOps"}; return true; + case 4447: v = UnownedStringSlice{"SampleMaskPostDepthCoverage"}; return true; + case 4448: v = UnownedStringSlice{"StorageBuffer8BitAccess"}; return true; + case 4449: v = UnownedStringSlice{"UniformAndStorageBuffer8BitAccess"}; return true; + case 4450: v = UnownedStringSlice{"StoragePushConstant8"}; return true; + case 4464: v = UnownedStringSlice{"DenormPreserve"}; return true; + case 4465: v = UnownedStringSlice{"DenormFlushToZero"}; return true; + case 4466: v = UnownedStringSlice{"SignedZeroInfNanPreserve"}; return true; + case 4467: v = UnownedStringSlice{"RoundingModeRTE"}; return true; + case 4468: v = UnownedStringSlice{"RoundingModeRTZ"}; return true; + case 4471: v = UnownedStringSlice{"RayQueryProvisionalKHR"}; return true; + case 4472: v = UnownedStringSlice{"RayQueryKHR"}; return true; + case 4478: v = UnownedStringSlice{"RayTraversalPrimitiveCullingKHR"}; return true; + case 4479: v = UnownedStringSlice{"RayTracingKHR"}; return true; + case 4484: v = UnownedStringSlice{"TextureSampleWeightedQCOM"}; return true; + case 4485: v = UnownedStringSlice{"TextureBoxFilterQCOM"}; return true; + case 4486: v = UnownedStringSlice{"TextureBlockMatchQCOM"}; return true; + case 5008: v = UnownedStringSlice{"Float16ImageAMD"}; return true; + case 5009: v = UnownedStringSlice{"ImageGatherBiasLodAMD"}; return true; + case 5010: v = UnownedStringSlice{"FragmentMaskAMD"}; return true; + case 5013: v = UnownedStringSlice{"StencilExportEXT"}; return true; + case 5015: v = UnownedStringSlice{"ImageReadWriteLodAMD"}; return true; + case 5016: v = UnownedStringSlice{"Int64ImageEXT"}; return true; + case 5055: v = UnownedStringSlice{"ShaderClockKHR"}; return true; + case 5249: v = UnownedStringSlice{"SampleMaskOverrideCoverageNV"}; return true; + case 5251: v = UnownedStringSlice{"GeometryShaderPassthroughNV"}; return true; + case 5254: v = UnownedStringSlice{"ShaderViewportIndexLayerEXT"}; return true; + case 5255: v = UnownedStringSlice{"ShaderViewportMaskNV"}; return true; + case 5259: v = UnownedStringSlice{"ShaderStereoViewNV"}; return true; + case 5260: v = UnownedStringSlice{"PerViewAttributesNV"}; return true; + case 5265: v = UnownedStringSlice{"FragmentFullyCoveredEXT"}; return true; + case 5266: v = UnownedStringSlice{"MeshShadingNV"}; return true; + case 5282: v = UnownedStringSlice{"ImageFootprintNV"}; return true; + case 5283: v = UnownedStringSlice{"MeshShadingEXT"}; return true; + case 5284: v = UnownedStringSlice{"FragmentBarycentricKHR"}; return true; + case 5288: v = UnownedStringSlice{"ComputeDerivativeGroupQuadsNV"}; return true; + case 5291: v = UnownedStringSlice{"FragmentDensityEXT"}; return true; + case 5297: v = UnownedStringSlice{"GroupNonUniformPartitionedNV"}; return true; + case 5301: v = UnownedStringSlice{"ShaderNonUniform"}; return true; + case 5302: v = UnownedStringSlice{"RuntimeDescriptorArray"}; return true; + case 5303: v = UnownedStringSlice{"InputAttachmentArrayDynamicIndexing"}; return true; + case 5304: v = UnownedStringSlice{"UniformTexelBufferArrayDynamicIndexing"}; return true; + case 5305: v = UnownedStringSlice{"StorageTexelBufferArrayDynamicIndexing"}; return true; + case 5306: v = UnownedStringSlice{"UniformBufferArrayNonUniformIndexing"}; return true; + case 5307: v = UnownedStringSlice{"SampledImageArrayNonUniformIndexing"}; return true; + case 5308: v = UnownedStringSlice{"StorageBufferArrayNonUniformIndexing"}; return true; + case 5309: v = UnownedStringSlice{"StorageImageArrayNonUniformIndexing"}; return true; + case 5310: v = UnownedStringSlice{"InputAttachmentArrayNonUniformIndexing"}; return true; + case 5311: v = UnownedStringSlice{"UniformTexelBufferArrayNonUniformIndexing"}; return true; + case 5312: v = UnownedStringSlice{"StorageTexelBufferArrayNonUniformIndexing"}; return true; + case 5336: v = UnownedStringSlice{"RayTracingPositionFetchKHR"}; return true; + case 5340: v = UnownedStringSlice{"RayTracingNV"}; return true; + case 5341: v = UnownedStringSlice{"RayTracingMotionBlurNV"}; return true; + case 5345: v = UnownedStringSlice{"VulkanMemoryModel"}; return true; + case 5346: v = UnownedStringSlice{"VulkanMemoryModelDeviceScope"}; return true; + case 5347: v = UnownedStringSlice{"PhysicalStorageBufferAddresses"}; return true; + case 5350: v = UnownedStringSlice{"ComputeDerivativeGroupLinearNV"}; return true; + case 5353: v = UnownedStringSlice{"RayTracingProvisionalKHR"}; return true; + case 5357: v = UnownedStringSlice{"CooperativeMatrixNV"}; return true; + case 5363: v = UnownedStringSlice{"FragmentShaderSampleInterlockEXT"}; return true; + case 5372: v = UnownedStringSlice{"FragmentShaderShadingRateInterlockEXT"}; return true; + case 5373: v = UnownedStringSlice{"ShaderSMBuiltinsNV"}; return true; + case 5378: v = UnownedStringSlice{"FragmentShaderPixelInterlockEXT"}; return true; + case 5379: v = UnownedStringSlice{"DemoteToHelperInvocation"}; return true; + case 5381: v = UnownedStringSlice{"RayTracingOpacityMicromapEXT"}; return true; + case 5383: v = UnownedStringSlice{"ShaderInvocationReorderNV"}; return true; + case 5390: v = UnownedStringSlice{"BindlessTextureNV"}; return true; + case 5391: v = UnownedStringSlice{"RayQueryPositionFetchKHR"}; return true; + case 5568: v = UnownedStringSlice{"SubgroupShuffleINTEL"}; return true; + case 5569: v = UnownedStringSlice{"SubgroupBufferBlockIOINTEL"}; return true; + case 5570: v = UnownedStringSlice{"SubgroupImageBlockIOINTEL"}; return true; + case 5579: v = UnownedStringSlice{"SubgroupImageMediaBlockIOINTEL"}; return true; + case 5582: v = UnownedStringSlice{"RoundToInfinityINTEL"}; return true; + case 5583: v = UnownedStringSlice{"FloatingPointModeINTEL"}; return true; + case 5584: v = UnownedStringSlice{"IntegerFunctions2INTEL"}; return true; + case 5603: v = UnownedStringSlice{"FunctionPointersINTEL"}; return true; + case 5604: v = UnownedStringSlice{"IndirectReferencesINTEL"}; return true; + case 5606: v = UnownedStringSlice{"AsmINTEL"}; return true; + case 5612: v = UnownedStringSlice{"AtomicFloat32MinMaxEXT"}; return true; + case 5613: v = UnownedStringSlice{"AtomicFloat64MinMaxEXT"}; return true; + case 5616: v = UnownedStringSlice{"AtomicFloat16MinMaxEXT"}; return true; + case 5617: v = UnownedStringSlice{"VectorComputeINTEL"}; return true; + case 5619: v = UnownedStringSlice{"VectorAnyINTEL"}; return true; + case 5629: v = UnownedStringSlice{"ExpectAssumeKHR"}; return true; + case 5696: v = UnownedStringSlice{"SubgroupAvcMotionEstimationINTEL"}; return true; + case 5697: v = UnownedStringSlice{"SubgroupAvcMotionEstimationIntraINTEL"}; return true; + case 5698: v = UnownedStringSlice{"SubgroupAvcMotionEstimationChromaINTEL"}; return true; + case 5817: v = UnownedStringSlice{"VariableLengthArrayINTEL"}; return true; + case 5821: v = UnownedStringSlice{"FunctionFloatControlINTEL"}; return true; + case 5824: v = UnownedStringSlice{"FPGAMemoryAttributesINTEL"}; return true; + case 5837: v = UnownedStringSlice{"FPFastMathModeINTEL"}; return true; + case 5844: v = UnownedStringSlice{"ArbitraryPrecisionIntegersINTEL"}; return true; + case 5845: v = UnownedStringSlice{"ArbitraryPrecisionFloatingPointINTEL"}; return true; + case 5886: v = UnownedStringSlice{"UnstructuredLoopControlsINTEL"}; return true; + case 5888: v = UnownedStringSlice{"FPGALoopControlsINTEL"}; return true; + case 5892: v = UnownedStringSlice{"KernelAttributesINTEL"}; return true; + case 5897: v = UnownedStringSlice{"FPGAKernelAttributesINTEL"}; return true; + case 5898: v = UnownedStringSlice{"FPGAMemoryAccessesINTEL"}; return true; + case 5904: v = UnownedStringSlice{"FPGAClusterAttributesINTEL"}; return true; + case 5906: v = UnownedStringSlice{"LoopFuseINTEL"}; return true; + case 5908: v = UnownedStringSlice{"FPGADSPControlINTEL"}; return true; + case 5910: v = UnownedStringSlice{"MemoryAccessAliasingINTEL"}; return true; + case 5916: v = UnownedStringSlice{"FPGAInvocationPipeliningAttributesINTEL"}; return true; + case 5920: v = UnownedStringSlice{"FPGABufferLocationINTEL"}; return true; + case 5922: v = UnownedStringSlice{"ArbitraryPrecisionFixedPointINTEL"}; return true; + case 5935: v = UnownedStringSlice{"USMStorageClassesINTEL"}; return true; + case 5939: v = UnownedStringSlice{"RuntimeAlignedAttributeINTEL"}; return true; + case 5943: v = UnownedStringSlice{"IOPipesINTEL"}; return true; + case 5945: v = UnownedStringSlice{"BlockingPipesINTEL"}; return true; + case 5948: v = UnownedStringSlice{"FPGARegINTEL"}; return true; + case 6016: v = UnownedStringSlice{"DotProductInputAll"}; return true; + case 6017: v = UnownedStringSlice{"DotProductInput4x8Bit"}; return true; + case 6018: v = UnownedStringSlice{"DotProductInput4x8BitPacked"}; return true; + case 6019: v = UnownedStringSlice{"DotProduct"}; return true; + case 6020: v = UnownedStringSlice{"RayCullMaskKHR"}; return true; + case 6022: v = UnownedStringSlice{"CooperativeMatrixKHR"}; return true; + case 6025: v = UnownedStringSlice{"BitInstructions"}; return true; + case 6026: v = UnownedStringSlice{"GroupNonUniformRotateKHR"}; return true; + case 6033: v = UnownedStringSlice{"AtomicFloat32AddEXT"}; return true; + case 6034: v = UnownedStringSlice{"AtomicFloat64AddEXT"}; return true; + case 6089: v = UnownedStringSlice{"LongConstantCompositeINTEL"}; return true; + case 6094: v = UnownedStringSlice{"OptNoneINTEL"}; return true; + case 6095: v = UnownedStringSlice{"AtomicFloat16AddEXT"}; return true; + case 6114: v = UnownedStringSlice{"DebugInfoModuleINTEL"}; return true; + case 6115: v = UnownedStringSlice{"BFloat16ConversionINTEL"}; return true; + case 6141: v = UnownedStringSlice{"SplitBarrierINTEL"}; return true; + case 6161: v = UnownedStringSlice{"FPGAKernelAttributesv2INTEL"}; return true; + case 6169: v = UnownedStringSlice{"FPMaxErrorINTEL"}; return true; + case 6171: v = UnownedStringSlice{"FPGALatencyControlINTEL"}; return true; + case 6174: v = UnownedStringSlice{"FPGAArgumentInterfacesINTEL"}; return true; + case 6400: v = UnownedStringSlice{"GroupUniformArithmeticKHR"}; return true; + default: return false; + } + case 36: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCandidateIntersectionKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCommittedIntersectionKHR"}; return true; + default: return false; + } + case 37: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCommittedIntersectionNoneKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCommittedIntersectionTriangleKHR"}; return true; + case 2: v = UnownedStringSlice{"RayQueryCommittedIntersectionGeneratedKHR"}; return true; + default: return false; + } + case 38: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCandidateIntersectionTriangleKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCandidateIntersectionAABBKHR"}; return true; + default: return false; + } + case 39: + switch(k2) + { + case 0: v = UnownedStringSlice{"PackedVectorFormat4x8Bit"}; return true; + default: return false; + } + case 40: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoneKHR"}; return true; + case 1: v = UnownedStringSlice{"MatrixASignedComponentsKHR"}; return true; + case 2: v = UnownedStringSlice{"MatrixBSignedComponentsKHR"}; return true; + case 4: v = UnownedStringSlice{"MatrixCSignedComponentsKHR"}; return true; + case 8: v = UnownedStringSlice{"MatrixResultSignedComponentsKHR"}; return true; + case 16: v = UnownedStringSlice{"SaturatingAccumulationKHR"}; return true; + default: return false; + } + case 41: + switch(k2) + { + case 0: v = UnownedStringSlice{"RowMajorKHR"}; return true; + case 1: v = UnownedStringSlice{"ColumnMajorKHR"}; return true; + default: return false; + } + case 42: + switch(k2) + { + case 0: v = UnownedStringSlice{"MatrixAKHR"}; return true; + case 1: v = UnownedStringSlice{"MatrixBKHR"}; return true; + case 2: v = UnownedStringSlice{"MatrixAccumulatorKHR"}; return true; + default: return false; + } + default: return false; + } +} + +static bool getOperandKindName(const OperandKind& k, UnownedStringSlice& v) +{ + switch(k.index) + { + case 0: + { + v = UnownedStringSlice{"ImageOperands"}; + return true; + } + case 1: + { + v = UnownedStringSlice{"FPFastMathMode"}; + return true; + } + case 2: + { + v = UnownedStringSlice{"SelectionControl"}; + return true; + } + case 3: + { + v = UnownedStringSlice{"LoopControl"}; + return true; + } + case 4: + { + v = UnownedStringSlice{"FunctionControl"}; + return true; + } + case 5: + { + v = UnownedStringSlice{"MemorySemantics"}; + return true; + } + case 6: + { + v = UnownedStringSlice{"MemoryAccess"}; + return true; + } + case 7: + { + v = UnownedStringSlice{"KernelProfilingInfo"}; + return true; + } + case 8: + { + v = UnownedStringSlice{"RayFlags"}; + return true; + } + case 9: + { + v = UnownedStringSlice{"FragmentShadingRate"}; + return true; + } + case 10: + { + v = UnownedStringSlice{"SourceLanguage"}; + return true; + } + case 11: + { + v = UnownedStringSlice{"ExecutionModel"}; + return true; + } + case 12: + { + v = UnownedStringSlice{"AddressingModel"}; + return true; + } + case 13: + { + v = UnownedStringSlice{"MemoryModel"}; + return true; + } + case 14: + { + v = UnownedStringSlice{"ExecutionMode"}; + return true; + } + case 15: + { + v = UnownedStringSlice{"StorageClass"}; + return true; + } + case 16: + { + v = UnownedStringSlice{"Dim"}; + return true; + } + case 17: + { + v = UnownedStringSlice{"SamplerAddressingMode"}; + return true; + } + case 18: + { + v = UnownedStringSlice{"SamplerFilterMode"}; + return true; + } + case 19: + { + v = UnownedStringSlice{"ImageFormat"}; + return true; + } + case 20: + { + v = UnownedStringSlice{"ImageChannelOrder"}; + return true; + } + case 21: + { + v = UnownedStringSlice{"ImageChannelDataType"}; + return true; + } + case 22: + { + v = UnownedStringSlice{"FPRoundingMode"}; + return true; + } + case 23: + { + v = UnownedStringSlice{"FPDenormMode"}; + return true; + } + case 24: + { + v = UnownedStringSlice{"QuantizationModes"}; + return true; + } + case 25: + { + v = UnownedStringSlice{"FPOperationMode"}; + return true; + } + case 26: + { + v = UnownedStringSlice{"OverflowModes"}; + return true; + } + case 27: + { + v = UnownedStringSlice{"LinkageType"}; + return true; + } + case 28: + { + v = UnownedStringSlice{"AccessQualifier"}; + return true; + } + case 29: + { + v = UnownedStringSlice{"FunctionParameterAttribute"}; + return true; + } + case 30: + { + v = UnownedStringSlice{"Decoration"}; + return true; + } + case 31: + { + v = UnownedStringSlice{"BuiltIn"}; + return true; + } + case 32: + { + v = UnownedStringSlice{"Scope"}; + return true; + } + case 33: + { + v = UnownedStringSlice{"GroupOperation"}; + return true; + } + case 34: + { + v = UnownedStringSlice{"KernelEnqueueFlags"}; + return true; + } + case 35: + { + v = UnownedStringSlice{"Capability"}; + return true; + } + case 36: + { + v = UnownedStringSlice{"RayQueryIntersection"}; + return true; + } + case 37: + { + v = UnownedStringSlice{"RayQueryCommittedIntersectionType"}; + return true; + } + case 38: + { + v = UnownedStringSlice{"RayQueryCandidateIntersectionType"}; + return true; + } + case 39: + { + v = UnownedStringSlice{"PackedVectorFormat"}; + return true; + } + case 40: + { + v = UnownedStringSlice{"CooperativeMatrixOperands"}; + return true; + } + case 41: + { + v = UnownedStringSlice{"CooperativeMatrixLayout"}; + return true; + } + case 42: + { + v = UnownedStringSlice{"CooperativeMatrixUse"}; + return true; + } + case 43: + { + v = UnownedStringSlice{"IdResultType"}; + return true; + } + case 44: + { + v = UnownedStringSlice{"IdResult"}; + return true; + } + case 45: + { + v = UnownedStringSlice{"IdMemorySemantics"}; + return true; + } + case 46: + { + v = UnownedStringSlice{"IdScope"}; + return true; + } + case 47: + { + v = UnownedStringSlice{"IdRef"}; + return true; + } + case 48: + { + v = UnownedStringSlice{"LiteralInteger"}; + return true; + } + case 49: + { + v = UnownedStringSlice{"LiteralString"}; + return true; + } + case 50: + { + v = UnownedStringSlice{"LiteralContextDependentNumber"}; + return true; + } + case 51: + { + v = UnownedStringSlice{"LiteralExtInstInteger"}; + return true; + } + case 52: + { + v = UnownedStringSlice{"LiteralSpecConstantOpInteger"}; + return true; + } + case 53: + { + v = UnownedStringSlice{"PairLiteralIntegerIdRef"}; + return true; + } + case 54: + { + v = UnownedStringSlice{"PairIdRefLiteralInteger"}; + return true; + } + case 55: + { + v = UnownedStringSlice{"PairIdRefIdRef"}; + return true; + } + default: return false; + } +} + +static bool getOperandKindUnderneathId(const OperandKind& k, OperandKind& v) +{ + switch(k.index) + { + case 45: + { + v = OperandKind{5}; + return true; + } + case 46: + { + v = OperandKind{32}; + return true; + } + default: return false; + } +} + +RefPtr SPIRVCoreGrammarInfo::getEmbeddedVersion() +{ + static SPIRVCoreGrammarInfo embedded = [](){ + SPIRVCoreGrammarInfo info; + info.opcodes.embedded = &lookupSpvOp; + info.capabilities.embedded = &lookupSpvCapability; + info.allEnumsWithTypePrefix.embedded = &lookupEnumWithTypePrefix; + info.opInfos.embedded = &getOpInfo; + info.opNames.embedded = &getOpName; + info.operandKinds.embedded = &lookupOperandKind; + info.allEnums.embedded = &lookupQualifiedEnum; + info.allEnumNames.embedded = &getQualifiedEnumName; + info.operandKindNames.embedded = &getOperandKindName; + info.operandKindUnderneathIds.embedded = &getOperandKindUnderneathId; + info.addReference(); + return info; + }(); + return &embedded; +} +} diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index da818984b..ae008cebb 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -220,6 +220,9 @@ void Session::init() m_languagePreludes[Index(SourceLanguage::CUDA)] = get_slang_cuda_prelude(); m_languagePreludes[Index(SourceLanguage::CPP)] = get_slang_cpp_prelude(); m_languagePreludes[Index(SourceLanguage::HLSL)] = get_slang_hlsl_prelude(); + + if(!spirvCoreGrammarInfo) + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::getEmbeddedVersion(); } void Session::_initCodeGenTransitionMap() @@ -805,6 +808,34 @@ IDownstreamCompiler* Session::getDownstreamCompiler(CodeGenTarget source, CodeGe return getOrLoadDownstreamCompiler(compilerType, nullptr); } +SLANG_NO_THROW SlangResult SLANG_MCALL Session::setSPIRVCoreGrammar(char const* jsonPath) +{ + if(!jsonPath) + { + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::getEmbeddedVersion(); + SLANG_ASSERT(spirvCoreGrammarInfo); + } + else + { + SourceManager* sourceManager = getBuiltinSourceManager(); + SLANG_ASSERT(sourceManager); + DiagnosticSink sink(sourceManager, Lexer::sourceLocationLexer); + + String contents; + const auto readRes = File::readAllText(jsonPath, contents); + if(SLANG_FAILED(readRes)) + { + sink.diagnose(SourceLoc{}, Diagnostics::unableToReadFile, jsonPath); + return readRes; + } + const auto pathInfo = PathInfo::makeFromString(jsonPath); + const auto sourceFile = sourceManager->createSourceFileWithString(pathInfo, contents); + const auto sourceView = sourceManager->createSourceView(sourceFile, nullptr, SourceLoc()); + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::loadFromJSON(*sourceView, sink); + } + return spirvCoreGrammarInfo ? SLANG_OK : SLANG_FAIL; +} + Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) { auto entryPointProfile = entryPoint->getProfile(); diff --git a/tests/expected-failure.txt b/tests/expected-failure.txt index d5934a3c5..e57fe6bc2 100644 --- a/tests/expected-failure.txt +++ b/tests/expected-failure.txt @@ -6,6 +6,7 @@ tests/bugs/byte-address-buffer-interlocked-add-f32.slang (vk) tests/bugs/gh-3075.slang.2 (vk) tests/bugs/ray-query-in-generic.slang.1 (vk) tests/bugs/vec-compare.slang.2 (vk) +tests/compute/buffer-layout.slang.2 (vk) tests/compute/half-rw-texture-convert.slang.4 (vk) tests/compute/half-rw-texture-convert2.slang.4 (vk) tests/compute/half-vector-compare.slang.1 (vk) @@ -66,4 +67,4 @@ tests/slang-extension/atomic-min-max-u64-byte-address-buffer.slang.4 (vk) tests/slang-extension/cas-int64-byte-address-buffer.slang.4 (vk) tests/slang-extension/exchange-int64-byte-address-buffer.slang.4 (vk) tests/slang-extension/realtime-clock.slang.2 (vk) -tests/type/texture-sampler/texture-sampler-2d.slang (vk) \ No newline at end of file +tests/type/texture-sampler/texture-sampler-2d.slang (vk) diff --git a/tests/language-feature/spirv-asm/assignment-syntax.slang b/tests/language-feature/spirv-asm/assignment-syntax.slang new file mode 100644 index 000000000..a511cd92a --- /dev/null +++ b/tests/language-feature/spirv-asm/assignment-syntax.slang @@ -0,0 +1,25 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -shaderobj -emit-spirv-directly + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK: 2 +// CHECK-NEXT: 4 +// CHECK-NEXT: 6 +// CHECK-NEXT: 8 + +// +// This test tests a basic application of the spirv_asm block's assignment syntax +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + %two = OpConstant $$int 2; + result = OpIMul $$int $n %two; + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/debug-instruction.slang b/tests/language-feature/spirv-asm/debug-instruction.slang new file mode 100644 index 000000000..4c25189de --- /dev/null +++ b/tests/language-feature/spirv-asm/debug-instruction.slang @@ -0,0 +1,29 @@ +//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK):-emit-spirv-directly -target spirv-asm -entry computeMain -stage compute + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK: ; Debug Information +// CHECK-NOT: ; Annotations +// CHECK: OpName %{{[a-zA-Z]+}} "INTEGERRRRRRRRRRRRRRRRRRRRR" +// CHECK: ; Annotations + +// +// This test tests that OpName is put in the correct location in the generated spriv +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + spirv_asm + { + OpName $$int "INTEGERRRRRRRRRRRRRRRRRRRRR" + }; + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + OpConstant $$int %two 2; + OpIMul $$int result $n %two + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/enum-lookup.slang b/tests/language-feature/spirv-asm/enum-lookup.slang new file mode 100644 index 000000000..ac4d8e2dd --- /dev/null +++ b/tests/language-feature/spirv-asm/enum-lookup.slang @@ -0,0 +1,26 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -shaderobj -emit-spirv-directly + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK: 2 +// CHECK-NEXT: 4 +// CHECK-NEXT: 6 +// CHECK-NEXT: 8 + +// +// This tests that we can look up a type qualified enum in a spirv block +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + // MemorySemanticsAcquire happens to have value 0x2 + %two : $$int = OpConstant MemorySemanticsAcquire; + result : $$int = OpIMul $n %two + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/id-wrap.slang b/tests/language-feature/spirv-asm/id-wrap.slang new file mode 100644 index 000000000..178ce344e --- /dev/null +++ b/tests/language-feature/spirv-asm/id-wrap.slang @@ -0,0 +1,38 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -shaderobj -emit-spirv-directly + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK: 2 +// CHECK-NEXT: 4 +// CHECK-NEXT: 6 +// CHECK-NEXT: 8 + +// +// This test tests that we correctly wrap constants in ids when required and +// can look up names through that wrapped operand kind +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + OpConstant $$int %two 2; + // A dummy barrier, this tests that we can look up these names without + // their Scope and MemorySemantics prefixes, and correctly wrap them in + // OpConstant. + OpMemoryBarrier Invocation + // Test that an unqualified enum works + AcquireRelease + // Test that a decimal integer literal works + | 64 + // Test that a hex integer literal works + | 0x800 + // Test that an explicit scope works + | MemorySemanticsAtomicCounterMemory; + OpIMul $$int result $n %two + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/opcapability.slang b/tests/language-feature/spirv-asm/opcapability.slang new file mode 100644 index 000000000..7bc9934d7 --- /dev/null +++ b/tests/language-feature/spirv-asm/opcapability.slang @@ -0,0 +1,28 @@ +//TEST:SIMPLE(filecheck=CHECK):-emit-spirv-directly -target spirv-asm -entry computeMain -stage compute + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK-NOT: ; Annotations +// CHECK: OpCapability Matrix +// CHECK: ; Annotations + +// +// This test tests that we can look up unscoped enums based on context, and +// position OpCapability correctly +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + // We should be able to look this up directly, without having to + // specify CapabilityMatrix or anything + OpCapability Matrix; + OpConstant $$int %two 2; + OpIMul $$int result $n %two + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/opextension.slang b/tests/language-feature/spirv-asm/opextension.slang new file mode 100644 index 000000000..da46423a7 --- /dev/null +++ b/tests/language-feature/spirv-asm/opextension.slang @@ -0,0 +1,25 @@ +//TEST:SIMPLE(filecheck=CHECK):-emit-spirv-directly -target spirv-asm -entry computeMain -stage compute + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK-NOT: ; Annotations +// CHECK: OpExtension "SPV_KHR_vulkan_memory_model" +// CHECK: ; Annotations + +// +// This test tests that we can position OpExtension correctly +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + OpExtension "SPV_KHR_vulkan_memory_model"; + OpConstant $$int %two 2; + OpIMul $$int result $n %two + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/too-many-operands.slang b/tests/language-feature/spirv-asm/too-many-operands.slang new file mode 100644 index 000000000..219448699 --- /dev/null +++ b/tests/language-feature/spirv-asm/too-many-operands.slang @@ -0,0 +1,26 @@ +//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): + +RWStructuredBuffer buf; + +// +// This test checks that we correctly diagnose passing too many operands to a spriv inst +// +void foo(const int constParam) +{ + spirv_asm + { + // Make sure we diagnose the first offending operand + OpLoad + %a + %b + %c + %d + %e + // CHECK: too-many-operands.slang([[#@LINE-1]]): warning 29104: too many operands for OpLoad (expected max 4), did you forget a semicolon? + %f; + + %r : $$int = OpIAdd %r %r // oops, I forgot the semicolon + OpNop + // CHECK: too-many-operands.slang([[#@LINE-1]]): warning 29104: too many operands for OpIAdd (expected max 4), did you forget a semicolon? + }; +} diff --git a/tests/language-feature/spirv-asm/typed-assignment-syntax.slang b/tests/language-feature/spirv-asm/typed-assignment-syntax.slang new file mode 100644 index 000000000..5e449686e --- /dev/null +++ b/tests/language-feature/spirv-asm/typed-assignment-syntax.slang @@ -0,0 +1,25 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK):-vk -shaderobj -emit-spirv-directly + +//TEST_INPUT:ubuffer(data=[1 2 3 4], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +// CHECK: 2 +// CHECK-NEXT: 4 +// CHECK-NEXT: 6 +// CHECK-NEXT: 8 + +// +// This test tests a basic application of the spirv_asm block's typed assignment syntax +// +[numthreads(4, 1, 1)] +void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID) +{ + int i = dispatchThreadID.x; + int n = outputBuffer[i]; + int r = spirv_asm + { + %two : $$int = OpConstant 2; + result : $$int = OpIMul $n %two; + }; + outputBuffer[i] = r; +} diff --git a/tests/language-feature/spirv-asm/wrong-assignment-opcode.slang b/tests/language-feature/spirv-asm/wrong-assignment-opcode.slang new file mode 100644 index 000000000..4afbb0417 --- /dev/null +++ b/tests/language-feature/spirv-asm/wrong-assignment-opcode.slang @@ -0,0 +1,41 @@ +//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): + +RWStructuredBuffer buf; + +// +// This test checks that we correctly diagnose trying to use the assignment and +// typed assignment syntax with operands with no result type or id. +// +// By virtue of these tests being in the same file, we also check the error +// recovery for the asm block parser. +// +int foo(const int constParam) +{ + // Doesn't have a result type + spirv_asm + { + %bar : %wrong = OpTypeInt 32 0 + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 29104: cannot use this 'x : = OpTypeInt...' syntax because OpTypeInt does not have a operand + + }; + + // Doesn't have a result value + spirv_asm + { + %foo = OpStore 1 2; + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 29104: cannot use this 'x = OpStore...' syntax because OpStore does not have a operand + }; + + // garbage + spirv_asm + { + %foo =; + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 20003: unexpected ';' + %foo :; + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 20003: unexpected ';' + %foo : bar; + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 20001: unexpected ';', expected '=' + %foo : bar =; + // CHECK: wrong-assignment-opcode.slang([[#@LINE-1]]): error 20003: unexpected ';' + }; +} diff --git a/tools/slang-lookup-generator/lookup-generator-main.cpp b/tools/slang-lookup-generator/lookup-generator-main.cpp index f64e2a78f..a6f43c102 100644 --- a/tools/slang-lookup-generator/lookup-generator-main.cpp +++ b/tools/slang-lookup-generator/lookup-generator-main.cpp @@ -4,6 +4,7 @@ #include "../../source/compiler-core/slang-json-parser.h" #include "../../source/compiler-core/slang-json-value.h" #include "../../source/compiler-core/slang-lexer.h" +#include "../../source/compiler-core/slang-perfect-hash.h" #include "../../source/core/slang-io.h" #include "../../source/core/slang-secure-crt.h" #include "../../source/core/slang-string-util.h" @@ -68,147 +69,13 @@ static List extractOpNames(UnownedStringSlice& error, const JSONValue& v return opnames; } -struct HashParams -{ - List saltTable; - List destTable; -}; - -enum HashFindResult { - Success, - NonUniqueKeys, - UnavoidableHashCollision, -}; - -// Implemented according to "Hash, displace, and compress" -// https://cmph.sourceforge.net/papers/esa09.pdf -static HashFindResult minimalPerfectHash(const List& ss, HashParams& hashParams) -{ - // Check for uniqueness - for (Index i = 0; i < ss.getCount(); ++i) - { - for (Index j = i + 1; j < ss.getCount(); ++j) - { - if (ss[i] == ss[j]) - { - return NonUniqueKeys; - } - } - } - - SLANG_ASSERT(UIndex(ss.getCount()) < std::numeric_limits::max()); - const UInt32 nBuckets = UInt32(ss.getCount()); - List> initialBuckets; - initialBuckets.setCount(nBuckets); - - const auto hash = [&](const String& s, const HashCode64 salt = 0) -> UInt32 - { - // - // The current getStableHashCode is susceptible to patterns of - // collisions causing the search to fail for the SPIR-V opnames; it - // performs poorly on short strings, taking over 300000 iterations to - // diverge on "Ceil" and "FMix" (and place them in already unoccupied - // slots)! - // - // Use FNV Hash here which seem perform much better on these short inputs - // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function - // - // If you change this, don't forget to also sync the version below in - // the printing code. - UInt64 h = salt; - for (const char c : s) h = ((h * 0x00000100000001B3) ^ c); - return h % nBuckets; - }; - - // Assign the inputs into their buckets according to the hash without salt. - // Sort the buckets according to size, so that later we can make these have - // unique destinations starting with the largest ones first as they are at - // most risk of collision. - for (const auto& s : ss) - { - initialBuckets[hash(s)].add(s); - } - initialBuckets.stableSort([](const List& a, const List& b) { return a.getCount() > b.getCount(); }); - - // These are our outputs, the salts are calculated such that for all input - // word, x, hash(x, salt[hash(x, 0)]) is unique - // - // We keep the final table as we need to detect when we've been given a - // word not in our language. - hashParams.saltTable.setCount(nBuckets); - for (auto& s : hashParams.saltTable) - { - s = 0; - } - hashParams.destTable.setCount(nBuckets); - for (auto& s : hashParams.destTable) - { - s.reduceLength(0); - } - - // This mask will, in each salt tryout, be used to prevent collisions - // within a single bucket. - List bucketDestinations = List::makeRepeated(false, nBuckets); - - for (const auto& b : initialBuckets) - { - // Break if we've reached the empty buckets - if (!b.getCount()) - { - break; - } - - // Try out all the salts until we get one which has no internal - // collisions for this bucket and also no collisions with the buckets - // we've processed so far. - UInt32 salt = 1; - while (true) - { - bool collision = false; - for (auto& d : bucketDestinations) - { - d = false; - } - - for (const auto& s : b) - { - const auto i = hash(s, salt); - if (hashParams.destTable[i].getLength() || bucketDestinations[i]) - { - collision = true; - break; - } - bucketDestinations[i] = true; - } - if (!collision) - { - break; - } - salt++; - - // If we fail to find a solution after some massive amount of tries - // it's almost certainly because of some property of the hash - // function and language causing an irresolvable collision. - if (salt > 10000 * nBuckets) - { - return UnavoidableHashCollision; - } - } - for (const auto& s : b) - { - hashParams.saltTable[hash(s)] = salt; - hashParams.destTable[hash(s, salt)] = s; - } - } - return Success; -} - void writeHashFile( const char* const outCppPath, const char* valueType, const char* valuePrefix, const List includes, - const HashParams& hashParams) + const HashParams& hashParams, + const List values) { StringBuilder sb; StringWriter writer(&sb, WriterFlags(0)); @@ -230,68 +97,12 @@ void writeHashFile( w.print("{\n"); w.print("\n"); - w.print("static const unsigned tableSalt[%ld] =", hashParams.saltTable.getCount()); - w.print("{\n "); - for (Index i = 0; i < hashParams.saltTable.getCount(); ++i) - { - const auto salt = hashParams.saltTable[i]; - if (i != hashParams.saltTable.getCount() - 1) - { - w.print(" %d,", salt); - if (i % 16 == 15) - { - w.print("\n "); - } - } - else - { - w.print(" %d", salt); - } - } - w.print("\n};\n"); - w.print("\n"); - - w.print("struct KV\n"); - w.print("{\n"); - w.print(" const char* name;\n"); - w.print(" %s value;\n", valueType); - w.print("};\n"); - w.print("\n"); - - w.print("static const KV words[%ld] =\n", hashParams.destTable.getCount()); - w.print("{\n"); - for (const auto& s : hashParams.destTable) - { - w.print(" {\"%s\", %s%s},\n", s.getBuffer(), valuePrefix, s.getBuffer()); - } - w.print("};\n"); - w.print("\n"); - - // Make sure to update the hash function in the search function above if - // you change this. - w.print("static UInt32 hash(const UnownedStringSlice& str, UInt32 salt)\n"); - w.print("{\n"); - w.print(" UInt64 h = salt;\n"); - w.print(" for(const char c : str)\n"); - w.print(" h = ((h * 0x00000100000001B3) ^ c);\n"); - w.print(" return h %% (sizeof(tableSalt)/sizeof(tableSalt[0]));\n"); - w.print("}\n"); - w.print("\n"); - - w.print("bool lookup%s(const UnownedStringSlice& str, %s& value)\n", valueType, valueType); - w.print("{\n"); - w.print(" const auto i = hash(str, tableSalt[hash(str, 0)]);\n"); - w.print(" if(str == words[i].name)\n"); - w.print(" {\n"); - w.print(" value = words[i].value;\n"); - w.print(" return true;\n"); - w.print(" }\n"); - w.print(" else\n"); - w.print(" {\n"); - w.print(" return false;\n"); - w.print(" }\n"); - w.print("}\n"); - w.print("\n"); + w.put(perfectHashToEmbeddableCpp( + hashParams, + UnownedStringSlice(valueType), + (String("lookup") + valueType).getUnownedSlice(), + values + ).getBuffer()); w.print("}\n"); @@ -356,10 +167,10 @@ int main(int argc, const char* const* argv) } HashParams hashParams; - auto r = minimalPerfectHash(opnames, hashParams); + auto r = minimalPerfectHash(opnames, hashParams); switch (r) { - case UnavoidableHashCollision: + case HashFindResult::UnavoidableHashCollision: { sink.diagnoseRaw( Severity::Error, @@ -368,20 +179,25 @@ int main(int argc, const char* const* argv) "collision for some input words\n"); return 1; } - case NonUniqueKeys: + case HashFindResult::NonUniqueKeys: { sink.diagnoseRaw(Severity::Error, "Input word list has duplicates\n"); return 1; } - case Success:; + case HashFindResult::Success:; } + List values; + values.reserve (hashParams.destTable.getCount()); + for(const auto& v : hashParams.destTable) + values.add(enumerantPrefix + v); writeHashFile( outCppPath, enumName, enumerantPrefix, { "../core/slang-common.h", "../core/slang-string.h", enumHeader }, - hashParams); + hashParams, + values); return 0; } diff --git a/tools/slang-spirv-embed-generator/spirv-embed-generator-main.cpp b/tools/slang-spirv-embed-generator/spirv-embed-generator-main.cpp new file mode 100644 index 000000000..30f1ef6b9 --- /dev/null +++ b/tools/slang-spirv-embed-generator/spirv-embed-generator-main.cpp @@ -0,0 +1,471 @@ +#include + +#include "source/core/slang-dictionary.h" +#include "source/core/slang-io.h" +#include "source/compiler-core/slang-diagnostic-sink.h" +#include "source/compiler-core/slang-perfect-hash.h" +#include "source/core/slang-writer.h" +#include "source/compiler-core/slang-spirv-core-grammar.h" +#include "source/compiler-core/slang-lexer.h" + +using namespace Slang; + +// +// Go from a dictionary to a C++ embedding of a perfect hash +// +template +String dictToPerfectHash( + const Dictionary& dict, + const UnownedStringSlice& type, + const UnownedStringSlice& funcName, + F valueToString) +{ + HashParams hashParams; + List names; + for(const auto& [name, val] : dict) + names.add(name); + auto r = minimalPerfectHash(names, hashParams); + SLANG_ASSERT(r == HashFindResult::Success); + List values; + values.reserve(hashParams.destTable.getCount()); + for(const auto& v : hashParams.destTable) + { + values.add(valueToString(dict.getValue(v.getUnownedSlice()))); + } + return perfectHashToEmbeddableCpp(hashParams, type, funcName, values); +} + +// +// Go from a dictionary to a C++ embedding of switch table +// +template +void dictToSwitch( + const Dictionary& dict, + const char* funName, + const char* keyType, + const char* valueType, + const char* unpackKey, + const F1 keyToString, + const F2 valueToAssignmentString, + WriterHelper& w) +{ + const auto line = [&](const auto& l){ + w.put(l); + w.put("\n"); + }; + + w.print("static bool %s(const %s& k, %s& v)\n", funName, keyType, valueType); + line("{"); + w.print(" switch(%s)\n", unpackKey); + line(" {"); + for(const auto& [k, v] : dict) + { + const auto kStr = keyToString(k); + const auto vStr = valueToAssignmentString(v); + w.print( + " case %s:\n" + " {\n" + " %s;\n" + " return true;\n" + " }\n", + kStr.getBuffer(), + vStr.getBuffer() + ); + } + line(" default: return false;"); + line(" }"); + line("}"); + line(""); +} + +// +// Go from a dictionary to a C++ embedding of switch table, specific to the +// two-level table of a QualifiedEnumValue +// +template +void qualifiedEnumValueNameSwitch( + const Dictionary& dict, + const char* funName, + const char* keyType, + const char* valueType, + const char* unpackKey1, + const F valueToAssignmentString, + WriterHelper& w) +{ + const auto line = [&](const auto& l){ + w.put(l); + w.put("\n"); + }; + + using K1 = Slang::SPIRVCoreGrammarInfo::OperandKind; + using K2 = SpvWord; + Dictionary> stepDict; + for(const auto& [k, v] : dict) + { + const auto& [k1, k2] = k; + stepDict[k1][k2] = v; + } + + w.print("static bool %s(const %s& k, %s& v)\n", funName, keyType, valueType); + line("{"); + line(" const auto& [k1, k2] = k;"); + w.print(" switch(%s)\n", unpackKey1); + line(" {"); + for(const auto& [k1, inner] : stepDict) + { + const auto k1Str = String(k1.index); + w.print(" case %s:\n", k1Str.getBuffer()); + + line(" switch(k2)"); + line(" {"); + for(const auto& [k2, v] : inner) + { + const auto k2Str = String(k2); + const auto vStr = valueToAssignmentString(v); + w.print(" case %s: %s; return true;\n", k2Str.getBuffer(), vStr.getBuffer()); + } + line(" default: return false;"); + line(" }"); + } + line(" default: return false;"); + line(" }"); + line("}"); + line(""); +} + +static const char* opClassToString(Slang::SPIRVCoreGrammarInfo::OpInfo::Class c) +{ + switch(c) + { +#define GO(n) case SPIRVCoreGrammarInfo::OpInfo::n: return #n; + GO(Miscellaneous) + GO(Debug) + GO(Annotation) + GO(Extension) + GO(ModeSetting) + GO(TypeDeclaration) + GO(ConstantCreation) + GO(Memory) + GO(Function) + GO(Image) + GO(Conversion) + GO(Composite) + GO(Arithmetic) + GO(Bit) + GO(Relational_and_Logical) + GO(Derivative) + GO(ControlFlow) + GO(Atomic) + GO(Primitive) + GO(Barrier) + GO(Group) + GO(DeviceSideEnqueue) + GO(Pipe) + GO(NonUniform) + GO(Reserved) + default: + GO(Other) +#undef GO + } +} + +// +// Write a C++ embedding of the SPIRVCoreGrammarInfo struct +// +void writeInfo( + const char* const outCppPath, + const SPIRVCoreGrammarInfo& info) +{ + StringBuilder sb; + StringWriter writer(&sb, WriterFlags(0)); + WriterHelper w(&writer); + const auto line = [&](const auto& l){ + w.put(l); + w.put("\n"); + }; + + // + // Intro + // + line("// Source embedding for SPIR-V core grammar"); + line("//"); + line("// This file was carefully generated by a machine,"); + line("// don't even think about modifying it yourself!"); + line("//"); + line(""); + line("#include \"../core/slang-smart-pointer.h\""); + line("#include \"../compiler-core/slang-spirv-core-grammar.h\""); + line("namespace Slang"); + line("{"); + line("using OperandKind = SPIRVCoreGrammarInfo::OperandKind;"); + line("using QualifiedEnumName = SPIRVCoreGrammarInfo::QualifiedEnumName;"); + line("using QualifiedEnumValue = SPIRVCoreGrammarInfo::QualifiedEnumValue;"); + + // + // Each block writes the lookup function for a member table + // Read the memberAssignments addition to see which one + // + List memberAssignments; + + + { + memberAssignments.add("info->opcodes.embedded = &lookupSpvOp;"); + w.put("static "); + w.put(dictToPerfectHash( + info.opcodes.dict, + UnownedStringSlice("SpvOp"), + UnownedStringSlice("lookupSpvOp"), + [](const auto n){ + const auto radix = 10; + return "static_cast(" + String(n, radix) + ")"; + } + ).getBuffer()); + } + + { + memberAssignments.add("info->capabilities.embedded = &lookupSpvCapability;"); + w.put("static "); + w.put(dictToPerfectHash( + info.capabilities.dict, + UnownedStringSlice("SpvCapability"), + UnownedStringSlice("lookupSpvCapability"), + [](const auto n){ + const auto radix = 10; + return "static_cast(" + String(n, radix) + ")"; + } + ).getBuffer()); + } + + { + memberAssignments.add("info->allEnumsWithTypePrefix.embedded = &lookupEnumWithTypePrefix;"); + w.put("static "); + w.put(dictToPerfectHash( + info.allEnumsWithTypePrefix.dict, + UnownedStringSlice("SpvWord"), + UnownedStringSlice("lookupEnumWithTypePrefix"), + [](const auto n){ + const auto radix = 10; + return "SpvWord{" + String(n, radix) + "}"; + } + ).getBuffer()); + } + + { + memberAssignments.add("info->opInfos.embedded = &getOpInfo;"); + dictToSwitch( + info.opInfos.dict, + "getOpInfo", + "SpvOp", + "SPIRVCoreGrammarInfo::OpInfo", + "k", + [&](SpvOp o){ + return "Spv" + String(info.opNames.dict.getValue(o)); + }, + [](const Slang::SPIRVCoreGrammarInfo::OpInfo& i){ + const char* classStr = opClassToString(i.class_); + String ret; + if(i.numOperandTypes) + { + ret.append("const static OperandKind operandTypes[] = {"); + String operandTypes; + for(Index o = 0; o < i.numOperandTypes; ++o) + { + if(o != 0) + ret.append(", "); + ret.append("{" + String(i.operandTypes[o].index) + "}"); + } + ret.append("};\n "); + } + ret.append( + String("v = {SPIRVCoreGrammarInfo::OpInfo::") + + classStr + ", " + + String(i.resultTypeIndex) + ", " + + String(i.resultIdIndex) + ", " + + String(i.minOperandCount) + ", " + + (i.maxOperandCount == 0xffff ? String("0xffff") : String(i.maxOperandCount)) + ", " + + String(i.numOperandTypes) + ", " + + (i.numOperandTypes ? "operandTypes" : "nullptr") + + "}"); + return ret; + }, + w + ); + } + + { + memberAssignments.add("info->opNames.embedded = &getOpName;"); + dictToSwitch( + info.opNames.dict, + "getOpName", + "SpvOp", + "UnownedStringSlice", + "k", + [&](SpvOp o){ + return "Spv" + String(info.opNames.dict.getValue(o)); + }, + [](const UnownedStringSlice& i){ + return "v = UnownedStringSlice{\"" + String(i) + "\"}"; + }, + w + ); + } + + { + memberAssignments.add("info->operandKinds.embedded = &lookupOperandKind;"); + w.put("static "); + w.put(dictToPerfectHash( + info.operandKinds.dict, + UnownedStringSlice("OperandKind"), + UnownedStringSlice("lookupOperandKind"), + [](const auto n){ + const auto radix = 10; + return "OperandKind{" + String(n.index, radix) + "}"; + } + ).getBuffer()); + } + + { + memberAssignments.add("info->allEnums.embedded = &lookupQualifiedEnum;"); + + // First construct a helper function which will lookup an enum name + // with a hex prefix representing the kind. This allows us to just + // reuse the existing string-based perfect hasher + Dictionary enumDict; + Index maxNameLength = 0; + for(const auto& [q, v] : info.allEnums.dict) + { + const auto i = q.kind.index; + String k; + k.appendChar(char((i >> 4) + 'a')); + k.appendChar(char((i & 0xf) + 'a')); + k.append(q.name); + enumDict.add(k, v); + maxNameLength = std::max(maxNameLength, k.getLength()); + } + w.put(dictToPerfectHash( + enumDict, + UnownedStringSlice("SpvWord"), + UnownedStringSlice("lookupEnumWithHexPrefix"), + [&](const auto n){ return "SpvWord{" + String(n) + "}"; } + ).getBuffer()); + + // Utilise this helper + line("static bool lookupQualifiedEnum(const QualifiedEnumName& k, SpvWord& v)"); + line("{"); + line(" static_assert(sizeof(k.kind.index) == 1);"); + w.print(" if(k.name.getLength() > %ld)\n", maxNameLength); + line(" return false;"); + w.print(" char name[%ld];\n", maxNameLength + 2); + line(" name[0] = char((k.kind.index >> 4) + 'a');"); + line(" name[1] = char((k.kind.index & 0xf) + 'a');"); + line(" memcpy(name+2, k.name.begin(), k.name.getLength());"); + line(" return lookupEnumWithHexPrefix(UnownedStringSlice(name, k.name.getLength() + 2), v);"); + line("}"); + line(""); + } + + { + memberAssignments.add("info->allEnumNames.embedded = &getQualifiedEnumName;"); + qualifiedEnumValueNameSwitch( + info.allEnumNames.dict, + "getQualifiedEnumName", + "QualifiedEnumValue", + "UnownedStringSlice", + "k1.index", + [](const UnownedStringSlice& i){ + return "v = UnownedStringSlice{\"" + String(i) + "\"}"; + }, + w + ); + } + + { + memberAssignments.add("info->operandKindNames.embedded = &getOperandKindName;"); + dictToSwitch( + info.operandKindNames.dict, + "getOperandKindName", + "OperandKind", + "UnownedStringSlice", + "k.index", + [&](Slang::SPIRVCoreGrammarInfo::OperandKind o){ + return String(o.index); + }, + [](const UnownedStringSlice& i){ + return "v = UnownedStringSlice{\"" + String(i) + "\"}"; + }, + w + ); + } + + { + memberAssignments.add("info->operandKindUnderneathIds.embedded = &getOperandKindUnderneathId;"); + dictToSwitch( + info.operandKindUnderneathIds.dict, + "getOperandKindUnderneathId", + "OperandKind", + "OperandKind", + "k.index", + [](Slang::SPIRVCoreGrammarInfo::OperandKind o){ + return String(o.index); + }, + [](Slang::SPIRVCoreGrammarInfo::OperandKind i){ + return "v = OperandKind{" + String(i.index) + "}"; + }, + w + ); + } + + // + // Now write out the function which holds onto the static embedded info table + // + line("RefPtr SPIRVCoreGrammarInfo::getEmbeddedVersion()"); + line("{"); + line(" static RefPtr embedded = [](){"); + line(" RefPtr info = new SPIRVCoreGrammarInfo();"); + for(const auto& a : memberAssignments) + line((" " + a).getBuffer()); + + // + line(" return info;"); + line(" }();"); + line(" return embedded;"); + line("}"); + line("}"); + + File::writeAllTextIfChanged(outCppPath, sb.getUnownedSlice()); +} + +int main(int argc, const char* const* argv) +{ + using namespace Slang; + + if (argc != 3) + { + fprintf( + stderr, + "Usage: %s spirv.core.grammar.json output.cpp\n", + argc >= 1 ? argv[0] : "slang-spirv-embed-generator"); + return 1; + } + + const char* const inPath = argv[1]; + const char* const outCppPath = argv[2]; + + RefPtr writer(new FileWriter(stderr, WriterFlag::AutoFlush)); + SourceManager sourceManager; + sourceManager.initialize(nullptr, nullptr); + DiagnosticSink sink(&sourceManager, Lexer::sourceLocationLexer); + sink.writer = writer; + + String contents; + SLANG_RETURN_ON_FAIL(File::readAllText(inPath, contents)); + PathInfo pathInfo = PathInfo::makeFromString(inPath); + SourceFile* sourceFile = sourceManager.createSourceFileWithString(pathInfo, contents); + SourceView* sourceView = sourceManager.createSourceView(sourceFile, nullptr, SourceLoc()); + + RefPtr info = SPIRVCoreGrammarInfo::loadFromJSON(*sourceView, sink); + + writeInfo(outCppPath, *info); + + return 0; +} -- cgit v1.2.3