From 32569eef5e5ba9b12a5b1c0e90f0e2163ee7b0d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Leclercq?= Date: Fri, 19 Feb 2021 14:47:24 +0100 Subject: [PATCH] Add SpirV masks and update grammar --- build/scripts/actions/spirv.lua | 33 +- include/Nazara/Shader/SpirvData.hpp | 344 +++++++++- src/Nazara/Shader/SpirvData.cpp | 958 +++++++++++++++++++--------- 3 files changed, 1010 insertions(+), 325 deletions(-) diff --git a/build/scripts/actions/spirv.lua b/build/scripts/actions/spirv.lua index b47c81fa9..6843e548a 100644 --- a/build/scripts/actions/spirv.lua +++ b/build/scripts/actions/spirv.lua @@ -60,6 +60,7 @@ ACTION.Function = function() #define NAZARA_SPIRVDATA_HPP #include +#include #include namespace Nz @@ -90,7 +91,7 @@ headerFile:write([[ for _, operand in pairs(result.operand_kinds) do headerFile:write("\t\t" .. operand.kind .. ",\n") end - + headerFile:write([[ }; @@ -98,24 +99,46 @@ headerFile:write([[ -- SpirV enums for _, operand in pairs(result.operand_kinds) do - if (operand.category == "ValueEnum") then + if (operand.category == "ValueEnum" or operand.category == "BitEnum") then + local enumName = "Spirv" .. operand.kind headerFile:write([[ - enum class Spirv]] .. operand.kind .. [[ + enum class ]] .. enumName .. [[ { ]]) + local maxName + local maxValue for _, enumerant in pairs(operand.enumerants) do + local value = enumerant.value + local eName = enumerant.enumerant:match("^%d") and operand.kind .. enumerant.enumerant or enumerant.enumerant headerFile:write([[ - ]] .. eName .. [[ = ]] .. enumerant.value .. [[, + ]] .. eName .. [[ = ]] .. value .. [[, ]]) + + if (not maxValue or value > maxValue) then + maxName = eName + end end headerFile:write([[ }; ]]) + if (operand.category == "BitEnum") then + headerFile:write([[ + template<> + struct EnumAsFlags<]] .. enumName .. [[> + { + static constexpr ]] .. enumName .. [[ max = ]] .. enumName .. "::" .. maxName .. [[; + + static constexpr bool AutoFlag = false; + }; + + +]]) + end end end @@ -220,4 +243,4 @@ namespace Nz } ]]) -end \ No newline at end of file +end diff --git a/include/Nazara/Shader/SpirvData.hpp b/include/Nazara/Shader/SpirvData.hpp index eccc122ad..3295d2edb 100644 --- a/include/Nazara/Shader/SpirvData.hpp +++ b/include/Nazara/Shader/SpirvData.hpp @@ -1,4 +1,4 @@ -// Copyright (C) 2020 Jérôme Leclercq +// Copyright (C) 2021 Jérôme Leclercq // This file is part of the "Nazara Engine - Shader generator" // For conditions of distribution and use, see copyright notice in Config.hpp" @@ -10,6 +10,7 @@ #define NAZARA_SPIRVDATA_HPP #include +#include #include namespace Nz @@ -367,7 +368,12 @@ namespace Nz OpSubgroupAnyKHR = 4429, OpSubgroupAllEqualKHR = 4430, OpSubgroupReadInvocationKHR = 4432, - OpTypeRayQueryProvisionalKHR = 4472, + OpTraceRayKHR = 4445, + OpExecuteCallableKHR = 4446, + OpConvertUToAccelerationStructureKHR = 4447, + OpIgnoreIntersectionKHR = 4448, + OpTerminateRayKHR = 4449, + OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, OpRayQueryGenerateIntersectionKHR = 4475, @@ -391,15 +397,11 @@ namespace Nz OpReportIntersectionNV = 5334, OpReportIntersectionKHR = 5334, OpIgnoreIntersectionNV = 5335, - OpIgnoreIntersectionKHR = 5335, OpTerminateRayNV = 5336, - OpTerminateRayKHR = 5336, OpTraceNV = 5337, - OpTraceRayKHR = 5337, OpTypeAccelerationStructureNV = 5341, OpTypeAccelerationStructureKHR = 5341, OpExecuteCallableNV = 5344, - OpExecuteCallableKHR = 5344, OpTypeCooperativeMatrixNV = 5358, OpCooperativeMatrixLoadNV = 5359, OpCooperativeMatrixStoreNV = 5360, @@ -433,8 +435,13 @@ namespace Nz OpUSubSatINTEL = 5596, OpIMul32x16INTEL = 5597, OpUMul32x16INTEL = 5598, - OpFunctionPointerINTEL = 5600, + OpConstFunctionPointerINTEL = 5600, OpFunctionPointerCallINTEL = 5601, + OpAsmTargetINTEL = 5609, + OpAsmINTEL = 5610, + OpAsmCallINTEL = 5611, + OpAtomicFMinEXT = 5614, + OpAtomicFMaxEXT = 5615, OpDecorateString = 5632, OpDecorateStringGOOGLE = 5632, OpMemberDecorateString = 5633, @@ -557,7 +564,12 @@ namespace Nz OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, + OpVariableLengthArrayINTEL = 5818, + OpSaveMemoryINTEL = 5819, + OpRestoreMemoryINTEL = 5820, OpLoopControlINTEL = 5887, + OpPtrCastToCrossWorkgroupINTEL = 5934, + OpCrossWorkgroupCastToPtrINTEL = 5938, OpReadPipeBlockingINTEL = 5946, OpWritePipeBlockingINTEL = 5947, OpFPGARegINTEL = 5949, @@ -579,6 +591,10 @@ namespace Nz OpRayQueryGetIntersectionObjectToWorldKHR = 6031, OpRayQueryGetIntersectionWorldToObjectKHR = 6032, OpAtomicFAddEXT = 6035, + OpTypeBufferSurfaceINTEL = 6086, + OpTypeStructContinuedINTEL = 6090, + OpConstantCompositeContinuedINTEL = 6091, + OpSpecConstantCompositeContinuedINTEL = 6092, }; enum class SpirvOperandKind @@ -592,6 +608,7 @@ namespace Nz MemoryAccess, KernelProfilingInfo, RayFlags, + FragmentShadingRate, SourceLanguage, ExecutionModel, AddressingModel, @@ -605,6 +622,8 @@ namespace Nz ImageChannelOrder, ImageChannelDataType, FPRoundingMode, + FPDenormMode, + FPOperationMode, LinkageType, AccessQualifier, FunctionParameterAttribute, @@ -632,6 +651,235 @@ namespace Nz PairIdRefIdRef, }; + enum class SpirvImageOperands + { + None = 0x0000, + Bias = 0x0001, + Lod = 0x0002, + Grad = 0x0004, + ConstOffset = 0x0008, + Offset = 0x0010, + ConstOffsets = 0x0020, + Sample = 0x0040, + MinLod = 0x0080, + MakeTexelAvailable = 0x0100, + MakeTexelAvailableKHR = 0x0100, + MakeTexelVisible = 0x0200, + MakeTexelVisibleKHR = 0x0200, + NonPrivateTexel = 0x0400, + NonPrivateTexelKHR = 0x0400, + VolatileTexel = 0x0800, + VolatileTexelKHR = 0x0800, + SignExtend = 0x1000, + ZeroExtend = 0x2000, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvImageOperands max = SpirvImageOperands::ZeroExtend; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvFPFastMathMode + { + None = 0x0000, + NotNaN = 0x0001, + NotInf = 0x0002, + NSZ = 0x0004, + AllowRecip = 0x0008, + Fast = 0x0010, + AllowContractFastINTEL = 0x10000, + AllowReassocINTEL = 0x20000, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvFPFastMathMode max = SpirvFPFastMathMode::AllowReassocINTEL; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvSelectionControl + { + None = 0x0000, + Flatten = 0x0001, + DontFlatten = 0x0002, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvSelectionControl max = SpirvSelectionControl::DontFlatten; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvLoopControl + { + None = 0x0000, + Unroll = 0x0001, + DontUnroll = 0x0002, + DependencyInfinite = 0x0004, + DependencyLength = 0x0008, + MinIterations = 0x0010, + MaxIterations = 0x0020, + IterationMultiple = 0x0040, + PeelCount = 0x0080, + PartialCount = 0x0100, + InitiationIntervalINTEL = 0x10000, + MaxConcurrencyINTEL = 0x20000, + DependencyArrayINTEL = 0x40000, + PipelineEnableINTEL = 0x80000, + LoopCoalesceINTEL = 0x100000, + MaxInterleavingINTEL = 0x200000, + SpeculatedIterationsINTEL = 0x400000, + NoFusionINTEL = 0x800000, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvLoopControl max = SpirvLoopControl::NoFusionINTEL; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvFunctionControl + { + None = 0x0000, + Inline = 0x0001, + DontInline = 0x0002, + Pure = 0x0004, + Const = 0x0008, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvFunctionControl max = SpirvFunctionControl::Const; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvMemorySemantics + { + Relaxed = 0x0000, + None = 0x0000, + Acquire = 0x0002, + Release = 0x0004, + AcquireRelease = 0x0008, + SequentiallyConsistent = 0x0010, + UniformMemory = 0x0040, + SubgroupMemory = 0x0080, + WorkgroupMemory = 0x0100, + CrossWorkgroupMemory = 0x0200, + AtomicCounterMemory = 0x0400, + ImageMemory = 0x0800, + OutputMemory = 0x1000, + OutputMemoryKHR = 0x1000, + MakeAvailable = 0x2000, + MakeAvailableKHR = 0x2000, + MakeVisible = 0x4000, + MakeVisibleKHR = 0x4000, + Volatile = 0x8000, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvMemorySemantics max = SpirvMemorySemantics::Volatile; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvMemoryAccess + { + None = 0x0000, + Volatile = 0x0001, + Aligned = 0x0002, + Nontemporal = 0x0004, + MakePointerAvailable = 0x0008, + MakePointerAvailableKHR = 0x0008, + MakePointerVisible = 0x0010, + MakePointerVisibleKHR = 0x0010, + NonPrivatePointer = 0x0020, + NonPrivatePointerKHR = 0x0020, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvMemoryAccess max = SpirvMemoryAccess::NonPrivatePointerKHR; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvKernelProfilingInfo + { + None = 0x0000, + CmdExecTime = 0x0001, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvKernelProfilingInfo max = SpirvKernelProfilingInfo::CmdExecTime; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvRayFlags + { + NoneKHR = 0x0000, + OpaqueKHR = 0x0001, + NoOpaqueKHR = 0x0002, + TerminateOnFirstHitKHR = 0x0004, + SkipClosestHitShaderKHR = 0x0008, + CullBackFacingTrianglesKHR = 0x0010, + CullFrontFacingTrianglesKHR = 0x0020, + CullOpaqueKHR = 0x0040, + CullNoOpaqueKHR = 0x0080, + SkipTrianglesKHR = 0x0100, + SkipAABBsKHR = 0x0200, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvRayFlags max = SpirvRayFlags::SkipAABBsKHR; + + static constexpr bool AutoFlag = false; + }; + + + enum class SpirvFragmentShadingRate + { + Vertical2Pixels = 0x0001, + Vertical4Pixels = 0x0002, + Horizontal2Pixels = 0x0004, + Horizontal4Pixels = 0x0008, + }; + + template<> + struct EnumAsFlags + { + static constexpr SpirvFragmentShadingRate max = SpirvFragmentShadingRate::Horizontal4Pixels; + + static constexpr bool AutoFlag = false; + }; + + enum class SpirvSourceLanguage { Unknown = 0, @@ -743,10 +991,16 @@ namespace Nz SampleInterlockUnorderedEXT = 5369, ShadingRateInterlockOrderedEXT = 5370, ShadingRateInterlockUnorderedEXT = 5371, + SharedLocalMemorySizeINTEL = 5618, + RoundingModeRTPINTEL = 5620, + RoundingModeRTNINTEL = 5621, + FloatingPointModeALTINTEL = 5622, + FloatingPointModeIEEEINTEL = 5623, MaxWorkgroupSizeINTEL = 5893, MaxWorkDimINTEL = 5894, NoGlobalOffsetINTEL = 5895, NumSIMDWorkitemsINTEL = 5896, + SchedulerTargetFmaxMhzINTEL = 5903, }; enum class SpirvStorageClass @@ -779,6 +1033,8 @@ namespace Nz PhysicalStorageBuffer = 5349, PhysicalStorageBufferEXT = 5349, CodeSectionINTEL = 5605, + DeviceOnlyINTEL = 5936, + HostOnlyINTEL = 5937, }; enum class SpirvDim @@ -849,6 +1105,8 @@ namespace Nz Rg8ui = 37, R16ui = 38, R8ui = 39, + R64ui = 40, + R64i = 41, }; enum class SpirvImageChannelOrder @@ -904,6 +1162,18 @@ namespace Nz RTN = 3, }; + enum class SpirvFPDenormMode + { + Preserve = 0, + FlushToZero = 1, + }; + + enum class SpirvFPOperationMode + { + IEEE = 0, + ALT = 1, + }; + enum class SpirvLinkageType { Export = 0, @@ -995,12 +1265,22 @@ namespace Nz RestrictPointerEXT = 5355, AliasedPointer = 5356, AliasedPointerEXT = 5356, + SIMTCallINTEL = 5599, ReferencedIndirectlyINTEL = 5602, + ClobberINTEL = 5607, + SideEffectsINTEL = 5608, + VectorComputeVariableINTEL = 5624, + FuncParamIOKindINTEL = 5625, + VectorComputeFunctionINTEL = 5626, + StackCallINTEL = 5627, + GlobalVariableOffsetINTEL = 5628, CounterBuffer = 5634, HlslCounterBufferGOOGLE = 5634, UserSemantic = 5635, HlslSemanticGOOGLE = 5635, UserTypeGOOGLE = 5636, + FunctionRoundingModeINTEL = 5822, + FunctionDenormModeINTEL = 5823, RegisterINTEL = 5825, MemoryINTEL = 5826, NumbanksINTEL = 5827, @@ -1013,6 +1293,17 @@ namespace Nz MergeINTEL = 5834, BankBitsINTEL = 5835, ForcePow2DepthINTEL = 5836, + BurstCoalesceINTEL = 5899, + CacheSizeINTEL = 5900, + DontStaticallyCoalesceINTEL = 5901, + PrefetchINTEL = 5902, + StallEnableINTEL = 5905, + FuseLoopsInFunctionINTEL = 5907, + BufferLocationINTEL = 5921, + IOPipeStorageINTEL = 5944, + FunctionFloatingPointModeINTEL = 6080, + SingleElementVectorINTEL = 6085, + VectorComputeCallableFunctionINTEL = 6087, }; enum class SpirvBuiltIn @@ -1059,20 +1350,22 @@ namespace Nz VertexIndex = 42, InstanceIndex = 43, SubgroupEqMask = 4416, - SubgroupGeMask = 4417, - SubgroupGtMask = 4418, - SubgroupLeMask = 4419, - SubgroupLtMask = 4420, SubgroupEqMaskKHR = 4416, + SubgroupGeMask = 4417, SubgroupGeMaskKHR = 4417, + SubgroupGtMask = 4418, SubgroupGtMaskKHR = 4418, + SubgroupLeMask = 4419, SubgroupLeMaskKHR = 4419, + SubgroupLtMask = 4420, SubgroupLtMaskKHR = 4420, BaseVertex = 4424, BaseInstance = 4425, DrawIndex = 4426, + PrimitiveShadingRateKHR = 4432, DeviceIndex = 4438, ViewIndex = 4440, + ShadingRateKHR = 4444, BaryCoordNoPerspAMD = 4992, BaryCoordNoPerspCentroidAMD = 4993, BaryCoordNoPerspSampleAMD = 4994, @@ -1124,7 +1417,6 @@ namespace Nz WorldToObjectNV = 5331, WorldToObjectKHR = 5331, HitTNV = 5332, - HitTKHR = 5332, HitKindNV = 5333, HitKindKHR = 5333, IncomingRayFlagsNV = 5351, @@ -1237,8 +1529,12 @@ namespace Nz GroupNonUniformQuad = 68, ShaderLayer = 69, ShaderViewportIndex = 70, + FragmentShadingRateKHR = 4422, SubgroupBallotKHR = 4423, DrawParameters = 4427, + WorkgroupMemoryExplicitLayoutKHR = 4428, + WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429, + WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430, SubgroupVoteKHR = 4431, StorageBuffer16BitAccess = 4433, StorageUniformBufferBlock16 = 4433, @@ -1261,12 +1557,15 @@ namespace Nz RoundingModeRTE = 4467, RoundingModeRTZ = 4468, RayQueryProvisionalKHR = 4471, - RayTraversalPrimitiveCullingProvisionalKHR = 4478, + RayQueryKHR = 4472, + RayTraversalPrimitiveCullingKHR = 4478, + RayTracingKHR = 4479, Float16ImageAMD = 5008, ImageGatherBiasLodAMD = 5009, FragmentMaskAMD = 5010, StencilExportEXT = 5013, ImageReadWriteLodAMD = 5015, + Int64ImageEXT = 5016, ShaderClockKHR = 5055, SampleMaskOverrideCoverageNV = 5249, GeometryShaderPassthroughNV = 5251, @@ -1326,21 +1625,40 @@ namespace Nz SubgroupBufferBlockIOINTEL = 5569, SubgroupImageBlockIOINTEL = 5570, SubgroupImageMediaBlockIOINTEL = 5579, + RoundToInfinityINTEL = 5582, + FloatingPointModeINTEL = 5583, IntegerFunctions2INTEL = 5584, FunctionPointersINTEL = 5603, IndirectReferencesINTEL = 5604, + AsmINTEL = 5606, + AtomicFloat32MinMaxEXT = 5612, + AtomicFloat64MinMaxEXT = 5613, + AtomicFloat16MinMaxEXT = 5616, + VectorComputeINTEL = 5617, + VectorAnyINTEL = 5619, SubgroupAvcMotionEstimationINTEL = 5696, SubgroupAvcMotionEstimationIntraINTEL = 5697, SubgroupAvcMotionEstimationChromaINTEL = 5698, + VariableLengthArrayINTEL = 5817, + FunctionFloatControlINTEL = 5821, FPGAMemoryAttributesINTEL = 5824, + FPFastMathModeINTEL = 5837, + ArbitraryPrecisionIntegersINTEL = 5844, UnstructuredLoopControlsINTEL = 5886, FPGALoopControlsINTEL = 5888, KernelAttributesINTEL = 5892, FPGAKernelAttributesINTEL = 5897, + FPGAMemoryAccessesINTEL = 5898, + FPGAClusterAttributesINTEL = 5904, + LoopFuseINTEL = 5906, + FPGABufferLocationINTEL = 5920, + USMStorageClassesINTEL = 5935, + IOPipesINTEL = 5943, BlockingPipesINTEL = 5945, FPGARegINTEL = 5948, AtomicFloat32AddEXT = 6033, AtomicFloat64AddEXT = 6034, + LongConstantCompositeINTEL = 6089, }; enum class SpirvRayQueryIntersection diff --git a/src/Nazara/Shader/SpirvData.cpp b/src/Nazara/Shader/SpirvData.cpp index dae33b777..5bb2f2794 100644 --- a/src/Nazara/Shader/SpirvData.cpp +++ b/src/Nazara/Shader/SpirvData.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2020 Jérôme Leclercq +// Copyright (C) 2021 Jérôme Leclercq // This file is part of the "Nazara Engine - Shader generator" // For conditions of distribution and use, see copyright notice in Config.hpp" @@ -11,7 +11,7 @@ namespace Nz { - static constexpr std::array s_operands = { + static constexpr std::array s_operands = { { { SpirvOperandKind::IdResultType, @@ -5429,6 +5429,70 @@ namespace Nz SpirvOperandKind::IdRef, R"('Index')" }, + { + SpirvOperandKind::IdRef, + R"('Accel')" + }, + { + SpirvOperandKind::IdRef, + R"('Ray Flags')" + }, + { + SpirvOperandKind::IdRef, + R"('Cull Mask')" + }, + { + SpirvOperandKind::IdRef, + R"('SBT Offset')" + }, + { + SpirvOperandKind::IdRef, + R"('SBT Stride')" + }, + { + SpirvOperandKind::IdRef, + R"('Miss Index')" + }, + { + SpirvOperandKind::IdRef, + R"('Ray Origin')" + }, + { + SpirvOperandKind::IdRef, + R"('Ray Tmin')" + }, + { + SpirvOperandKind::IdRef, + R"('Ray Direction')" + }, + { + SpirvOperandKind::IdRef, + R"('Ray Tmax')" + }, + { + SpirvOperandKind::IdRef, + R"('Payload')" + }, + { + SpirvOperandKind::IdRef, + R"('SBT Index')" + }, + { + SpirvOperandKind::IdRef, + R"('Callable Data')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Accel')" + }, { SpirvOperandKind::IdResult, R"(IdResult)" @@ -6345,6 +6409,106 @@ namespace Nz SpirvOperandKind::IdRef, R"('Operand 1')" }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::LiteralString, + R"('Asm target')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Asm type')" + }, + { + SpirvOperandKind::IdRef, + R"('Target')" + }, + { + SpirvOperandKind::LiteralString, + R"('Asm instructions')" + }, + { + SpirvOperandKind::LiteralString, + R"('Constraints')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Asm')" + }, + { + SpirvOperandKind::IdRef, + R"('Argument 0')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Pointer')" + }, + { + SpirvOperandKind::IdScope, + R"('Memory')" + }, + { + SpirvOperandKind::IdMemorySemantics, + R"('Semantics')" + }, + { + SpirvOperandKind::IdRef, + R"('Value')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Pointer')" + }, + { + SpirvOperandKind::IdScope, + R"('Memory')" + }, + { + SpirvOperandKind::IdMemorySemantics, + R"('Semantics')" + }, + { + SpirvOperandKind::IdRef, + R"('Value')" + }, { SpirvOperandKind::IdRef, R"('Target')" @@ -8185,6 +8349,30 @@ namespace Nz SpirvOperandKind::IdRef, R"('Payload')" }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Lenght')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Ptr')" + }, { SpirvOperandKind::LiteralInteger, R"('Loop Control Parameters')" @@ -8197,6 +8385,30 @@ namespace Nz SpirvOperandKind::IdResult, R"(IdResult)" }, + { + SpirvOperandKind::IdRef, + R"('Pointer')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Pointer')" + }, + { + SpirvOperandKind::IdResultType, + R"(IdResultType)" + }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, { SpirvOperandKind::IdRef, R"('Packet Size')" @@ -8513,10 +8725,28 @@ namespace Nz SpirvOperandKind::IdRef, R"('Value')" }, + { + SpirvOperandKind::IdResult, + R"(IdResult)" + }, + { + SpirvOperandKind::IdRef, + R"('Member 0 type', + +'member 1 type', + +...)" + }, + { + SpirvOperandKind::IdRef, + R"('Constituents')" + }, + { + SpirvOperandKind::IdRef, + R"('Constituents')" + }, } }; - static std::array s_instructions = { + static std::array s_instructions = { { { SpirvOp::OpNop, @@ -10625,137 +10855,23 @@ namespace Nz 4, }, { - SpirvOp::OpTypeRayQueryProvisionalKHR, - R"(OpTypeRayQueryProvisionalKHR)", + SpirvOp::OpTraceRayKHR, + R"(OpTraceRayKHR)", &s_operands[1352], - 1, + 11, }, { - SpirvOp::OpRayQueryInitializeKHR, - R"(OpRayQueryInitializeKHR)", - &s_operands[1353], - 8, - }, - { - SpirvOp::OpRayQueryTerminateKHR, - R"(OpRayQueryTerminateKHR)", - &s_operands[1361], - 1, - }, - { - SpirvOp::OpRayQueryGenerateIntersectionKHR, - R"(OpRayQueryGenerateIntersectionKHR)", - &s_operands[1362], + SpirvOp::OpExecuteCallableKHR, + R"(OpExecuteCallableKHR)", + &s_operands[1363], 2, }, { - SpirvOp::OpRayQueryConfirmIntersectionKHR, - R"(OpRayQueryConfirmIntersectionKHR)", - &s_operands[1364], - 1, - }, - { - SpirvOp::OpRayQueryProceedKHR, - R"(OpRayQueryProceedKHR)", + SpirvOp::OpConvertUToAccelerationStructureKHR, + R"(OpConvertUToAccelerationStructureKHR)", &s_operands[1365], 3, }, - { - SpirvOp::OpRayQueryGetIntersectionTypeKHR, - R"(OpRayQueryGetIntersectionTypeKHR)", - &s_operands[1368], - 4, - }, - { - SpirvOp::OpGroupIAddNonUniformAMD, - R"(OpGroupIAddNonUniformAMD)", - &s_operands[1372], - 5, - }, - { - SpirvOp::OpGroupFAddNonUniformAMD, - R"(OpGroupFAddNonUniformAMD)", - &s_operands[1377], - 5, - }, - { - SpirvOp::OpGroupFMinNonUniformAMD, - R"(OpGroupFMinNonUniformAMD)", - &s_operands[1382], - 5, - }, - { - SpirvOp::OpGroupUMinNonUniformAMD, - R"(OpGroupUMinNonUniformAMD)", - &s_operands[1387], - 5, - }, - { - SpirvOp::OpGroupSMinNonUniformAMD, - R"(OpGroupSMinNonUniformAMD)", - &s_operands[1392], - 5, - }, - { - SpirvOp::OpGroupFMaxNonUniformAMD, - R"(OpGroupFMaxNonUniformAMD)", - &s_operands[1397], - 5, - }, - { - SpirvOp::OpGroupUMaxNonUniformAMD, - R"(OpGroupUMaxNonUniformAMD)", - &s_operands[1402], - 5, - }, - { - SpirvOp::OpGroupSMaxNonUniformAMD, - R"(OpGroupSMaxNonUniformAMD)", - &s_operands[1407], - 5, - }, - { - SpirvOp::OpFragmentMaskFetchAMD, - R"(OpFragmentMaskFetchAMD)", - &s_operands[1412], - 4, - }, - { - SpirvOp::OpFragmentFetchAMD, - R"(OpFragmentFetchAMD)", - &s_operands[1416], - 5, - }, - { - SpirvOp::OpReadClockKHR, - R"(OpReadClockKHR)", - &s_operands[1421], - 3, - }, - { - SpirvOp::OpImageSampleFootprintNV, - R"(OpImageSampleFootprintNV)", - &s_operands[1424], - 7, - }, - { - SpirvOp::OpGroupNonUniformPartitionNV, - R"(OpGroupNonUniformPartitionNV)", - &s_operands[1431], - 3, - }, - { - SpirvOp::OpWritePackedPrimitiveIndices4x8NV, - R"(OpWritePackedPrimitiveIndices4x8NV)", - &s_operands[1434], - 2, - }, - { - SpirvOp::OpReportIntersectionKHR, - R"(OpReportIntersectionKHR)", - &s_operands[1436], - 4, - }, { SpirvOp::OpIgnoreIntersectionKHR, R"(OpIgnoreIntersectionKHR)", @@ -10769,51 +10885,195 @@ namespace Nz 0, }, { - SpirvOp::OpTraceRayKHR, - R"(OpTraceRayKHR)", + SpirvOp::OpTypeRayQueryKHR, + R"(OpTypeRayQueryKHR)", + &s_operands[1368], + 1, + }, + { + SpirvOp::OpRayQueryInitializeKHR, + R"(OpRayQueryInitializeKHR)", + &s_operands[1369], + 8, + }, + { + SpirvOp::OpRayQueryTerminateKHR, + R"(OpRayQueryTerminateKHR)", + &s_operands[1377], + 1, + }, + { + SpirvOp::OpRayQueryGenerateIntersectionKHR, + R"(OpRayQueryGenerateIntersectionKHR)", + &s_operands[1378], + 2, + }, + { + SpirvOp::OpRayQueryConfirmIntersectionKHR, + R"(OpRayQueryConfirmIntersectionKHR)", + &s_operands[1380], + 1, + }, + { + SpirvOp::OpRayQueryProceedKHR, + R"(OpRayQueryProceedKHR)", + &s_operands[1381], + 3, + }, + { + SpirvOp::OpRayQueryGetIntersectionTypeKHR, + R"(OpRayQueryGetIntersectionTypeKHR)", + &s_operands[1384], + 4, + }, + { + SpirvOp::OpGroupIAddNonUniformAMD, + R"(OpGroupIAddNonUniformAMD)", + &s_operands[1388], + 5, + }, + { + SpirvOp::OpGroupFAddNonUniformAMD, + R"(OpGroupFAddNonUniformAMD)", + &s_operands[1393], + 5, + }, + { + SpirvOp::OpGroupFMinNonUniformAMD, + R"(OpGroupFMinNonUniformAMD)", + &s_operands[1398], + 5, + }, + { + SpirvOp::OpGroupUMinNonUniformAMD, + R"(OpGroupUMinNonUniformAMD)", + &s_operands[1403], + 5, + }, + { + SpirvOp::OpGroupSMinNonUniformAMD, + R"(OpGroupSMinNonUniformAMD)", + &s_operands[1408], + 5, + }, + { + SpirvOp::OpGroupFMaxNonUniformAMD, + R"(OpGroupFMaxNonUniformAMD)", + &s_operands[1413], + 5, + }, + { + SpirvOp::OpGroupUMaxNonUniformAMD, + R"(OpGroupUMaxNonUniformAMD)", + &s_operands[1418], + 5, + }, + { + SpirvOp::OpGroupSMaxNonUniformAMD, + R"(OpGroupSMaxNonUniformAMD)", + &s_operands[1423], + 5, + }, + { + SpirvOp::OpFragmentMaskFetchAMD, + R"(OpFragmentMaskFetchAMD)", + &s_operands[1428], + 4, + }, + { + SpirvOp::OpFragmentFetchAMD, + R"(OpFragmentFetchAMD)", + &s_operands[1432], + 5, + }, + { + SpirvOp::OpReadClockKHR, + R"(OpReadClockKHR)", + &s_operands[1437], + 3, + }, + { + SpirvOp::OpImageSampleFootprintNV, + R"(OpImageSampleFootprintNV)", &s_operands[1440], + 7, + }, + { + SpirvOp::OpGroupNonUniformPartitionNV, + R"(OpGroupNonUniformPartitionNV)", + &s_operands[1447], + 3, + }, + { + SpirvOp::OpWritePackedPrimitiveIndices4x8NV, + R"(OpWritePackedPrimitiveIndices4x8NV)", + &s_operands[1450], + 2, + }, + { + SpirvOp::OpReportIntersectionKHR, + R"(OpReportIntersectionKHR)", + &s_operands[1452], + 4, + }, + { + SpirvOp::OpIgnoreIntersectionNV, + R"(OpIgnoreIntersectionNV)", + nullptr, + 0, + }, + { + SpirvOp::OpTerminateRayNV, + R"(OpTerminateRayNV)", + nullptr, + 0, + }, + { + SpirvOp::OpTraceNV, + R"(OpTraceNV)", + &s_operands[1456], 11, }, { SpirvOp::OpTypeAccelerationStructureKHR, R"(OpTypeAccelerationStructureKHR)", - &s_operands[1451], + &s_operands[1467], 1, }, { - SpirvOp::OpExecuteCallableKHR, - R"(OpExecuteCallableKHR)", - &s_operands[1452], + SpirvOp::OpExecuteCallableNV, + R"(OpExecuteCallableNV)", + &s_operands[1468], 2, }, { SpirvOp::OpTypeCooperativeMatrixNV, R"(OpTypeCooperativeMatrixNV)", - &s_operands[1454], + &s_operands[1470], 5, }, { SpirvOp::OpCooperativeMatrixLoadNV, R"(OpCooperativeMatrixLoadNV)", - &s_operands[1459], + &s_operands[1475], 6, }, { SpirvOp::OpCooperativeMatrixStoreNV, R"(OpCooperativeMatrixStoreNV)", - &s_operands[1465], + &s_operands[1481], 5, }, { SpirvOp::OpCooperativeMatrixMulAddNV, R"(OpCooperativeMatrixMulAddNV)", - &s_operands[1470], + &s_operands[1486], 5, }, { SpirvOp::OpCooperativeMatrixLengthNV, R"(OpCooperativeMatrixLengthNV)", - &s_operands[1475], + &s_operands[1491], 3, }, { @@ -10837,1017 +11097,1101 @@ namespace Nz { SpirvOp::OpIsHelperInvocationEXT, R"(OpIsHelperInvocationEXT)", - &s_operands[1478], + &s_operands[1494], 2, }, { SpirvOp::OpSubgroupShuffleINTEL, R"(OpSubgroupShuffleINTEL)", - &s_operands[1480], + &s_operands[1496], 4, }, { SpirvOp::OpSubgroupShuffleDownINTEL, R"(OpSubgroupShuffleDownINTEL)", - &s_operands[1484], + &s_operands[1500], 5, }, { SpirvOp::OpSubgroupShuffleUpINTEL, R"(OpSubgroupShuffleUpINTEL)", - &s_operands[1489], + &s_operands[1505], 5, }, { SpirvOp::OpSubgroupShuffleXorINTEL, R"(OpSubgroupShuffleXorINTEL)", - &s_operands[1494], + &s_operands[1510], 4, }, { SpirvOp::OpSubgroupBlockReadINTEL, R"(OpSubgroupBlockReadINTEL)", - &s_operands[1498], + &s_operands[1514], 3, }, { SpirvOp::OpSubgroupBlockWriteINTEL, R"(OpSubgroupBlockWriteINTEL)", - &s_operands[1501], + &s_operands[1517], 2, }, { SpirvOp::OpSubgroupImageBlockReadINTEL, R"(OpSubgroupImageBlockReadINTEL)", - &s_operands[1503], + &s_operands[1519], 4, }, { SpirvOp::OpSubgroupImageBlockWriteINTEL, R"(OpSubgroupImageBlockWriteINTEL)", - &s_operands[1507], + &s_operands[1523], 3, }, { SpirvOp::OpSubgroupImageMediaBlockReadINTEL, R"(OpSubgroupImageMediaBlockReadINTEL)", - &s_operands[1510], + &s_operands[1526], 6, }, { SpirvOp::OpSubgroupImageMediaBlockWriteINTEL, R"(OpSubgroupImageMediaBlockWriteINTEL)", - &s_operands[1516], + &s_operands[1532], 5, }, { SpirvOp::OpUCountLeadingZerosINTEL, R"(OpUCountLeadingZerosINTEL)", - &s_operands[1521], + &s_operands[1537], 3, }, { SpirvOp::OpUCountTrailingZerosINTEL, R"(OpUCountTrailingZerosINTEL)", - &s_operands[1524], + &s_operands[1540], 3, }, { SpirvOp::OpAbsISubINTEL, R"(OpAbsISubINTEL)", - &s_operands[1527], + &s_operands[1543], 4, }, { SpirvOp::OpAbsUSubINTEL, R"(OpAbsUSubINTEL)", - &s_operands[1531], + &s_operands[1547], 4, }, { SpirvOp::OpIAddSatINTEL, R"(OpIAddSatINTEL)", - &s_operands[1535], + &s_operands[1551], 4, }, { SpirvOp::OpUAddSatINTEL, R"(OpUAddSatINTEL)", - &s_operands[1539], + &s_operands[1555], 4, }, { SpirvOp::OpIAverageINTEL, R"(OpIAverageINTEL)", - &s_operands[1543], + &s_operands[1559], 4, }, { SpirvOp::OpUAverageINTEL, R"(OpUAverageINTEL)", - &s_operands[1547], + &s_operands[1563], 4, }, { SpirvOp::OpIAverageRoundedINTEL, R"(OpIAverageRoundedINTEL)", - &s_operands[1551], + &s_operands[1567], 4, }, { SpirvOp::OpUAverageRoundedINTEL, R"(OpUAverageRoundedINTEL)", - &s_operands[1555], + &s_operands[1571], 4, }, { SpirvOp::OpISubSatINTEL, R"(OpISubSatINTEL)", - &s_operands[1559], + &s_operands[1575], 4, }, { SpirvOp::OpUSubSatINTEL, R"(OpUSubSatINTEL)", - &s_operands[1563], + &s_operands[1579], 4, }, { SpirvOp::OpIMul32x16INTEL, R"(OpIMul32x16INTEL)", - &s_operands[1567], + &s_operands[1583], 4, }, { SpirvOp::OpUMul32x16INTEL, R"(OpUMul32x16INTEL)", - &s_operands[1571], + &s_operands[1587], 4, }, { - SpirvOp::OpFunctionPointerINTEL, - R"(OpFunctionPointerINTEL)", - &s_operands[1575], + SpirvOp::OpConstFunctionPointerINTEL, + R"(OpConstFunctionPointerINTEL)", + &s_operands[1591], 3, }, { SpirvOp::OpFunctionPointerCallINTEL, R"(OpFunctionPointerCallINTEL)", - &s_operands[1578], + &s_operands[1594], 3, }, + { + SpirvOp::OpAsmTargetINTEL, + R"(OpAsmTargetINTEL)", + &s_operands[1597], + 3, + }, + { + SpirvOp::OpAsmINTEL, + R"(OpAsmINTEL)", + &s_operands[1600], + 6, + }, + { + SpirvOp::OpAsmCallINTEL, + R"(OpAsmCallINTEL)", + &s_operands[1606], + 4, + }, + { + SpirvOp::OpAtomicFMinEXT, + R"(OpAtomicFMinEXT)", + &s_operands[1610], + 6, + }, + { + SpirvOp::OpAtomicFMaxEXT, + R"(OpAtomicFMaxEXT)", + &s_operands[1616], + 6, + }, { SpirvOp::OpDecorateStringGOOGLE, R"(OpDecorateStringGOOGLE)", - &s_operands[1581], + &s_operands[1622], 2, }, { SpirvOp::OpMemberDecorateStringGOOGLE, R"(OpMemberDecorateStringGOOGLE)", - &s_operands[1583], + &s_operands[1624], 3, }, { SpirvOp::OpVmeImageINTEL, R"(OpVmeImageINTEL)", - &s_operands[1586], + &s_operands[1627], 4, }, { SpirvOp::OpTypeVmeImageINTEL, R"(OpTypeVmeImageINTEL)", - &s_operands[1590], + &s_operands[1631], 2, }, { SpirvOp::OpTypeAvcImePayloadINTEL, R"(OpTypeAvcImePayloadINTEL)", - &s_operands[1592], + &s_operands[1633], 1, }, { SpirvOp::OpTypeAvcRefPayloadINTEL, R"(OpTypeAvcRefPayloadINTEL)", - &s_operands[1593], + &s_operands[1634], 1, }, { SpirvOp::OpTypeAvcSicPayloadINTEL, R"(OpTypeAvcSicPayloadINTEL)", - &s_operands[1594], + &s_operands[1635], 1, }, { SpirvOp::OpTypeAvcMcePayloadINTEL, R"(OpTypeAvcMcePayloadINTEL)", - &s_operands[1595], + &s_operands[1636], 1, }, { SpirvOp::OpTypeAvcMceResultINTEL, R"(OpTypeAvcMceResultINTEL)", - &s_operands[1596], + &s_operands[1637], 1, }, { SpirvOp::OpTypeAvcImeResultINTEL, R"(OpTypeAvcImeResultINTEL)", - &s_operands[1597], + &s_operands[1638], 1, }, { SpirvOp::OpTypeAvcImeResultSingleReferenceStreamoutINTEL, R"(OpTypeAvcImeResultSingleReferenceStreamoutINTEL)", - &s_operands[1598], + &s_operands[1639], 1, }, { SpirvOp::OpTypeAvcImeResultDualReferenceStreamoutINTEL, R"(OpTypeAvcImeResultDualReferenceStreamoutINTEL)", - &s_operands[1599], + &s_operands[1640], 1, }, { SpirvOp::OpTypeAvcImeSingleReferenceStreaminINTEL, R"(OpTypeAvcImeSingleReferenceStreaminINTEL)", - &s_operands[1600], + &s_operands[1641], 1, }, { SpirvOp::OpTypeAvcImeDualReferenceStreaminINTEL, R"(OpTypeAvcImeDualReferenceStreaminINTEL)", - &s_operands[1601], + &s_operands[1642], 1, }, { SpirvOp::OpTypeAvcRefResultINTEL, R"(OpTypeAvcRefResultINTEL)", - &s_operands[1602], + &s_operands[1643], 1, }, { SpirvOp::OpTypeAvcSicResultINTEL, R"(OpTypeAvcSicResultINTEL)", - &s_operands[1603], + &s_operands[1644], 1, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL)", - &s_operands[1604], + &s_operands[1645], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL, R"(OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL)", - &s_operands[1608], + &s_operands[1649], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL)", - &s_operands[1612], + &s_operands[1653], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterShapePenaltyINTEL, R"(OpSubgroupAvcMceSetInterShapePenaltyINTEL)", - &s_operands[1616], + &s_operands[1657], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL)", - &s_operands[1620], + &s_operands[1661], 4, }, { SpirvOp::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL, R"(OpSubgroupAvcMceSetInterDirectionPenaltyINTEL)", - &s_operands[1624], + &s_operands[1665], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL)", - &s_operands[1628], + &s_operands[1669], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL)", - &s_operands[1632], + &s_operands[1673], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL)", - &s_operands[1636], + &s_operands[1677], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL)", - &s_operands[1638], + &s_operands[1679], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL, R"(OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL)", - &s_operands[1640], + &s_operands[1681], 2, }, { SpirvOp::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL, R"(OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL)", - &s_operands[1642], + &s_operands[1683], 6, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL)", - &s_operands[1648], + &s_operands[1689], 4, }, { SpirvOp::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL)", - &s_operands[1652], + &s_operands[1693], 2, }, { SpirvOp::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL, R"(OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL)", - &s_operands[1654], + &s_operands[1695], 2, }, { SpirvOp::OpSubgroupAvcMceSetAcOnlyHaarINTEL, R"(OpSubgroupAvcMceSetAcOnlyHaarINTEL)", - &s_operands[1656], + &s_operands[1697], 3, }, { SpirvOp::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL, R"(OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL)", - &s_operands[1659], + &s_operands[1700], 4, }, { SpirvOp::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL, R"(OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL)", - &s_operands[1663], + &s_operands[1704], 4, }, { SpirvOp::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL, R"(OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL)", - &s_operands[1667], + &s_operands[1708], 5, }, { SpirvOp::OpSubgroupAvcMceConvertToImePayloadINTEL, R"(OpSubgroupAvcMceConvertToImePayloadINTEL)", - &s_operands[1672], + &s_operands[1713], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToImeResultINTEL, R"(OpSubgroupAvcMceConvertToImeResultINTEL)", - &s_operands[1675], + &s_operands[1716], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToRefPayloadINTEL, R"(OpSubgroupAvcMceConvertToRefPayloadINTEL)", - &s_operands[1678], + &s_operands[1719], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToRefResultINTEL, R"(OpSubgroupAvcMceConvertToRefResultINTEL)", - &s_operands[1681], + &s_operands[1722], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToSicPayloadINTEL, R"(OpSubgroupAvcMceConvertToSicPayloadINTEL)", - &s_operands[1684], + &s_operands[1725], 3, }, { SpirvOp::OpSubgroupAvcMceConvertToSicResultINTEL, R"(OpSubgroupAvcMceConvertToSicResultINTEL)", - &s_operands[1687], + &s_operands[1728], 3, }, { SpirvOp::OpSubgroupAvcMceGetMotionVectorsINTEL, R"(OpSubgroupAvcMceGetMotionVectorsINTEL)", - &s_operands[1690], + &s_operands[1731], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterDistortionsINTEL, R"(OpSubgroupAvcMceGetInterDistortionsINTEL)", - &s_operands[1693], + &s_operands[1734], 3, }, { SpirvOp::OpSubgroupAvcMceGetBestInterDistortionsINTEL, R"(OpSubgroupAvcMceGetBestInterDistortionsINTEL)", - &s_operands[1696], + &s_operands[1737], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMajorShapeINTEL, R"(OpSubgroupAvcMceGetInterMajorShapeINTEL)", - &s_operands[1699], + &s_operands[1740], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMinorShapeINTEL, R"(OpSubgroupAvcMceGetInterMinorShapeINTEL)", - &s_operands[1702], + &s_operands[1743], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterDirectionsINTEL, R"(OpSubgroupAvcMceGetInterDirectionsINTEL)", - &s_operands[1705], + &s_operands[1746], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterMotionVectorCountINTEL, R"(OpSubgroupAvcMceGetInterMotionVectorCountINTEL)", - &s_operands[1708], + &s_operands[1749], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterReferenceIdsINTEL, R"(OpSubgroupAvcMceGetInterReferenceIdsINTEL)", - &s_operands[1711], + &s_operands[1752], 3, }, { SpirvOp::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL, R"(OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL)", - &s_operands[1714], + &s_operands[1755], 5, }, { SpirvOp::OpSubgroupAvcImeInitializeINTEL, R"(OpSubgroupAvcImeInitializeINTEL)", - &s_operands[1719], + &s_operands[1760], 5, }, { SpirvOp::OpSubgroupAvcImeSetSingleReferenceINTEL, R"(OpSubgroupAvcImeSetSingleReferenceINTEL)", - &s_operands[1724], + &s_operands[1765], 5, }, { SpirvOp::OpSubgroupAvcImeSetDualReferenceINTEL, R"(OpSubgroupAvcImeSetDualReferenceINTEL)", - &s_operands[1729], + &s_operands[1770], 6, }, { SpirvOp::OpSubgroupAvcImeRefWindowSizeINTEL, R"(OpSubgroupAvcImeRefWindowSizeINTEL)", - &s_operands[1735], + &s_operands[1776], 4, }, { SpirvOp::OpSubgroupAvcImeAdjustRefOffsetINTEL, R"(OpSubgroupAvcImeAdjustRefOffsetINTEL)", - &s_operands[1739], + &s_operands[1780], 6, }, { SpirvOp::OpSubgroupAvcImeConvertToMcePayloadINTEL, R"(OpSubgroupAvcImeConvertToMcePayloadINTEL)", - &s_operands[1745], + &s_operands[1786], 3, }, { SpirvOp::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL, R"(OpSubgroupAvcImeSetMaxMotionVectorCountINTEL)", - &s_operands[1748], + &s_operands[1789], 4, }, { SpirvOp::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL, R"(OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL)", - &s_operands[1752], + &s_operands[1793], 3, }, { SpirvOp::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL, R"(OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL)", - &s_operands[1755], + &s_operands[1796], 4, }, { SpirvOp::OpSubgroupAvcImeSetWeightedSadINTEL, R"(OpSubgroupAvcImeSetWeightedSadINTEL)", - &s_operands[1759], + &s_operands[1800], 4, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL)", - &s_operands[1763], + &s_operands[1804], 5, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceINTEL)", - &s_operands[1768], + &s_operands[1809], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL)", - &s_operands[1774], + &s_operands[1815], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL)", - &s_operands[1780], + &s_operands[1821], 7, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL)", - &s_operands[1787], + &s_operands[1828], 5, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL)", - &s_operands[1792], + &s_operands[1833], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL, R"(OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL)", - &s_operands[1798], + &s_operands[1839], 6, }, { SpirvOp::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL, R"(OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL)", - &s_operands[1804], + &s_operands[1845], 7, }, { SpirvOp::OpSubgroupAvcImeConvertToMceResultINTEL, R"(OpSubgroupAvcImeConvertToMceResultINTEL)", - &s_operands[1811], + &s_operands[1852], 3, }, { SpirvOp::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL, R"(OpSubgroupAvcImeGetSingleReferenceStreaminINTEL)", - &s_operands[1814], + &s_operands[1855], 3, }, { SpirvOp::OpSubgroupAvcImeGetDualReferenceStreaminINTEL, R"(OpSubgroupAvcImeGetDualReferenceStreaminINTEL)", - &s_operands[1817], + &s_operands[1858], 3, }, { SpirvOp::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL, R"(OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL)", - &s_operands[1820], + &s_operands[1861], 3, }, { SpirvOp::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL, R"(OpSubgroupAvcImeStripDualReferenceStreamoutINTEL)", - &s_operands[1823], + &s_operands[1864], 3, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL)", - &s_operands[1826], + &s_operands[1867], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL)", - &s_operands[1830], + &s_operands[1871], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL, R"(OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL)", - &s_operands[1834], + &s_operands[1875], 4, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL)", - &s_operands[1838], + &s_operands[1879], 5, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL)", - &s_operands[1843], + &s_operands[1884], 5, }, { SpirvOp::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL, R"(OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL)", - &s_operands[1848], + &s_operands[1889], 5, }, { SpirvOp::OpSubgroupAvcImeGetBorderReachedINTEL, R"(OpSubgroupAvcImeGetBorderReachedINTEL)", - &s_operands[1853], + &s_operands[1894], 4, }, { SpirvOp::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL, R"(OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL)", - &s_operands[1857], + &s_operands[1898], 3, }, { SpirvOp::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL, R"(OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL)", - &s_operands[1860], + &s_operands[1901], 3, }, { SpirvOp::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL, R"(OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL)", - &s_operands[1863], + &s_operands[1904], 3, }, { SpirvOp::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL, R"(OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL)", - &s_operands[1866], + &s_operands[1907], 3, }, { SpirvOp::OpSubgroupAvcFmeInitializeINTEL, R"(OpSubgroupAvcFmeInitializeINTEL)", - &s_operands[1869], + &s_operands[1910], 9, }, { SpirvOp::OpSubgroupAvcBmeInitializeINTEL, R"(OpSubgroupAvcBmeInitializeINTEL)", - &s_operands[1878], + &s_operands[1919], 10, }, { SpirvOp::OpSubgroupAvcRefConvertToMcePayloadINTEL, R"(OpSubgroupAvcRefConvertToMcePayloadINTEL)", - &s_operands[1888], + &s_operands[1929], 3, }, { SpirvOp::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL, R"(OpSubgroupAvcRefSetBidirectionalMixDisableINTEL)", - &s_operands[1891], + &s_operands[1932], 3, }, { SpirvOp::OpSubgroupAvcRefSetBilinearFilterEnableINTEL, R"(OpSubgroupAvcRefSetBilinearFilterEnableINTEL)", - &s_operands[1894], + &s_operands[1935], 3, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL)", - &s_operands[1897], + &s_operands[1938], 5, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithDualReferenceINTEL)", - &s_operands[1902], + &s_operands[1943], 6, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL, R"(OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL)", - &s_operands[1908], + &s_operands[1949], 5, }, { SpirvOp::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL, R"(OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL)", - &s_operands[1913], + &s_operands[1954], 6, }, { SpirvOp::OpSubgroupAvcRefConvertToMceResultINTEL, R"(OpSubgroupAvcRefConvertToMceResultINTEL)", - &s_operands[1919], + &s_operands[1960], 3, }, { SpirvOp::OpSubgroupAvcSicInitializeINTEL, R"(OpSubgroupAvcSicInitializeINTEL)", - &s_operands[1922], + &s_operands[1963], 3, }, { SpirvOp::OpSubgroupAvcSicConfigureSkcINTEL, R"(OpSubgroupAvcSicConfigureSkcINTEL)", - &s_operands[1925], + &s_operands[1966], 8, }, { SpirvOp::OpSubgroupAvcSicConfigureIpeLumaINTEL, R"(OpSubgroupAvcSicConfigureIpeLumaINTEL)", - &s_operands[1933], + &s_operands[1974], 10, }, { SpirvOp::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL, R"(OpSubgroupAvcSicConfigureIpeLumaChromaINTEL)", - &s_operands[1943], + &s_operands[1984], 13, }, { SpirvOp::OpSubgroupAvcSicGetMotionVectorMaskINTEL, R"(OpSubgroupAvcSicGetMotionVectorMaskINTEL)", - &s_operands[1956], + &s_operands[1997], 4, }, { SpirvOp::OpSubgroupAvcSicConvertToMcePayloadINTEL, R"(OpSubgroupAvcSicConvertToMcePayloadINTEL)", - &s_operands[1960], + &s_operands[2001], 3, }, { SpirvOp::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL, R"(OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL)", - &s_operands[1963], + &s_operands[2004], 4, }, { SpirvOp::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL, R"(OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL)", - &s_operands[1967], + &s_operands[2008], 6, }, { SpirvOp::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL, R"(OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL)", - &s_operands[1973], + &s_operands[2014], 4, }, { SpirvOp::OpSubgroupAvcSicSetBilinearFilterEnableINTEL, R"(OpSubgroupAvcSicSetBilinearFilterEnableINTEL)", - &s_operands[1977], + &s_operands[2018], 3, }, { SpirvOp::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL, R"(OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL)", - &s_operands[1980], + &s_operands[2021], 4, }, { SpirvOp::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL, R"(OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL)", - &s_operands[1984], + &s_operands[2025], 4, }, { SpirvOp::OpSubgroupAvcSicEvaluateIpeINTEL, R"(OpSubgroupAvcSicEvaluateIpeINTEL)", - &s_operands[1988], + &s_operands[2029], 4, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL)", - &s_operands[1992], + &s_operands[2033], 5, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithDualReferenceINTEL)", - &s_operands[1997], + &s_operands[2038], 6, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL, R"(OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL)", - &s_operands[2003], + &s_operands[2044], 5, }, { SpirvOp::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL, R"(OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL)", - &s_operands[2008], + &s_operands[2049], 6, }, { SpirvOp::OpSubgroupAvcSicConvertToMceResultINTEL, R"(OpSubgroupAvcSicConvertToMceResultINTEL)", - &s_operands[2014], + &s_operands[2055], 3, }, { SpirvOp::OpSubgroupAvcSicGetIpeLumaShapeINTEL, R"(OpSubgroupAvcSicGetIpeLumaShapeINTEL)", - &s_operands[2017], + &s_operands[2058], 3, }, { SpirvOp::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL, R"(OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL)", - &s_operands[2020], + &s_operands[2061], 3, }, { SpirvOp::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL, R"(OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL)", - &s_operands[2023], + &s_operands[2064], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL, R"(OpSubgroupAvcSicGetPackedIpeLumaModesINTEL)", - &s_operands[2026], + &s_operands[2067], 3, }, { SpirvOp::OpSubgroupAvcSicGetIpeChromaModeINTEL, R"(OpSubgroupAvcSicGetIpeChromaModeINTEL)", - &s_operands[2029], + &s_operands[2070], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL, R"(OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL)", - &s_operands[2032], + &s_operands[2073], 3, }, { SpirvOp::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL, R"(OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL)", - &s_operands[2035], + &s_operands[2076], 3, }, { SpirvOp::OpSubgroupAvcSicGetInterRawSadsINTEL, R"(OpSubgroupAvcSicGetInterRawSadsINTEL)", - &s_operands[2038], + &s_operands[2079], 3, }, + { + SpirvOp::OpVariableLengthArrayINTEL, + R"(OpVariableLengthArrayINTEL)", + &s_operands[2082], + 3, + }, + { + SpirvOp::OpSaveMemoryINTEL, + R"(OpSaveMemoryINTEL)", + &s_operands[2085], + 2, + }, + { + SpirvOp::OpRestoreMemoryINTEL, + R"(OpRestoreMemoryINTEL)", + &s_operands[2087], + 1, + }, { SpirvOp::OpLoopControlINTEL, R"(OpLoopControlINTEL)", - &s_operands[2041], + &s_operands[2088], 1, }, + { + SpirvOp::OpPtrCastToCrossWorkgroupINTEL, + R"(OpPtrCastToCrossWorkgroupINTEL)", + &s_operands[2089], + 3, + }, + { + SpirvOp::OpCrossWorkgroupCastToPtrINTEL, + R"(OpCrossWorkgroupCastToPtrINTEL)", + &s_operands[2092], + 3, + }, { SpirvOp::OpReadPipeBlockingINTEL, R"(OpReadPipeBlockingINTEL)", - &s_operands[2042], + &s_operands[2095], 4, }, { SpirvOp::OpWritePipeBlockingINTEL, R"(OpWritePipeBlockingINTEL)", - &s_operands[2046], + &s_operands[2099], 4, }, { SpirvOp::OpFPGARegINTEL, R"(OpFPGARegINTEL)", - &s_operands[2050], + &s_operands[2103], 4, }, { SpirvOp::OpRayQueryGetRayTMinKHR, R"(OpRayQueryGetRayTMinKHR)", - &s_operands[2054], + &s_operands[2107], 3, }, { SpirvOp::OpRayQueryGetRayFlagsKHR, R"(OpRayQueryGetRayFlagsKHR)", - &s_operands[2057], + &s_operands[2110], 3, }, { SpirvOp::OpRayQueryGetIntersectionTKHR, R"(OpRayQueryGetIntersectionTKHR)", - &s_operands[2060], + &s_operands[2113], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceCustomIndexKHR, R"(OpRayQueryGetIntersectionInstanceCustomIndexKHR)", - &s_operands[2064], + &s_operands[2117], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceIdKHR, R"(OpRayQueryGetIntersectionInstanceIdKHR)", - &s_operands[2068], + &s_operands[2121], 4, }, { SpirvOp::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR, R"(OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)", - &s_operands[2072], + &s_operands[2125], 4, }, { SpirvOp::OpRayQueryGetIntersectionGeometryIndexKHR, R"(OpRayQueryGetIntersectionGeometryIndexKHR)", - &s_operands[2076], + &s_operands[2129], 4, }, { SpirvOp::OpRayQueryGetIntersectionPrimitiveIndexKHR, R"(OpRayQueryGetIntersectionPrimitiveIndexKHR)", - &s_operands[2080], + &s_operands[2133], 4, }, { SpirvOp::OpRayQueryGetIntersectionBarycentricsKHR, R"(OpRayQueryGetIntersectionBarycentricsKHR)", - &s_operands[2084], + &s_operands[2137], 4, }, { SpirvOp::OpRayQueryGetIntersectionFrontFaceKHR, R"(OpRayQueryGetIntersectionFrontFaceKHR)", - &s_operands[2088], + &s_operands[2141], 4, }, { SpirvOp::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR, R"(OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)", - &s_operands[2092], + &s_operands[2145], 3, }, { SpirvOp::OpRayQueryGetIntersectionObjectRayDirectionKHR, R"(OpRayQueryGetIntersectionObjectRayDirectionKHR)", - &s_operands[2095], + &s_operands[2148], 4, }, { SpirvOp::OpRayQueryGetIntersectionObjectRayOriginKHR, R"(OpRayQueryGetIntersectionObjectRayOriginKHR)", - &s_operands[2099], + &s_operands[2152], 4, }, { SpirvOp::OpRayQueryGetWorldRayDirectionKHR, R"(OpRayQueryGetWorldRayDirectionKHR)", - &s_operands[2103], + &s_operands[2156], 3, }, { SpirvOp::OpRayQueryGetWorldRayOriginKHR, R"(OpRayQueryGetWorldRayOriginKHR)", - &s_operands[2106], + &s_operands[2159], 3, }, { SpirvOp::OpRayQueryGetIntersectionObjectToWorldKHR, R"(OpRayQueryGetIntersectionObjectToWorldKHR)", - &s_operands[2109], + &s_operands[2162], 4, }, { SpirvOp::OpRayQueryGetIntersectionWorldToObjectKHR, R"(OpRayQueryGetIntersectionWorldToObjectKHR)", - &s_operands[2113], + &s_operands[2166], 4, }, { SpirvOp::OpAtomicFAddEXT, R"(OpAtomicFAddEXT)", - &s_operands[2117], + &s_operands[2170], 6, }, + { + SpirvOp::OpTypeBufferSurfaceINTEL, + R"(OpTypeBufferSurfaceINTEL)", + &s_operands[2176], + 1, + }, + { + SpirvOp::OpTypeStructContinuedINTEL, + R"(OpTypeStructContinuedINTEL)", + &s_operands[2177], + 1, + }, + { + SpirvOp::OpConstantCompositeContinuedINTEL, + R"(OpConstantCompositeContinuedINTEL)", + &s_operands[2178], + 1, + }, + { + SpirvOp::OpSpecConstantCompositeContinuedINTEL, + R"(OpSpecConstantCompositeContinuedINTEL)", + &s_operands[2179], + 1, + }, } };