CoCalc -- doc.cpp

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/glslang/SPIRV/doc.cpp
²¹⁰⁵² views
1
//
2
// Copyright (C) 2014-2015 LunarG, Inc.
3
// Copyright (C) 2022-2025 Arm Limited.
4
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
5
//
6
// All rights reserved.
7
//
8
// Redistribution and use in source and binary forms, with or without
9
// modification, are permitted provided that the following conditions
10
// are met:
11
//
12
//    Redistributions of source code must retain the above copyright
13
//    notice, this list of conditions and the following disclaimer.
14
//
15
//    Redistributions in binary form must reproduce the above
16
//    copyright notice, this list of conditions and the following
17
//    disclaimer in the documentation and/or other materials provided
18
//    with the distribution.
19
//
20
//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
21
//    contributors may be used to endorse or promote products derived
22
//    from this software without specific prior written permission.
23
//
24
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35
// POSSIBILITY OF SUCH DAMAGE.
36

37
//
38
// 1) Programmatically fill in instruction/operand information.
39
//    This can be used for disassembly, printing documentation, etc.
40
//
41
// 2) Print documentation from this parameterization.
42
//
43

44
#include "doc.h"
45
#include "spvUtil.h"
46

47
#include <cstdio>
48
#include <cstring>
49
#include <algorithm>
50
#include <mutex>
51

52
namespace spv {
53
    extern "C" {
54
        // Include C-based headers that don't have a namespace
55
        #include "GLSL.ext.KHR.h"
56
        #include "GLSL.ext.EXT.h"
57
        #include "GLSL.ext.AMD.h"
58
        #include "GLSL.ext.NV.h"
59
        #include "GLSL.ext.ARM.h"
60
        #include "GLSL.ext.QCOM.h"
61
    }
62
}
63

64
namespace spv {
65

66
//
67
// Whole set of functions that translate enumerants to their text strings for
68
// the specification (or their sanitized versions for auto-generating the
69
// spirv headers.
70
//
71
// Also, for masks the ceilings are declared next to these, to help keep them in sync.
72
// Ceilings should be
73
//  - one more than the maximum value an enumerant takes on, for non-mask enumerants
74
//    (for non-sparse enums, this is the number of enumerants)
75
//  - the number of bits consumed by the set of masks
76
//    (for non-sparse mask enums, this is the number of enumerants)
77
//
78

79
const char* SourceString(int source)
80
{
81
    switch (source) {
82
    case 0:  return "Unknown";
83
    case 1:  return "ESSL";
84
    case 2:  return "GLSL";
85
    case 3:  return "OpenCL_C";
86
    case 4:  return "OpenCL_CPP";
87
    case 5:  return "HLSL";
88

89
    default: return "Bad";
90
    }
91
}
92

93
const char* ExecutionModelString(int model)
94
{
95
    switch (model) {
96
    case 0:  return "Vertex";
97
    case 1:  return "TessellationControl";
98
    case 2:  return "TessellationEvaluation";
99
    case 3:  return "Geometry";
100
    case 4:  return "Fragment";
101
    case 5:  return "GLCompute";
102
    case 6:  return "Kernel";
103
    case (int)ExecutionModel::TaskNV: return "TaskNV";
104
    case (int)ExecutionModel::MeshNV: return "MeshNV";
105
    case (int)ExecutionModel::TaskEXT: return "TaskEXT";
106
    case (int)ExecutionModel::MeshEXT: return "MeshEXT";
107

108
    default: return "Bad";
109

110
    case (int)ExecutionModel::RayGenerationKHR: return "RayGenerationKHR";
111
    case (int)ExecutionModel::IntersectionKHR:  return "IntersectionKHR";
112
    case (int)ExecutionModel::AnyHitKHR:        return "AnyHitKHR";
113
    case (int)ExecutionModel::ClosestHitKHR:    return "ClosestHitKHR";
114
    case (int)ExecutionModel::MissKHR:          return "MissKHR";
115
    case (int)ExecutionModel::CallableKHR:      return "CallableKHR";
116
    }
117
}
118

119
const char* AddressingString(int addr)
120
{
121
    switch (addr) {
122
    case 0:  return "Logical";
123
    case 1:  return "Physical32";
124
    case 2:  return "Physical64";
125

126
    case (int)AddressingModel::PhysicalStorageBuffer64EXT: return "PhysicalStorageBuffer64EXT";
127

128
    default: return "Bad";
129
    }
130
}
131

132
const char* MemoryString(int mem)
133
{
134
    switch (mem) {
135
    case (int)MemoryModel::Simple:     return "Simple";
136
    case (int)MemoryModel::GLSL450:    return "GLSL450";
137
    case (int)MemoryModel::OpenCL:     return "OpenCL";
138
    case (int)MemoryModel::VulkanKHR:  return "VulkanKHR";
139

140
    default: return "Bad";
141
    }
142
}
143

144
const int ExecutionModeCeiling = 40;
145

146
const char* ExecutionModeString(int mode)
147
{
148
    switch (mode) {
149
    case 0:  return "Invocations";
150
    case 1:  return "SpacingEqual";
151
    case 2:  return "SpacingFractionalEven";
152
    case 3:  return "SpacingFractionalOdd";
153
    case 4:  return "VertexOrderCw";
154
    case 5:  return "VertexOrderCcw";
155
    case 6:  return "PixelCenterInteger";
156
    case 7:  return "OriginUpperLeft";
157
    case 8:  return "OriginLowerLeft";
158
    case 9:  return "EarlyFragmentTests";
159
    case 10: return "PointMode";
160
    case 11: return "Xfb";
161
    case 12: return "DepthReplacing";
162
    case 13: return "Bad";
163
    case 14: return "DepthGreater";
164
    case 15: return "DepthLess";
165
    case 16: return "DepthUnchanged";
166
    case 17: return "LocalSize";
167
    case 18: return "LocalSizeHint";
168
    case 19: return "InputPoints";
169
    case 20: return "InputLines";
170
    case 21: return "InputLinesAdjacency";
171
    case 22: return "Triangles";
172
    case 23: return "InputTrianglesAdjacency";
173
    case 24: return "Quads";
174
    case 25: return "Isolines";
175
    case 26: return "OutputVertices";
176
    case 27: return "OutputPoints";
177
    case 28: return "OutputLineStrip";
178
    case 29: return "OutputTriangleStrip";
179
    case 30: return "VecTypeHint";
180
    case 31: return "ContractionOff";
181
    case 32: return "Bad";
182

183
    case (int)ExecutionMode::Initializer:                   return "Initializer";
184
    case (int)ExecutionMode::Finalizer:                     return "Finalizer";
185
    case (int)ExecutionMode::SubgroupSize:                  return "SubgroupSize";
186
    case (int)ExecutionMode::SubgroupsPerWorkgroup:         return "SubgroupsPerWorkgroup";
187
    case (int)ExecutionMode::SubgroupsPerWorkgroupId:       return "SubgroupsPerWorkgroupId";
188
    case (int)ExecutionMode::LocalSizeId:                   return "LocalSizeId";
189
    case (int)ExecutionMode::LocalSizeHintId:               return "LocalSizeHintId";
190

191
    case (int)ExecutionMode::PostDepthCoverage:             return "PostDepthCoverage";
192
    case (int)ExecutionMode::DenormPreserve:                return "DenormPreserve";
193
    case (int)ExecutionMode::DenormFlushToZero:             return "DenormFlushToZero";
194
    case (int)ExecutionMode::SignedZeroInfNanPreserve:      return "SignedZeroInfNanPreserve";
195
    case (int)ExecutionMode::RoundingModeRTE:               return "RoundingModeRTE";
196
    case (int)ExecutionMode::RoundingModeRTZ:               return "RoundingModeRTZ";
197

198
    case (int)ExecutionMode::NonCoherentTileAttachmentReadQCOM: return "NonCoherentTileAttachmentReadQCOM";
199
    case (int)ExecutionMode::TileShadingRateQCOM:               return "TileShadingRateQCOM";
200

201
    case (int)ExecutionMode::EarlyAndLateFragmentTestsAMD:  return "EarlyAndLateFragmentTestsAMD";
202
    case (int)ExecutionMode::StencilRefUnchangedFrontAMD:   return "StencilRefUnchangedFrontAMD";
203
    case (int)ExecutionMode::StencilRefLessFrontAMD:        return "StencilRefLessFrontAMD";
204
    case (int)ExecutionMode::StencilRefGreaterBackAMD:      return "StencilRefGreaterBackAMD";
205
    case (int)ExecutionMode::StencilRefReplacingEXT:        return "StencilRefReplacingEXT";
206
    case (int)ExecutionMode::SubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
207
    case (int)ExecutionMode::MaximallyReconvergesKHR:       return "MaximallyReconverges";
208

209
    case (int)ExecutionMode::OutputLinesNV:                 return "OutputLinesNV";
210
    case (int)ExecutionMode::OutputPrimitivesNV:            return "OutputPrimitivesNV";
211
    case (int)ExecutionMode::OutputTrianglesNV:             return "OutputTrianglesNV";
212
    case (int)ExecutionMode::DerivativeGroupQuadsNV:        return "DerivativeGroupQuadsNV";
213
    case (int)ExecutionMode::DerivativeGroupLinearNV:       return "DerivativeGroupLinearNV";
214

215
    case (int)ExecutionMode::PixelInterlockOrderedEXT:         return "PixelInterlockOrderedEXT";
216
    case (int)ExecutionMode::PixelInterlockUnorderedEXT:       return "PixelInterlockUnorderedEXT";
217
    case (int)ExecutionMode::SampleInterlockOrderedEXT:        return "SampleInterlockOrderedEXT";
218
    case (int)ExecutionMode::SampleInterlockUnorderedEXT:      return "SampleInterlockUnorderedEXT";
219
    case (int)ExecutionMode::ShadingRateInterlockOrderedEXT:   return "ShadingRateInterlockOrderedEXT";
220
    case (int)ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
221

222
    case (int)ExecutionMode::MaxWorkgroupSizeINTEL:    return "MaxWorkgroupSizeINTEL";
223
    case (int)ExecutionMode::MaxWorkDimINTEL:          return "MaxWorkDimINTEL";
224
    case (int)ExecutionMode::NoGlobalOffsetINTEL:      return "NoGlobalOffsetINTEL";
225
    case (int)ExecutionMode::NumSIMDWorkitemsINTEL:    return "NumSIMDWorkitemsINTEL";
226

227
    case (int)ExecutionMode::RequireFullQuadsKHR:      return "RequireFullQuadsKHR";
228
    case (int)ExecutionMode::QuadDerivativesKHR:       return "QuadDerivativesKHR";
229

230
    case (int)ExecutionMode::NonCoherentColorAttachmentReadEXT:        return "NonCoherentColorAttachmentReadEXT";
231
    case (int)ExecutionMode::NonCoherentDepthAttachmentReadEXT:        return "NonCoherentDepthAttachmentReadEXT";
232
    case (int)ExecutionMode::NonCoherentStencilAttachmentReadEXT:      return "NonCoherentStencilAttachmentReadEXT";
233

234
    case (int)ExecutionMode::Shader64BitIndexingEXT:                   return "Shader64BitIndexingEXT";
235

236
    case ExecutionModeCeiling:
237
    default: return "Bad";
238
    }
239
}
240

241
const char* StorageClassString(int StorageClass)
242
{
243
    switch (StorageClass) {
244
    case 0:  return "UniformConstant";
245
    case 1:  return "Input";
246
    case 2:  return "Uniform";
247
    case 3:  return "Output";
248
    case 4:  return "Workgroup";
249
    case 5:  return "CrossWorkgroup";
250
    case 6:  return "Private";
251
    case 7:  return "Function";
252
    case 8:  return "Generic";
253
    case 9:  return "PushConstant";
254
    case 10: return "AtomicCounter";
255
    case 11: return "Image";
256
    case 12: return "StorageBuffer";
257

258
    case (int)StorageClass::TileAttachmentQCOM:       return "TileAttachmentQCOM";
259
    case (int)StorageClass::RayPayloadKHR:            return "RayPayloadKHR";
260
    case (int)StorageClass::HitAttributeKHR:          return "HitAttributeKHR";
261
    case (int)StorageClass::IncomingRayPayloadKHR:    return "IncomingRayPayloadKHR";
262
    case (int)StorageClass::ShaderRecordBufferKHR:    return "ShaderRecordBufferKHR";
263
    case (int)StorageClass::CallableDataKHR:          return "CallableDataKHR";
264
    case (int)StorageClass::IncomingCallableDataKHR:  return "IncomingCallableDataKHR";
265

266
    case (int)StorageClass::PhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
267
    case (int)StorageClass::TaskPayloadWorkgroupEXT:  return "TaskPayloadWorkgroupEXT";
268
    case (int)StorageClass::HitObjectAttributeNV:     return "HitObjectAttributeNV";
269
    case (int)StorageClass::TileImageEXT:             return "TileImageEXT";
270
    case (int)StorageClass::HitObjectAttributeEXT:    return "HitObjectAttributeEXT";
271
    default: return "Bad";
272
    }
273
}
274

275
const int DecorationCeiling = 45;
276

277
const char* DecorationString(int decoration)
278
{
279
    switch (decoration) {
280
    case 0:  return "RelaxedPrecision";
281
    case 1:  return "SpecId";
282
    case 2:  return "Block";
283
    case 3:  return "BufferBlock";
284
    case 4:  return "RowMajor";
285
    case 5:  return "ColMajor";
286
    case 6:  return "ArrayStride";
287
    case 7:  return "MatrixStride";
288
    case 8:  return "GLSLShared";
289
    case 9:  return "GLSLPacked";
290
    case 10: return "CPacked";
291
    case 11: return "BuiltIn";
292
    case 12: return "Bad";
293
    case 13: return "NoPerspective";
294
    case 14: return "Flat";
295
    case 15: return "Patch";
296
    case 16: return "Centroid";
297
    case 17: return "Sample";
298
    case 18: return "Invariant";
299
    case 19: return "Restrict";
300
    case 20: return "Aliased";
301
    case 21: return "Volatile";
302
    case 22: return "Constant";
303
    case 23: return "Coherent";
304
    case 24: return "NonWritable";
305
    case 25: return "NonReadable";
306
    case 26: return "Uniform";
307
    case 27: return "Bad";
308
    case 28: return "SaturatedConversion";
309
    case 29: return "Stream";
310
    case 30: return "Location";
311
    case 31: return "Component";
312
    case 32: return "Index";
313
    case 33: return "Binding";
314
    case 34: return "DescriptorSet";
315
    case 35: return "Offset";
316
    case 36: return "XfbBuffer";
317
    case 37: return "XfbStride";
318
    case 38: return "FuncParamAttr";
319
    case 39: return "FP Rounding Mode";
320
    case 40: return "FP Fast Math Mode";
321
    case 41: return "Linkage Attributes";
322
    case 42: return "NoContraction";
323
    case 43: return "InputAttachmentIndex";
324
    case 44: return "Alignment";
325

326
    case DecorationCeiling:
327
    default:  return "Bad";
328

329
    case (int)Decoration::WeightTextureQCOM:           return "DecorationWeightTextureQCOM";
330
    case (int)Decoration::BlockMatchTextureQCOM:       return "DecorationBlockMatchTextureQCOM";
331
    case (int)Decoration::BlockMatchSamplerQCOM:       return "DecorationBlockMatchSamplerQCOM";
332
    case (int)Decoration::ExplicitInterpAMD:           return "ExplicitInterpAMD";
333
    case (int)Decoration::OverrideCoverageNV:          return "OverrideCoverageNV";
334
    case (int)Decoration::PassthroughNV:               return "PassthroughNV";
335
    case (int)Decoration::ViewportRelativeNV:          return "ViewportRelativeNV";
336
    case (int)Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
337
    case (int)Decoration::PerPrimitiveNV:              return "PerPrimitiveNV";
338
    case (int)Decoration::PerViewNV:                   return "PerViewNV";
339
    case (int)Decoration::PerTaskNV:                   return "PerTaskNV";
340

341
    case (int)Decoration::PerVertexKHR:                return "PerVertexKHR";
342

343
    case (int)Decoration::NonUniformEXT:           return "DecorationNonUniformEXT";
344
    case (int)Decoration::HlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
345
    case (int)Decoration::HlslSemanticGOOGLE:      return "DecorationHlslSemanticGOOGLE";
346
    case (int)Decoration::RestrictPointerEXT:      return "DecorationRestrictPointerEXT";
347
    case (int)Decoration::AliasedPointerEXT:       return "DecorationAliasedPointerEXT";
348

349
    case (int)Decoration::HitObjectShaderRecordBufferNV:  return "DecorationHitObjectShaderRecordBufferNV";
350
    case (int)Decoration::HitObjectShaderRecordBufferEXT:  return "DecorationHitObjectShaderRecordBufferEXT";
351

352
    case (int)Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "DecorationSaturatedToLargestFloat8NormalConversionEXT";
353
    }
354
}
355

356
const char* BuiltInString(int builtIn)
357
{
358
    switch (builtIn) {
359
    case 0:  return "Position";
360
    case 1:  return "PointSize";
361
    case 2:  return "Bad";
362
    case 3:  return "ClipDistance";
363
    case 4:  return "CullDistance";
364
    case 5:  return "VertexId";
365
    case 6:  return "InstanceId";
366
    case 7:  return "PrimitiveId";
367
    case 8:  return "InvocationId";
368
    case 9:  return "Layer";
369
    case 10: return "ViewportIndex";
370
    case 11: return "TessLevelOuter";
371
    case 12: return "TessLevelInner";
372
    case 13: return "TessCoord";
373
    case 14: return "PatchVertices";
374
    case 15: return "FragCoord";
375
    case 16: return "PointCoord";
376
    case 17: return "FrontFacing";
377
    case 18: return "SampleId";
378
    case 19: return "SamplePosition";
379
    case 20: return "SampleMask";
380
    case 21: return "Bad";
381
    case 22: return "FragDepth";
382
    case 23: return "HelperInvocation";
383
    case 24: return "NumWorkgroups";
384
    case 25: return "WorkgroupSize";
385
    case 26: return "WorkgroupId";
386
    case 27: return "LocalInvocationId";
387
    case 28: return "GlobalInvocationId";
388
    case 29: return "LocalInvocationIndex";
389
    case 30: return "WorkDim";
390
    case 31: return "GlobalSize";
391
    case 32: return "EnqueuedWorkgroupSize";
392
    case 33: return "GlobalOffset";
393
    case 34: return "GlobalLinearId";
394
    case 35: return "Bad";
395
    case 36: return "SubgroupSize";
396
    case 37: return "SubgroupMaxSize";
397
    case 38: return "NumSubgroups";
398
    case 39: return "NumEnqueuedSubgroups";
399
    case 40: return "SubgroupId";
400
    case 41: return "SubgroupLocalInvocationId";
401
    case 42: return "VertexIndex";                 // TBD: put next to VertexId?
402
    case 43: return "InstanceIndex";               // TBD: put next to InstanceId?
403

404
    case 4416: return "SubgroupEqMaskKHR";
405
    case 4417: return "SubgroupGeMaskKHR";
406
    case 4418: return "SubgroupGtMaskKHR";
407
    case 4419: return "SubgroupLeMaskKHR";
408
    case 4420: return "SubgroupLtMaskKHR";
409
    case 4438: return "DeviceIndex";
410
    case 4440: return "ViewIndex";
411
    case 4424: return "BaseVertex";
412
    case 4425: return "BaseInstance";
413
    case 4426: return "DrawIndex";
414
    case 4432: return "PrimitiveShadingRateKHR";
415
    case 4444: return "ShadingRateKHR";
416
    case 5014: return "FragStencilRefEXT";
417

418
    case (int)BuiltIn::TileOffsetQCOM:     return "TileOffsetQCOM";
419
    case (int)BuiltIn::TileDimensionQCOM:  return "TileDimensionQCOM";
420
    case (int)BuiltIn::TileApronSizeQCOM:  return "TileApronSizeQCOM";
421

422
    case 4992: return "BaryCoordNoPerspAMD";
423
    case 4993: return "BaryCoordNoPerspCentroidAMD";
424
    case 4994: return "BaryCoordNoPerspSampleAMD";
425
    case 4995: return "BaryCoordSmoothAMD";
426
    case 4996: return "BaryCoordSmoothCentroidAMD";
427
    case 4997: return "BaryCoordSmoothSampleAMD";
428
    case 4998: return "BaryCoordPullModelAMD";
429
    case (int)BuiltIn::LaunchIdKHR:                 return "LaunchIdKHR";
430
    case (int)BuiltIn::LaunchSizeKHR:               return "LaunchSizeKHR";
431
    case (int)BuiltIn::WorldRayOriginKHR:           return "WorldRayOriginKHR";
432
    case (int)BuiltIn::WorldRayDirectionKHR:        return "WorldRayDirectionKHR";
433
    case (int)BuiltIn::ObjectRayOriginKHR:          return "ObjectRayOriginKHR";
434
    case (int)BuiltIn::ObjectRayDirectionKHR:       return "ObjectRayDirectionKHR";
435
    case (int)BuiltIn::RayTminKHR:                  return "RayTminKHR";
436
    case (int)BuiltIn::RayTmaxKHR:                  return "RayTmaxKHR";
437
    case (int)BuiltIn::CullMaskKHR:                 return "CullMaskKHR";
438
    case (int)BuiltIn::HitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
439
    case (int)BuiltIn::HitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
440
    case (int)BuiltIn::HitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
441
    case (int)BuiltIn::HitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
442
    case (int)BuiltIn::HitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
443
    case (int)BuiltIn::HitIsSphereNV:               return "HitIsSphereNV";
444
    case (int)BuiltIn::HitIsLSSNV:                  return "HitIsLSSNV";
445
    case (int)BuiltIn::HitSpherePositionNV:         return "HitSpherePositionNV";
446
    case (int)BuiltIn::HitSphereRadiusNV:           return "HitSphereRadiusNV";
447
    case (int)BuiltIn::HitLSSPositionsNV:           return "HitLSSPositionsNV";
448
    case (int)BuiltIn::HitLSSRadiiNV:               return "HitLLSSRadiiNV";
449
    case (int)BuiltIn::InstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
450
    case (int)BuiltIn::RayGeometryIndexKHR:         return "RayGeometryIndexKHR";
451
    case (int)BuiltIn::ObjectToWorldKHR:            return "ObjectToWorldKHR";
452
    case (int)BuiltIn::WorldToObjectKHR:            return "WorldToObjectKHR";
453
    case (int)BuiltIn::HitTNV:                      return "HitTNV";
454
    case (int)BuiltIn::HitKindKHR:                  return "HitKindKHR";
455
    case (int)BuiltIn::IncomingRayFlagsKHR:         return "IncomingRayFlagsKHR";
456
    case (int)BuiltIn::ViewportMaskNV:              return "ViewportMaskNV";
457
    case (int)BuiltIn::SecondaryPositionNV:         return "SecondaryPositionNV";
458
    case (int)BuiltIn::SecondaryViewportMaskNV:     return "SecondaryViewportMaskNV";
459
    case (int)BuiltIn::PositionPerViewNV:           return "PositionPerViewNV";
460
    case (int)BuiltIn::ViewportMaskPerViewNV:       return "ViewportMaskPerViewNV";
461
//    case (int)BuiltIn::FragmentSizeNV:             return "FragmentSizeNV";        // superseded by BuiltInFragSizeEXT
462
//    case (int)BuiltIn::InvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
463
    case (int)BuiltIn::BaryCoordKHR:                return "BaryCoordKHR";
464
    case (int)BuiltIn::BaryCoordNoPerspKHR:         return "BaryCoordNoPerspKHR";
465
    case (int)BuiltIn::ClusterIDNV:                 return "ClusterIDNV";
466

467
    case (int)BuiltIn::FragSizeEXT:                 return "FragSizeEXT";
468
    case (int)BuiltIn::FragInvocationCountEXT:      return "FragInvocationCountEXT";
469

470
    case 5264: return "FullyCoveredEXT";
471

472
    case (int)BuiltIn::TaskCountNV:           return "TaskCountNV";
473
    case (int)BuiltIn::PrimitiveCountNV:      return "PrimitiveCountNV";
474
    case (int)BuiltIn::PrimitiveIndicesNV:    return "PrimitiveIndicesNV";
475
    case (int)BuiltIn::ClipDistancePerViewNV: return "ClipDistancePerViewNV";
476
    case (int)BuiltIn::CullDistancePerViewNV: return "CullDistancePerViewNV";
477
    case (int)BuiltIn::LayerPerViewNV:        return "LayerPerViewNV";
478
    case (int)BuiltIn::MeshViewCountNV:       return "MeshViewCountNV";
479
    case (int)BuiltIn::MeshViewIndicesNV:     return "MeshViewIndicesNV";
480
    case (int)BuiltIn::WarpsPerSMNV:           return "WarpsPerSMNV";
481
    case (int)BuiltIn::SMCountNV:              return "SMCountNV";
482
    case (int)BuiltIn::WarpIDNV:               return "WarpIDNV";
483
    case (int)BuiltIn::SMIDNV:                 return "SMIDNV";
484
    case (int)BuiltIn::CurrentRayTimeNV:       return "CurrentRayTimeNV";
485
    case (int)BuiltIn::PrimitivePointIndicesEXT:        return "PrimitivePointIndicesEXT";
486
    case (int)BuiltIn::PrimitiveLineIndicesEXT:         return "PrimitiveLineIndicesEXT";
487
    case (int)BuiltIn::PrimitiveTriangleIndicesEXT:     return "PrimitiveTriangleIndicesEXT";
488
    case (int)BuiltIn::CullPrimitiveEXT:                return "CullPrimitiveEXT";
489
    case (int)BuiltIn::CoreCountARM:           return "CoreCountARM";
490
    case (int)BuiltIn::CoreIDARM:              return "CoreIDARM";
491
    case (int)BuiltIn::CoreMaxIDARM:           return "CoreMaxIDARM";
492
    case (int)BuiltIn::WarpIDARM:              return "WarpIDARM";
493
    case (int)BuiltIn::WarpMaxIDARM:           return "BuiltInWarpMaxIDARM";
494

495
    default: return "Bad";
496
    }
497
}
498

499
const char* DimensionString(int dim)
500
{
501
    switch (dim) {
502
    case 0:  return "1D";
503
    case 1:  return "2D";
504
    case 2:  return "3D";
505
    case 3:  return "Cube";
506
    case 4:  return "Rect";
507
    case 5:  return "Buffer";
508
    case 6:  return "SubpassData";
509
    case (int)Dim::TileImageDataEXT:  return "TileImageDataEXT";
510

511
    default: return "Bad";
512
    }
513
}
514

515
const char* SamplerAddressingModeString(int mode)
516
{
517
    switch (mode) {
518
    case 0:  return "None";
519
    case 1:  return "ClampToEdge";
520
    case 2:  return "Clamp";
521
    case 3:  return "Repeat";
522
    case 4:  return "RepeatMirrored";
523

524
    default: return "Bad";
525
    }
526
}
527

528
const char* SamplerFilterModeString(int mode)
529
{
530
    switch (mode) {
531
    case 0: return "Nearest";
532
    case 1: return "Linear";
533

534
    default: return "Bad";
535
    }
536
}
537

538
const char* ImageFormatString(int format)
539
{
540
    switch (format) {
541
    case  0: return "Unknown";
542

543
    // ES/Desktop float
544
    case  1: return "Rgba32f";
545
    case  2: return "Rgba16f";
546
    case  3: return "R32f";
547
    case  4: return "Rgba8";
548
    case  5: return "Rgba8Snorm";
549

550
    // Desktop float
551
    case  6: return "Rg32f";
552
    case  7: return "Rg16f";
553
    case  8: return "R11fG11fB10f";
554
    case  9: return "R16f";
555
    case 10: return "Rgba16";
556
    case 11: return "Rgb10A2";
557
    case 12: return "Rg16";
558
    case 13: return "Rg8";
559
    case 14: return "R16";
560
    case 15: return "R8";
561
    case 16: return "Rgba16Snorm";
562
    case 17: return "Rg16Snorm";
563
    case 18: return "Rg8Snorm";
564
    case 19: return "R16Snorm";
565
    case 20: return "R8Snorm";
566

567
    // ES/Desktop int
568
    case 21: return "Rgba32i";
569
    case 22: return "Rgba16i";
570
    case 23: return "Rgba8i";
571
    case 24: return "R32i";
572

573
    // Desktop int
574
    case 25: return "Rg32i";
575
    case 26: return "Rg16i";
576
    case 27: return "Rg8i";
577
    case 28: return "R16i";
578
    case 29: return "R8i";
579

580
    // ES/Desktop uint
581
    case 30: return "Rgba32ui";
582
    case 31: return "Rgba16ui";
583
    case 32: return "Rgba8ui";
584
    case 33: return "R32ui";
585

586
    // Desktop uint
587
    case 34: return "Rgb10a2ui";
588
    case 35: return "Rg32ui";
589
    case 36: return "Rg16ui";
590
    case 37: return "Rg8ui";
591
    case 38: return "R16ui";
592
    case 39: return "R8ui";
593
    case 40: return "R64ui";
594
    case 41: return "R64i";
595

596
    default:
597
        return "Bad";
598
    }
599
}
600

601
const char* ImageChannelOrderString(int format)
602
{
603
    switch (format) {
604
    case 0:  return "R";
605
    case 1:  return "A";
606
    case 2:  return "RG";
607
    case 3:  return "RA";
608
    case 4:  return "RGB";
609
    case 5:  return "RGBA";
610
    case 6:  return "BGRA";
611
    case 7:  return "ARGB";
612
    case 8:  return "Intensity";
613
    case 9:  return "Luminance";
614
    case 10: return "Rx";
615
    case 11: return "RGx";
616
    case 12: return "RGBx";
617
    case 13: return "Depth";
618
    case 14: return "DepthStencil";
619
    case 15: return "sRGB";
620
    case 16: return "sRGBx";
621
    case 17: return "sRGBA";
622
    case 18: return "sBGRA";
623

624
    default:
625
        return "Bad";
626
    }
627
}
628

629
const char* ImageChannelDataTypeString(int type)
630
{
631
    switch (type)
632
    {
633
    case 0: return "SnormInt8";
634
    case 1: return "SnormInt16";
635
    case 2: return "UnormInt8";
636
    case 3: return "UnormInt16";
637
    case 4: return "UnormShort565";
638
    case 5: return "UnormShort555";
639
    case 6: return "UnormInt101010";
640
    case 7: return "SignedInt8";
641
    case 8: return "SignedInt16";
642
    case 9: return "SignedInt32";
643
    case 10: return "UnsignedInt8";
644
    case 11: return "UnsignedInt16";
645
    case 12: return "UnsignedInt32";
646
    case 13: return "HalfFloat";
647
    case 14: return "Float";
648
    case 15: return "UnormInt24";
649
    case 16: return "UnormInt101010_2";
650

651
    default:
652
        return "Bad";
653
    }
654
}
655

656
const int ImageOperandsCeiling = 17;
657

658
const char* ImageOperandsString(int format)
659
{
660
    switch (format) {
661
    case (int)ImageOperandsShift::Bias:                    return "Bias";
662
    case (int)ImageOperandsShift::Lod:                     return "Lod";
663
    case (int)ImageOperandsShift::Grad:                    return "Grad";
664
    case (int)ImageOperandsShift::ConstOffset:             return "ConstOffset";
665
    case (int)ImageOperandsShift::Offset:                  return "Offset";
666
    case (int)ImageOperandsShift::ConstOffsets:            return "ConstOffsets";
667
    case (int)ImageOperandsShift::Sample:                  return "Sample";
668
    case (int)ImageOperandsShift::MinLod:                  return "MinLod";
669
    case (int)ImageOperandsShift::MakeTexelAvailableKHR:   return "MakeTexelAvailableKHR";
670
    case (int)ImageOperandsShift::MakeTexelVisibleKHR:     return "MakeTexelVisibleKHR";
671
    case (int)ImageOperandsShift::NonPrivateTexelKHR:      return "NonPrivateTexelKHR";
672
    case (int)ImageOperandsShift::VolatileTexelKHR:        return "VolatileTexelKHR";
673
    case (int)ImageOperandsShift::SignExtend:              return "SignExtend";
674
    case (int)ImageOperandsShift::ZeroExtend:              return "ZeroExtend";
675
    case (int)ImageOperandsShift::Nontemporal:             return "Nontemporal";
676
    case (int)ImageOperandsShift::Offsets:                 return "Offsets";
677

678
    case ImageOperandsCeiling:
679
    default:
680
        return "Bad";
681
    }
682
}
683

684
const char* FPFastMathString(int mode)
685
{
686
    switch (mode) {
687
    case 0: return "NotNaN";
688
    case 1: return "NotInf";
689
    case 2: return "NSZ";
690
    case 3: return "AllowRecip";
691
    case 4: return "Fast";
692

693
    default:     return "Bad";
694
    }
695
}
696

697
const char* FPRoundingModeString(int mode)
698
{
699
    switch (mode) {
700
    case 0:  return "RTE";
701
    case 1:  return "RTZ";
702
    case 2:  return "RTP";
703
    case 3:  return "RTN";
704

705
    default: return "Bad";
706
    }
707
}
708

709
const char* LinkageTypeString(int type)
710
{
711
    switch (type) {
712
    case 0:  return "Export";
713
    case 1:  return "Import";
714

715
    default: return "Bad";
716
    }
717
}
718

719
const char* FuncParamAttrString(int attr)
720
{
721
    switch (attr) {
722
    case 0:  return "Zext";
723
    case 1:  return "Sext";
724
    case 2:  return "ByVal";
725
    case 3:  return "Sret";
726
    case 4:  return "NoAlias";
727
    case 5:  return "NoCapture";
728
    case 6:  return "NoWrite";
729
    case 7:  return "NoReadWrite";
730

731
    default: return "Bad";
732
    }
733
}
734

735
const char* AccessQualifierString(int attr)
736
{
737
    switch (attr) {
738
    case 0:  return "ReadOnly";
739
    case 1:  return "WriteOnly";
740
    case 2:  return "ReadWrite";
741

742
    default: return "Bad";
743
    }
744
}
745

746
const int SelectControlCeiling = 2;
747

748
const char* SelectControlString(int cont)
749
{
750
    switch (cont) {
751
    case 0:  return "Flatten";
752
    case 1:  return "DontFlatten";
753

754
    case SelectControlCeiling:
755
    default: return "Bad";
756
    }
757
}
758

759
const int LoopControlCeiling = (int)LoopControlShift::PartialCount + 1;
760

761
const char* LoopControlString(int cont)
762
{
763
    switch (cont) {
764
    case (int)LoopControlShift::Unroll:             return "Unroll";
765
    case (int)LoopControlShift::DontUnroll:         return "DontUnroll";
766
    case (int)LoopControlShift::DependencyInfinite: return "DependencyInfinite";
767
    case (int)LoopControlShift::DependencyLength:   return "DependencyLength";
768
    case (int)LoopControlShift::MinIterations:      return "MinIterations";
769
    case (int)LoopControlShift::MaxIterations:      return "MaxIterations";
770
    case (int)LoopControlShift::IterationMultiple:  return "IterationMultiple";
771
    case (int)LoopControlShift::PeelCount:          return "PeelCount";
772
    case (int)LoopControlShift::PartialCount:       return "PartialCount";
773

774
    case LoopControlCeiling:
775
    default: return "Bad";
776
    }
777
}
778

779
const int FunctionControlCeiling = 4;
780

781
const char* FunctionControlString(int cont)
782
{
783
    switch (cont) {
784
    case 0:  return "Inline";
785
    case 1:  return "DontInline";
786
    case 2:  return "Pure";
787
    case 3:  return "Const";
788

789
    case FunctionControlCeiling:
790
    default: return "Bad";
791
    }
792
}
793

794
const char* MemorySemanticsString(int mem)
795
{
796
    // Note: No bits set (None) means "Relaxed"
797
    switch (mem) {
798
    case 0: return "Bad"; // Note: this is a placeholder for 'Consume'
799
    case 1: return "Acquire";
800
    case 2: return "Release";
801
    case 3: return "AcquireRelease";
802
    case 4: return "SequentiallyConsistent";
803
    case 5: return "Bad"; // Note: reserved for future expansion
804
    case 6: return "UniformMemory";
805
    case 7: return "SubgroupMemory";
806
    case 8: return "WorkgroupMemory";
807
    case 9: return "CrossWorkgroupMemory";
808
    case 10: return "AtomicCounterMemory";
809
    case 11: return "ImageMemory";
810

811
    default:     return "Bad";
812
    }
813
}
814

815
const int MemoryAccessCeiling = 6;
816

817
const char* MemoryAccessString(int mem)
818
{
819
    switch (mem) {
820
    case (int)MemoryAccessShift::Volatile:                 return "Volatile";
821
    case (int)MemoryAccessShift::Aligned:                  return "Aligned";
822
    case (int)MemoryAccessShift::Nontemporal:              return "Nontemporal";
823
    case (int)MemoryAccessShift::MakePointerAvailableKHR:  return "MakePointerAvailableKHR";
824
    case (int)MemoryAccessShift::MakePointerVisibleKHR:    return "MakePointerVisibleKHR";
825
    case (int)MemoryAccessShift::NonPrivatePointerKHR:     return "NonPrivatePointerKHR";
826

827
    default: return "Bad";
828
    }
829
}
830

831
const int CooperativeMatrixOperandsCeiling = 6;
832

833
const char* CooperativeMatrixOperandsString(int op)
834
{
835
    switch (op) {
836
    case (int)CooperativeMatrixOperandsShift::MatrixASignedComponentsKHR:  return "ASignedComponentsKHR";
837
    case (int)CooperativeMatrixOperandsShift::MatrixBSignedComponentsKHR:  return "BSignedComponentsKHR";
838
    case (int)CooperativeMatrixOperandsShift::MatrixCSignedComponentsKHR:  return "CSignedComponentsKHR";
839
    case (int)CooperativeMatrixOperandsShift::MatrixResultSignedComponentsKHR:  return "ResultSignedComponentsKHR";
840
    case (int)CooperativeMatrixOperandsShift::SaturatingAccumulationKHR:   return "SaturatingAccumulationKHR";
841

842
    default: return "Bad";
843
    }
844
}
845

846
const int TensorAddressingOperandsCeiling = 3;
847

848
const char* TensorAddressingOperandsString(int op)
849
{
850
    switch (op) {
851
    case (int)TensorAddressingOperandsShift::TensorView:  return "TensorView";
852
    case (int)TensorAddressingOperandsShift::DecodeFunc:  return "DecodeFunc";
853

854
    default: return "Bad";
855
    }
856
}
857

858
const char* ScopeString(int mem)
859
{
860
    switch (mem) {
861
    case 0:  return "CrossDevice";
862
    case 1:  return "Device";
863
    case 2:  return "Workgroup";
864
    case 3:  return "Subgroup";
865
    case 4:  return "Invocation";
866

867
    default: return "Bad";
868
    }
869
}
870

871
const char* GroupOperationString(int gop)
872
{
873

874
    switch (gop)
875
    {
876
    case (int)GroupOperation::Reduce:  return "Reduce";
877
    case (int)GroupOperation::InclusiveScan:  return "InclusiveScan";
878
    case (int)GroupOperation::ExclusiveScan:  return "ExclusiveScan";
879
    case (int)GroupOperation::ClusteredReduce:  return "ClusteredReduce";
880
    case (int)GroupOperation::PartitionedReduceNV:  return "PartitionedReduceNV";
881
    case (int)GroupOperation::PartitionedInclusiveScanNV:  return "PartitionedInclusiveScanNV";
882
    case (int)GroupOperation::PartitionedExclusiveScanNV:  return "PartitionedExclusiveScanNV";
883

884
    default: return "Bad";
885
    }
886
}
887

888
const char* KernelEnqueueFlagsString(int flag)
889
{
890
    switch (flag)
891
    {
892
    case 0:  return "NoWait";
893
    case 1:  return "WaitKernel";
894
    case 2:  return "WaitWorkGroup";
895

896
    default: return "Bad";
897
    }
898
}
899

900
const char* KernelProfilingInfoString(int info)
901
{
902
    switch (info)
903
    {
904
    case 0:  return "CmdExecTime";
905

906
    default: return "Bad";
907
    }
908
}
909

910
const char* CapabilityString(int info)
911
{
912
    switch (info)
913
    {
914
    case 0:  return "Matrix";
915
    case 1:  return "Shader";
916
    case 2:  return "Geometry";
917
    case 3:  return "Tessellation";
918
    case 4:  return "Addresses";
919
    case 5:  return "Linkage";
920
    case 6:  return "Kernel";
921
    case 7:  return "Vector16";
922
    case 8:  return "Float16Buffer";
923
    case 9:  return "Float16";
924
    case 10: return "Float64";
925
    case 11: return "Int64";
926
    case 12: return "Int64Atomics";
927
    case 13: return "ImageBasic";
928
    case 14: return "ImageReadWrite";
929
    case 15: return "ImageMipmap";
930
    case 16: return "Bad";
931
    case 17: return "Pipes";
932
    case 18: return "Groups";
933
    case 19: return "DeviceEnqueue";
934
    case 20: return "LiteralSampler";
935
    case 21: return "AtomicStorage";
936
    case 22: return "Int16";
937
    case 23: return "TessellationPointSize";
938
    case 24: return "GeometryPointSize";
939
    case 25: return "ImageGatherExtended";
940
    case 26: return "Bad";
941
    case 27: return "StorageImageMultisample";
942
    case 28: return "UniformBufferArrayDynamicIndexing";
943
    case 29: return "SampledImageArrayDynamicIndexing";
944
    case 30: return "StorageBufferArrayDynamicIndexing";
945
    case 31: return "StorageImageArrayDynamicIndexing";
946
    case 32: return "ClipDistance";
947
    case 33: return "CullDistance";
948
    case 34: return "ImageCubeArray";
949
    case 35: return "SampleRateShading";
950
    case 36: return "ImageRect";
951
    case 37: return "SampledRect";
952
    case 38: return "GenericPointer";
953
    case 39: return "Int8";
954
    case 40: return "InputAttachment";
955
    case 41: return "SparseResidency";
956
    case 42: return "MinLod";
957
    case 43: return "Sampled1D";
958
    case 44: return "Image1D";
959
    case 45: return "SampledCubeArray";
960
    case 46: return "SampledBuffer";
961
    case 47: return "ImageBuffer";
962
    case 48: return "ImageMSArray";
963
    case 49: return "StorageImageExtendedFormats";
964
    case 50: return "ImageQuery";
965
    case 51: return "DerivativeControl";
966
    case 52: return "InterpolationFunction";
967
    case 53: return "TransformFeedback";
968
    case 54: return "GeometryStreams";
969
    case 55: return "StorageImageReadWithoutFormat";
970
    case 56: return "StorageImageWriteWithoutFormat";
971
    case 57: return "MultiViewport";
972
    case 61: return "GroupNonUniform";
973
    case 62: return "GroupNonUniformVote";
974
    case 63: return "GroupNonUniformArithmetic";
975
    case 64: return "GroupNonUniformBallot";
976
    case 65: return "GroupNonUniformShuffle";
977
    case 66: return "GroupNonUniformShuffleRelative";
978
    case 67: return "GroupNonUniformClustered";
979
    case 68: return "GroupNonUniformQuad";
980

981
    case (int)Capability::SubgroupBallotKHR: return "SubgroupBallotKHR";
982
    case (int)Capability::DrawParameters:    return "DrawParameters";
983
    case (int)Capability::SubgroupVoteKHR:   return "SubgroupVoteKHR";
984
    case (int)Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR";
985

986
    case (int)Capability::StorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
987
    case (int)Capability::StorageUniform16:            return "StorageUniform16";
988
    case (int)Capability::StoragePushConstant16:       return "StoragePushConstant16";
989
    case (int)Capability::StorageInputOutput16:        return "StorageInputOutput16";
990

991
    case (int)Capability::StorageBuffer8BitAccess:             return "StorageBuffer8BitAccess";
992
    case (int)Capability::UniformAndStorageBuffer8BitAccess:   return "UniformAndStorageBuffer8BitAccess";
993
    case (int)Capability::StoragePushConstant8:                return "StoragePushConstant8";
994

995
    case (int)Capability::DeviceGroup: return "DeviceGroup";
996
    case (int)Capability::MultiView:   return "MultiView";
997

998
    case (int)Capability::DenormPreserve:           return "DenormPreserve";
999
    case (int)Capability::DenormFlushToZero:        return "DenormFlushToZero";
1000
    case (int)Capability::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
1001
    case (int)Capability::RoundingModeRTE:          return "RoundingModeRTE";
1002
    case (int)Capability::RoundingModeRTZ:          return "RoundingModeRTZ";
1003

1004
    case (int)Capability::StencilExportEXT: return "StencilExportEXT";
1005

1006
    case (int)Capability::Float16ImageAMD:       return "Float16ImageAMD";
1007
    case (int)Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
1008
    case (int)Capability::FragmentMaskAMD:       return "FragmentMaskAMD";
1009
    case (int)Capability::ImageReadWriteLodAMD:  return "ImageReadWriteLodAMD";
1010

1011
    case (int)Capability::AtomicStorageOps:             return "AtomicStorageOps";
1012

1013
    case (int)Capability::SampleMaskPostDepthCoverage:  return "SampleMaskPostDepthCoverage";
1014
    case (int)Capability::GeometryShaderPassthroughNV:     return "GeometryShaderPassthroughNV";
1015
    case (int)Capability::ShaderViewportIndexLayerNV:      return "ShaderViewportIndexLayerNV";
1016
    case (int)Capability::ShaderViewportMaskNV:            return "ShaderViewportMaskNV";
1017
    case (int)Capability::ShaderStereoViewNV:              return "ShaderStereoViewNV";
1018
    case (int)Capability::PerViewAttributesNV:             return "PerViewAttributesNV";
1019
    case (int)Capability::GroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
1020
    case (int)Capability::RayTracingNV:                    return "RayTracingNV";
1021
    case (int)Capability::RayTracingMotionBlurNV:          return "RayTracingMotionBlurNV";
1022
    case (int)Capability::RayTracingKHR:                   return "RayTracingKHR";
1023
    case (int)Capability::RayCullMaskKHR:                  return "RayCullMaskKHR";
1024
    case (int)Capability::RayQueryKHR:                     return "RayQueryKHR";
1025
    case (int)Capability::RayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
1026
    case (int)Capability::RayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
1027
    case (int)Capability::RayTracingPositionFetchKHR:      return "RayTracingPositionFetchKHR";
1028
    case (int)Capability::DisplacementMicromapNV:           return "DisplacementMicromapNV";
1029
    case (int)Capability::RayTracingOpacityMicromapEXT:    return "RayTracingOpacityMicromapEXT";
1030
    case (int)Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
1031
    case (int)Capability::RayQueryPositionFetchKHR:        return "RayQueryPositionFetchKHR";
1032
    case (int)Capability::ComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
1033
    case (int)Capability::ComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
1034
    case (int)Capability::FragmentBarycentricKHR:          return "FragmentBarycentricKHR";
1035
    case (int)Capability::MeshShadingNV:                   return "MeshShadingNV";
1036
    case (int)Capability::ImageFootprintNV:                return "ImageFootprintNV";
1037
    case (int)Capability::MeshShadingEXT:                  return "MeshShadingEXT";
1038
//    case (int)Capability::ShadingRateNV:                   return "ShadingRateNV";  // superseded by FragmentDensityEXT
1039
    case (int)Capability::SampleMaskOverrideCoverageNV:    return "SampleMaskOverrideCoverageNV";
1040
    case (int)Capability::FragmentDensityEXT:              return "FragmentDensityEXT";
1041

1042
    case (int)Capability::FragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
1043

1044
    case (int)Capability::ShaderNonUniformEXT:                          return "ShaderNonUniformEXT";
1045
    case (int)Capability::RuntimeDescriptorArrayEXT:                    return "RuntimeDescriptorArrayEXT";
1046
    case (int)Capability::InputAttachmentArrayDynamicIndexingEXT:       return "InputAttachmentArrayDynamicIndexingEXT";
1047
    case (int)Capability::UniformTexelBufferArrayDynamicIndexingEXT:    return "UniformTexelBufferArrayDynamicIndexingEXT";
1048
    case (int)Capability::StorageTexelBufferArrayDynamicIndexingEXT:    return "StorageTexelBufferArrayDynamicIndexingEXT";
1049
    case (int)Capability::UniformBufferArrayNonUniformIndexingEXT:      return "UniformBufferArrayNonUniformIndexingEXT";
1050
    case (int)Capability::SampledImageArrayNonUniformIndexingEXT:       return "SampledImageArrayNonUniformIndexingEXT";
1051
    case (int)Capability::StorageBufferArrayNonUniformIndexingEXT:      return "StorageBufferArrayNonUniformIndexingEXT";
1052
    case (int)Capability::StorageImageArrayNonUniformIndexingEXT:       return "StorageImageArrayNonUniformIndexingEXT";
1053
    case (int)Capability::InputAttachmentArrayNonUniformIndexingEXT:    return "InputAttachmentArrayNonUniformIndexingEXT";
1054
    case (int)Capability::UniformTexelBufferArrayNonUniformIndexingEXT: return "UniformTexelBufferArrayNonUniformIndexingEXT";
1055
    case (int)Capability::StorageTexelBufferArrayNonUniformIndexingEXT: return "StorageTexelBufferArrayNonUniformIndexingEXT";
1056

1057
    case (int)Capability::VulkanMemoryModelKHR:                return "VulkanMemoryModelKHR";
1058
    case (int)Capability::VulkanMemoryModelDeviceScopeKHR:     return "VulkanMemoryModelDeviceScopeKHR";
1059

1060
    case (int)Capability::PhysicalStorageBufferAddressesEXT:   return "PhysicalStorageBufferAddressesEXT";
1061

1062
    case (int)Capability::VariablePointers:                    return "VariablePointers";
1063

1064
    case (int)Capability::CooperativeMatrixNV:     return "CooperativeMatrixNV";
1065
    case (int)Capability::CooperativeMatrixKHR:    return "CooperativeMatrixKHR";
1066
    case (int)Capability::CooperativeMatrixReductionsNV:           return "CooperativeMatrixReductionsNV";
1067
    case (int)Capability::CooperativeMatrixConversionsNV:          return "CooperativeMatrixConversionsNV";
1068
    case (int)Capability::CooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
1069
    case (int)Capability::CooperativeMatrixTensorAddressingNV:     return "CooperativeMatrixTensorAddressingNV";
1070
    case (int)Capability::CooperativeMatrixBlockLoadsNV:           return "CooperativeMatrixBlockLoadsNV";
1071
    case (int)Capability::TensorAddressingNV:                      return "TensorAddressingNV";
1072

1073
    case (int)Capability::ShaderSMBuiltinsNV:      return "ShaderSMBuiltinsNV";
1074

1075
    case (int)Capability::CooperativeVectorNV:                     return "CooperativeVectorNV";
1076
    case (int)Capability::CooperativeVectorTrainingNV:             return "CooperativeVectorTrainingNV";
1077

1078
    case (int)Capability::FragmentShaderSampleInterlockEXT:        return "FragmentShaderSampleInterlockEXT";
1079
    case (int)Capability::FragmentShaderPixelInterlockEXT:         return "FragmentShaderPixelInterlockEXT";
1080
    case (int)Capability::FragmentShaderShadingRateInterlockEXT:   return "FragmentShaderShadingRateInterlockEXT";
1081

1082
    case (int)Capability::TileImageColorReadAccessEXT:           return "TileImageColorReadAccessEXT";
1083
    case (int)Capability::TileImageDepthReadAccessEXT:           return "TileImageDepthReadAccessEXT";
1084
    case (int)Capability::TileImageStencilReadAccessEXT:         return "TileImageStencilReadAccessEXT";
1085

1086
    case (int)Capability::CooperativeMatrixLayoutsARM:             return "CooperativeMatrixLayoutsARM";
1087
    case (int)Capability::TensorsARM:                              return "TensorsARM";
1088

1089
    case (int)Capability::FragmentShadingRateKHR:                  return "FragmentShadingRateKHR";
1090

1091
    case (int)Capability::DemoteToHelperInvocationEXT:             return "DemoteToHelperInvocationEXT";
1092
    case (int)Capability::AtomicFloat16VectorNV:                   return "AtomicFloat16VectorNV";
1093
    case (int)Capability::ShaderClockKHR:                          return "ShaderClockKHR";
1094
    case (int)Capability::QuadControlKHR:                          return "QuadControlKHR";
1095
    case (int)Capability::Int64ImageEXT:                           return "Int64ImageEXT";
1096

1097
    case (int)Capability::IntegerFunctions2INTEL:              return "IntegerFunctions2INTEL";
1098

1099
    case (int)Capability::ExpectAssumeKHR:                         return "ExpectAssumeKHR";
1100

1101
    case (int)Capability::AtomicFloat16AddEXT:                     return "AtomicFloat16AddEXT";
1102
    case (int)Capability::AtomicFloat32AddEXT:                     return "AtomicFloat32AddEXT";
1103
    case (int)Capability::AtomicFloat64AddEXT:                     return "AtomicFloat64AddEXT";
1104
    case (int)Capability::AtomicFloat16MinMaxEXT:                  return "AtomicFloat16MinMaxEXT";
1105
    case (int)Capability::AtomicFloat32MinMaxEXT:                  return "AtomicFloat32MinMaxEXT";
1106
    case (int)Capability::AtomicFloat64MinMaxEXT:                  return "AtomicFloat64MinMaxEXT";
1107

1108
    case (int)Capability::WorkgroupMemoryExplicitLayoutKHR:            return "WorkgroupMemoryExplicitLayoutKHR";
1109
    case (int)Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR:  return "WorkgroupMemoryExplicitLayout8BitAccessKHR";
1110
    case (int)Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR";
1111
    case (int)Capability::CoreBuiltinsARM:                             return "CoreBuiltinsARM";
1112

1113
    case (int)Capability::ShaderInvocationReorderNV:                return "ShaderInvocationReorderNV";
1114
    case (int)Capability::ShaderInvocationReorderEXT:               return "ShaderInvocationReorderEXT";
1115

1116
    case (int)Capability::TextureSampleWeightedQCOM:           return "TextureSampleWeightedQCOM";
1117
    case (int)Capability::TextureBoxFilterQCOM:                return "TextureBoxFilterQCOM";
1118
    case (int)Capability::TextureBlockMatchQCOM:               return "TextureBlockMatchQCOM";
1119
    case (int)Capability::TileShadingQCOM:                     return "TileShadingQCOM";
1120
    case (int)Capability::TextureBlockMatch2QCOM:              return "TextureBlockMatch2QCOM";
1121

1122
    case (int)Capability::CooperativeMatrixConversionQCOM:     return "CooperativeMatrixConversionQCOM";
1123

1124
    case (int)Capability::ReplicatedCompositesEXT:             return "ReplicatedCompositesEXT";
1125

1126
    case (int)Capability::DotProductKHR:                       return "DotProductKHR";
1127
    case (int)Capability::DotProductInputAllKHR:               return "DotProductInputAllKHR";
1128
    case (int)Capability::DotProductInput4x8BitKHR:            return "DotProductInput4x8BitKHR";
1129
    case (int)Capability::DotProductInput4x8BitPackedKHR:      return "DotProductInput4x8BitPackedKHR";
1130

1131
    case (int)Capability::RayTracingClusterAccelerationStructureNV:   return "RayTracingClusterAccelerationStructureNV";
1132

1133
    case (int)Capability::RayTracingSpheresGeometryNV:             return "RayTracingSpheresGeometryNV";
1134
    case (int)Capability::RayTracingLinearSweptSpheresGeometryNV:  return "RayTracingLinearSweptSpheresGeometryNV";
1135

1136
    case (int)Capability::BFloat16TypeKHR:                     return "BFloat16TypeKHR";
1137
    case (int)Capability::BFloat16DotProductKHR:               return "BFloat16DotProductKHR";
1138
    case (int)Capability::BFloat16CooperativeMatrixKHR:        return "BFloat16CooperativeMatrixKHR";
1139

1140
    case (int)Capability::Float8EXT:                           return "Float8EXT";
1141
    case (int)Capability::Float8CooperativeMatrixEXT:          return "Float8CooperativeMatrixEXT";
1142

1143
    case (int)Capability::Shader64BitIndexingEXT:              return "CapabilityShader64BitIndexingEXT";
1144

1145
    default: return "Bad";
1146
    }
1147
}
1148

1149
const char* OpcodeString(int op)
1150
{
1151
    switch (op) {
1152
    case 0:   return "OpNop";
1153
    case 1:   return "OpUndef";
1154
    case 2:   return "OpSourceContinued";
1155
    case 3:   return "OpSource";
1156
    case 4:   return "OpSourceExtension";
1157
    case 5:   return "OpName";
1158
    case 6:   return "OpMemberName";
1159
    case 7:   return "OpString";
1160
    case 8:   return "OpLine";
1161
    case 9:   return "Bad";
1162
    case 10:  return "OpExtension";
1163
    case 11:  return "OpExtInstImport";
1164
    case 12:  return "OpExtInst";
1165
    case 13:  return "Bad";
1166
    case 14:  return "OpMemoryModel";
1167
    case 15:  return "OpEntryPoint";
1168
    case 16:  return "OpExecutionMode";
1169
    case 17:  return "OpCapability";
1170
    case 18:  return "Bad";
1171
    case 19:  return "OpTypeVoid";
1172
    case 20:  return "OpTypeBool";
1173
    case 21:  return "OpTypeInt";
1174
    case 22:  return "OpTypeFloat";
1175
    case 23:  return "OpTypeVector";
1176
    case 24:  return "OpTypeMatrix";
1177
    case 25:  return "OpTypeImage";
1178
    case 26:  return "OpTypeSampler";
1179
    case 27:  return "OpTypeSampledImage";
1180
    case 28:  return "OpTypeArray";
1181
    case 29:  return "OpTypeRuntimeArray";
1182
    case 30:  return "OpTypeStruct";
1183
    case 31:  return "OpTypeOpaque";
1184
    case 32:  return "OpTypePointer";
1185
    case 33:  return "OpTypeFunction";
1186
    case 34:  return "OpTypeEvent";
1187
    case 35:  return "OpTypeDeviceEvent";
1188
    case 36:  return "OpTypeReserveId";
1189
    case 37:  return "OpTypeQueue";
1190
    case 38:  return "OpTypePipe";
1191
    case 39:  return "OpTypeForwardPointer";
1192
    case 40:  return "Bad";
1193
    case 41:  return "OpConstantTrue";
1194
    case 42:  return "OpConstantFalse";
1195
    case 43:  return "OpConstant";
1196
    case 44:  return "OpConstantComposite";
1197
    case 45:  return "OpConstantSampler";
1198
    case 46:  return "OpConstantNull";
1199
    case 47:  return "Bad";
1200
    case 48:  return "OpSpecConstantTrue";
1201
    case 49:  return "OpSpecConstantFalse";
1202
    case 50:  return "OpSpecConstant";
1203
    case 51:  return "OpSpecConstantComposite";
1204
    case 52:  return "OpSpecConstantOp";
1205
    case 53:  return "Bad";
1206
    case 54:  return "OpFunction";
1207
    case 55:  return "OpFunctionParameter";
1208
    case 56:  return "OpFunctionEnd";
1209
    case 57:  return "OpFunctionCall";
1210
    case 58:  return "Bad";
1211
    case 59:  return "OpVariable";
1212
    case 60:  return "OpImageTexelPointer";
1213
    case 61:  return "OpLoad";
1214
    case 62:  return "OpStore";
1215
    case 63:  return "OpCopyMemory";
1216
    case 64:  return "OpCopyMemorySized";
1217
    case 65:  return "OpAccessChain";
1218
    case 66:  return "OpInBoundsAccessChain";
1219
    case 67:  return "OpPtrAccessChain";
1220
    case 68:  return "OpArrayLength";
1221
    case 69:  return "OpGenericPtrMemSemantics";
1222
    case 70:  return "OpInBoundsPtrAccessChain";
1223
    case 71:  return "OpDecorate";
1224
    case 72:  return "OpMemberDecorate";
1225
    case 73:  return "OpDecorationGroup";
1226
    case 74:  return "OpGroupDecorate";
1227
    case 75:  return "OpGroupMemberDecorate";
1228
    case 76:  return "Bad";
1229
    case 77:  return "OpVectorExtractDynamic";
1230
    case 78:  return "OpVectorInsertDynamic";
1231
    case 79:  return "OpVectorShuffle";
1232
    case 80:  return "OpCompositeConstruct";
1233
    case 81:  return "OpCompositeExtract";
1234
    case 82:  return "OpCompositeInsert";
1235
    case 83:  return "OpCopyObject";
1236
    case 84:  return "OpTranspose";
1237
    case (int)Op::OpCopyLogical: return "OpCopyLogical";
1238
    case 85:  return "Bad";
1239
    case 86:  return "OpSampledImage";
1240
    case 87:  return "OpImageSampleImplicitLod";
1241
    case 88:  return "OpImageSampleExplicitLod";
1242
    case 89:  return "OpImageSampleDrefImplicitLod";
1243
    case 90:  return "OpImageSampleDrefExplicitLod";
1244
    case 91:  return "OpImageSampleProjImplicitLod";
1245
    case 92:  return "OpImageSampleProjExplicitLod";
1246
    case 93:  return "OpImageSampleProjDrefImplicitLod";
1247
    case 94:  return "OpImageSampleProjDrefExplicitLod";
1248
    case 95:  return "OpImageFetch";
1249
    case 96:  return "OpImageGather";
1250
    case 97:  return "OpImageDrefGather";
1251
    case 98:  return "OpImageRead";
1252
    case 99:  return "OpImageWrite";
1253
    case 100: return "OpImage";
1254
    case 101: return "OpImageQueryFormat";
1255
    case 102: return "OpImageQueryOrder";
1256
    case 103: return "OpImageQuerySizeLod";
1257
    case 104: return "OpImageQuerySize";
1258
    case 105: return "OpImageQueryLod";
1259
    case 106: return "OpImageQueryLevels";
1260
    case 107: return "OpImageQuerySamples";
1261
    case 108: return "Bad";
1262
    case 109: return "OpConvertFToU";
1263
    case 110: return "OpConvertFToS";
1264
    case 111: return "OpConvertSToF";
1265
    case 112: return "OpConvertUToF";
1266
    case 113: return "OpUConvert";
1267
    case 114: return "OpSConvert";
1268
    case 115: return "OpFConvert";
1269
    case 116: return "OpQuantizeToF16";
1270
    case 117: return "OpConvertPtrToU";
1271
    case 118: return "OpSatConvertSToU";
1272
    case 119: return "OpSatConvertUToS";
1273
    case 120: return "OpConvertUToPtr";
1274
    case 121: return "OpPtrCastToGeneric";
1275
    case 122: return "OpGenericCastToPtr";
1276
    case 123: return "OpGenericCastToPtrExplicit";
1277
    case 124: return "OpBitcast";
1278
    case 125: return "Bad";
1279
    case 126: return "OpSNegate";
1280
    case 127: return "OpFNegate";
1281
    case 128: return "OpIAdd";
1282
    case 129: return "OpFAdd";
1283
    case 130: return "OpISub";
1284
    case 131: return "OpFSub";
1285
    case 132: return "OpIMul";
1286
    case 133: return "OpFMul";
1287
    case 134: return "OpUDiv";
1288
    case 135: return "OpSDiv";
1289
    case 136: return "OpFDiv";
1290
    case 137: return "OpUMod";
1291
    case 138: return "OpSRem";
1292
    case 139: return "OpSMod";
1293
    case 140: return "OpFRem";
1294
    case 141: return "OpFMod";
1295
    case 142: return "OpVectorTimesScalar";
1296
    case 143: return "OpMatrixTimesScalar";
1297
    case 144: return "OpVectorTimesMatrix";
1298
    case 145: return "OpMatrixTimesVector";
1299
    case 146: return "OpMatrixTimesMatrix";
1300
    case 147: return "OpOuterProduct";
1301
    case 148: return "OpDot";
1302
    case 149: return "OpIAddCarry";
1303
    case 150: return "OpISubBorrow";
1304
    case 151: return "OpUMulExtended";
1305
    case 152: return "OpSMulExtended";
1306
    case 153: return "Bad";
1307
    case 154: return "OpAny";
1308
    case 155: return "OpAll";
1309
    case 156: return "OpIsNan";
1310
    case 157: return "OpIsInf";
1311
    case 158: return "OpIsFinite";
1312
    case 159: return "OpIsNormal";
1313
    case 160: return "OpSignBitSet";
1314
    case 161: return "OpLessOrGreater";
1315
    case 162: return "OpOrdered";
1316
    case 163: return "OpUnordered";
1317
    case 164: return "OpLogicalEqual";
1318
    case 165: return "OpLogicalNotEqual";
1319
    case 166: return "OpLogicalOr";
1320
    case 167: return "OpLogicalAnd";
1321
    case 168: return "OpLogicalNot";
1322
    case 169: return "OpSelect";
1323
    case 170: return "OpIEqual";
1324
    case 171: return "OpINotEqual";
1325
    case 172: return "OpUGreaterThan";
1326
    case 173: return "OpSGreaterThan";
1327
    case 174: return "OpUGreaterThanEqual";
1328
    case 175: return "OpSGreaterThanEqual";
1329
    case 176: return "OpULessThan";
1330
    case 177: return "OpSLessThan";
1331
    case 178: return "OpULessThanEqual";
1332
    case 179: return "OpSLessThanEqual";
1333
    case 180: return "OpFOrdEqual";
1334
    case 181: return "OpFUnordEqual";
1335
    case 182: return "OpFOrdNotEqual";
1336
    case 183: return "OpFUnordNotEqual";
1337
    case 184: return "OpFOrdLessThan";
1338
    case 185: return "OpFUnordLessThan";
1339
    case 186: return "OpFOrdGreaterThan";
1340
    case 187: return "OpFUnordGreaterThan";
1341
    case 188: return "OpFOrdLessThanEqual";
1342
    case 189: return "OpFUnordLessThanEqual";
1343
    case 190: return "OpFOrdGreaterThanEqual";
1344
    case 191: return "OpFUnordGreaterThanEqual";
1345
    case 192: return "Bad";
1346
    case 193: return "Bad";
1347
    case 194: return "OpShiftRightLogical";
1348
    case 195: return "OpShiftRightArithmetic";
1349
    case 196: return "OpShiftLeftLogical";
1350
    case 197: return "OpBitwiseOr";
1351
    case 198: return "OpBitwiseXor";
1352
    case 199: return "OpBitwiseAnd";
1353
    case 200: return "OpNot";
1354
    case 201: return "OpBitFieldInsert";
1355
    case 202: return "OpBitFieldSExtract";
1356
    case 203: return "OpBitFieldUExtract";
1357
    case 204: return "OpBitReverse";
1358
    case 205: return "OpBitCount";
1359
    case 206: return "Bad";
1360
    case 207: return "OpDPdx";
1361
    case 208: return "OpDPdy";
1362
    case 209: return "OpFwidth";
1363
    case 210: return "OpDPdxFine";
1364
    case 211: return "OpDPdyFine";
1365
    case 212: return "OpFwidthFine";
1366
    case 213: return "OpDPdxCoarse";
1367
    case 214: return "OpDPdyCoarse";
1368
    case 215: return "OpFwidthCoarse";
1369
    case 216: return "Bad";
1370
    case 217: return "Bad";
1371
    case 218: return "OpEmitVertex";
1372
    case 219: return "OpEndPrimitive";
1373
    case 220: return "OpEmitStreamVertex";
1374
    case 221: return "OpEndStreamPrimitive";
1375
    case 222: return "Bad";
1376
    case 223: return "Bad";
1377
    case 224: return "OpControlBarrier";
1378
    case 225: return "OpMemoryBarrier";
1379
    case 226: return "Bad";
1380
    case 227: return "OpAtomicLoad";
1381
    case 228: return "OpAtomicStore";
1382
    case 229: return "OpAtomicExchange";
1383
    case 230: return "OpAtomicCompareExchange";
1384
    case 231: return "OpAtomicCompareExchangeWeak";
1385
    case 232: return "OpAtomicIIncrement";
1386
    case 233: return "OpAtomicIDecrement";
1387
    case 234: return "OpAtomicIAdd";
1388
    case 235: return "OpAtomicISub";
1389
    case 236: return "OpAtomicSMin";
1390
    case 237: return "OpAtomicUMin";
1391
    case 238: return "OpAtomicSMax";
1392
    case 239: return "OpAtomicUMax";
1393
    case 240: return "OpAtomicAnd";
1394
    case 241: return "OpAtomicOr";
1395
    case 242: return "OpAtomicXor";
1396
    case 243: return "Bad";
1397
    case 244: return "Bad";
1398
    case 245: return "OpPhi";
1399
    case 246: return "OpLoopMerge";
1400
    case 247: return "OpSelectionMerge";
1401
    case 248: return "OpLabel";
1402
    case 249: return "OpBranch";
1403
    case 250: return "OpBranchConditional";
1404
    case 251: return "OpSwitch";
1405
    case 252: return "OpKill";
1406
    case 253: return "OpReturn";
1407
    case 254: return "OpReturnValue";
1408
    case 255: return "OpUnreachable";
1409
    case 256: return "OpLifetimeStart";
1410
    case 257: return "OpLifetimeStop";
1411
    case 258: return "Bad";
1412
    case 259: return "OpGroupAsyncCopy";
1413
    case 260: return "OpGroupWaitEvents";
1414
    case 261: return "OpGroupAll";
1415
    case 262: return "OpGroupAny";
1416
    case 263: return "OpGroupBroadcast";
1417
    case 264: return "OpGroupIAdd";
1418
    case 265: return "OpGroupFAdd";
1419
    case 266: return "OpGroupFMin";
1420
    case 267: return "OpGroupUMin";
1421
    case 268: return "OpGroupSMin";
1422
    case 269: return "OpGroupFMax";
1423
    case 270: return "OpGroupUMax";
1424
    case 271: return "OpGroupSMax";
1425
    case 272: return "Bad";
1426
    case 273: return "Bad";
1427
    case 274: return "OpReadPipe";
1428
    case 275: return "OpWritePipe";
1429
    case 276: return "OpReservedReadPipe";
1430
    case 277: return "OpReservedWritePipe";
1431
    case 278: return "OpReserveReadPipePackets";
1432
    case 279: return "OpReserveWritePipePackets";
1433
    case 280: return "OpCommitReadPipe";
1434
    case 281: return "OpCommitWritePipe";
1435
    case 282: return "OpIsValidReserveId";
1436
    case 283: return "OpGetNumPipePackets";
1437
    case 284: return "OpGetMaxPipePackets";
1438
    case 285: return "OpGroupReserveReadPipePackets";
1439
    case 286: return "OpGroupReserveWritePipePackets";
1440
    case 287: return "OpGroupCommitReadPipe";
1441
    case 288: return "OpGroupCommitWritePipe";
1442
    case 289: return "Bad";
1443
    case 290: return "Bad";
1444
    case 291: return "OpEnqueueMarker";
1445
    case 292: return "OpEnqueueKernel";
1446
    case 293: return "OpGetKernelNDrangeSubGroupCount";
1447
    case 294: return "OpGetKernelNDrangeMaxSubGroupSize";
1448
    case 295: return "OpGetKernelWorkGroupSize";
1449
    case 296: return "OpGetKernelPreferredWorkGroupSizeMultiple";
1450
    case 297: return "OpRetainEvent";
1451
    case 298: return "OpReleaseEvent";
1452
    case 299: return "OpCreateUserEvent";
1453
    case 300: return "OpIsValidEvent";
1454
    case 301: return "OpSetUserEventStatus";
1455
    case 302: return "OpCaptureEventProfilingInfo";
1456
    case 303: return "OpGetDefaultQueue";
1457
    case 304: return "OpBuildNDRange";
1458
    case 305: return "OpImageSparseSampleImplicitLod";
1459
    case 306: return "OpImageSparseSampleExplicitLod";
1460
    case 307: return "OpImageSparseSampleDrefImplicitLod";
1461
    case 308: return "OpImageSparseSampleDrefExplicitLod";
1462
    case 309: return "OpImageSparseSampleProjImplicitLod";
1463
    case 310: return "OpImageSparseSampleProjExplicitLod";
1464
    case 311: return "OpImageSparseSampleProjDrefImplicitLod";
1465
    case 312: return "OpImageSparseSampleProjDrefExplicitLod";
1466
    case 313: return "OpImageSparseFetch";
1467
    case 314: return "OpImageSparseGather";
1468
    case 315: return "OpImageSparseDrefGather";
1469
    case 316: return "OpImageSparseTexelsResident";
1470
    case 317: return "OpNoLine";
1471
    case 318: return "OpAtomicFlagTestAndSet";
1472
    case 319: return "OpAtomicFlagClear";
1473
    case 320: return "OpImageSparseRead";
1474

1475
    case (int)Op::OpModuleProcessed: return "OpModuleProcessed";
1476
    case (int)Op::OpExecutionModeId: return "OpExecutionModeId";
1477
    case (int)Op::OpDecorateId:      return "OpDecorateId";
1478

1479
    case 333: return "OpGroupNonUniformElect";
1480
    case 334: return "OpGroupNonUniformAll";
1481
    case 335: return "OpGroupNonUniformAny";
1482
    case 336: return "OpGroupNonUniformAllEqual";
1483
    case 337: return "OpGroupNonUniformBroadcast";
1484
    case 338: return "OpGroupNonUniformBroadcastFirst";
1485
    case 339: return "OpGroupNonUniformBallot";
1486
    case 340: return "OpGroupNonUniformInverseBallot";
1487
    case 341: return "OpGroupNonUniformBallotBitExtract";
1488
    case 342: return "OpGroupNonUniformBallotBitCount";
1489
    case 343: return "OpGroupNonUniformBallotFindLSB";
1490
    case 344: return "OpGroupNonUniformBallotFindMSB";
1491
    case 345: return "OpGroupNonUniformShuffle";
1492
    case 346: return "OpGroupNonUniformShuffleXor";
1493
    case 347: return "OpGroupNonUniformShuffleUp";
1494
    case 348: return "OpGroupNonUniformShuffleDown";
1495
    case 349: return "OpGroupNonUniformIAdd";
1496
    case 350: return "OpGroupNonUniformFAdd";
1497
    case 351: return "OpGroupNonUniformIMul";
1498
    case 352: return "OpGroupNonUniformFMul";
1499
    case 353: return "OpGroupNonUniformSMin";
1500
    case 354: return "OpGroupNonUniformUMin";
1501
    case 355: return "OpGroupNonUniformFMin";
1502
    case 356: return "OpGroupNonUniformSMax";
1503
    case 357: return "OpGroupNonUniformUMax";
1504
    case 358: return "OpGroupNonUniformFMax";
1505
    case 359: return "OpGroupNonUniformBitwiseAnd";
1506
    case 360: return "OpGroupNonUniformBitwiseOr";
1507
    case 361: return "OpGroupNonUniformBitwiseXor";
1508
    case 362: return "OpGroupNonUniformLogicalAnd";
1509
    case 363: return "OpGroupNonUniformLogicalOr";
1510
    case 364: return "OpGroupNonUniformLogicalXor";
1511
    case 365: return "OpGroupNonUniformQuadBroadcast";
1512
    case 366: return "OpGroupNonUniformQuadSwap";
1513

1514
    case (int)Op::OpTerminateInvocation: return "OpTerminateInvocation";
1515

1516
    case 4421: return "OpSubgroupBallotKHR";
1517
    case 4422: return "OpSubgroupFirstInvocationKHR";
1518
    case 4428: return "OpSubgroupAllKHR";
1519
    case 4429: return "OpSubgroupAnyKHR";
1520
    case 4430: return "OpSubgroupAllEqualKHR";
1521
    case 4432: return "OpSubgroupReadInvocationKHR";
1522
    case 4433: return "OpExtInstWithForwardRefsKHR";
1523

1524
    case (int)Op::OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
1525
    case (int)Op::OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
1526

1527
    case (int)Op::OpAtomicFAddEXT: return "OpAtomicFAddEXT";
1528
    case (int)Op::OpAtomicFMinEXT: return "OpAtomicFMinEXT";
1529
    case (int)Op::OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
1530

1531
    case (int)Op::OpAssumeTrueKHR: return "OpAssumeTrueKHR";
1532
    case (int)Op::OpExpectKHR: return "OpExpectKHR";
1533

1534
    case 5000: return "OpGroupIAddNonUniformAMD";
1535
    case 5001: return "OpGroupFAddNonUniformAMD";
1536
    case 5002: return "OpGroupFMinNonUniformAMD";
1537
    case 5003: return "OpGroupUMinNonUniformAMD";
1538
    case 5004: return "OpGroupSMinNonUniformAMD";
1539
    case 5005: return "OpGroupFMaxNonUniformAMD";
1540
    case 5006: return "OpGroupUMaxNonUniformAMD";
1541
    case 5007: return "OpGroupSMaxNonUniformAMD";
1542

1543
    case 5011: return "OpFragmentMaskFetchAMD";
1544
    case 5012: return "OpFragmentFetchAMD";
1545

1546
    case (int)Op::OpReadClockKHR:               return "OpReadClockKHR";
1547

1548
    case (int)Op::OpDecorateStringGOOGLE:       return "OpDecorateStringGOOGLE";
1549
    case (int)Op::OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";
1550

1551
    case (int)Op::OpReportIntersectionKHR:             return "OpReportIntersectionKHR";
1552
    case (int)Op::OpIgnoreIntersectionNV:              return "OpIgnoreIntersectionNV";
1553
    case (int)Op::OpIgnoreIntersectionKHR:             return "OpIgnoreIntersectionKHR";
1554
    case (int)Op::OpTerminateRayNV:                    return "OpTerminateRayNV";
1555
    case (int)Op::OpTerminateRayKHR:                   return "OpTerminateRayKHR";
1556
    case (int)Op::OpTraceNV:                           return "OpTraceNV";
1557
    case (int)Op::OpTraceRayMotionNV:                  return "OpTraceRayMotionNV";
1558
    case (int)Op::OpTraceRayKHR:                       return "OpTraceRayKHR";
1559
    case (int)Op::OpTypeAccelerationStructureKHR:      return "OpTypeAccelerationStructureKHR";
1560
    case (int)Op::OpExecuteCallableNV:                 return "OpExecuteCallableNV";
1561
    case (int)Op::OpExecuteCallableKHR:                return "OpExecuteCallableKHR";
1562
    case (int)Op::OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
1563

1564
    case (int)Op::OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
1565
    case (int)Op::OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
1566
    case (int)Op::OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
1567
    case (int)Op::OpEmitMeshTasksEXT:                 return "OpEmitMeshTasksEXT";
1568
    case (int)Op::OpSetMeshOutputsEXT:                return "OpSetMeshOutputsEXT";
1569

1570
    case (int)Op::OpGroupNonUniformRotateKHR:         return "OpGroupNonUniformRotateKHR";
1571

1572
    case (int)Op::OpTypeRayQueryKHR:                                                   return "OpTypeRayQueryKHR";
1573
    case (int)Op::OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
1574
    case (int)Op::OpRayQueryTerminateKHR:                                              return "OpRayQueryTerminateKHR";
1575
    case (int)Op::OpRayQueryGenerateIntersectionKHR:                                   return "OpRayQueryGenerateIntersectionKHR";
1576
    case (int)Op::OpRayQueryConfirmIntersectionKHR:                                    return "OpRayQueryConfirmIntersectionKHR";
1577
    case (int)Op::OpRayQueryProceedKHR:                                                return "OpRayQueryProceedKHR";
1578
    case (int)Op::OpRayQueryGetIntersectionTypeKHR:                                    return "OpRayQueryGetIntersectionTypeKHR";
1579
    case (int)Op::OpRayQueryGetRayTMinKHR:                                             return "OpRayQueryGetRayTMinKHR";
1580
    case (int)Op::OpRayQueryGetRayFlagsKHR:                                            return "OpRayQueryGetRayFlagsKHR";
1581
    case (int)Op::OpRayQueryGetIntersectionTKHR:                                       return "OpRayQueryGetIntersectionTKHR";
1582
    case (int)Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR:                     return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
1583
    case (int)Op::OpRayQueryGetIntersectionInstanceIdKHR:                              return "OpRayQueryGetIntersectionInstanceIdKHR";
1584
    case (int)Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:  return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
1585
    case (int)Op::OpRayQueryGetIntersectionGeometryIndexKHR:                           return "OpRayQueryGetIntersectionGeometryIndexKHR";
1586
    case (int)Op::OpRayQueryGetIntersectionPrimitiveIndexKHR:                          return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
1587
    case (int)Op::OpRayQueryGetIntersectionBarycentricsKHR:                            return "OpRayQueryGetIntersectionBarycentricsKHR";
1588
    case (int)Op::OpRayQueryGetIntersectionFrontFaceKHR:                               return "OpRayQueryGetIntersectionFrontFaceKHR";
1589
    case (int)Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:                     return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
1590
    case (int)Op::OpRayQueryGetIntersectionObjectRayDirectionKHR:                      return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
1591
    case (int)Op::OpRayQueryGetIntersectionObjectRayOriginKHR:                         return "OpRayQueryGetIntersectionObjectRayOriginKHR";
1592
    case (int)Op::OpRayQueryGetWorldRayDirectionKHR:                                   return "OpRayQueryGetWorldRayDirectionKHR";
1593
    case (int)Op::OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
1594
    case (int)Op::OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
1595
    case (int)Op::OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
1596
    case (int)Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR:                 return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
1597
    case (int)Op::OpRayQueryGetClusterIdNV:                                            return "OpRayQueryGetIntersectionClusterIdNV";
1598

1599
    case (int)Op::OpRayQueryGetIntersectionSpherePositionNV:                           return "OpRayQueryGetIntersectionSpherePositionNV";
1600
    case (int)Op::OpRayQueryGetIntersectionSphereRadiusNV:                             return "OpRayQueryGetIntersectionSphereRadiusNV";
1601
    case (int)Op::OpRayQueryGetIntersectionLSSHitValueNV:                              return "OpRayQueryGetIntersectionLSSHitValueNV";
1602
    case (int)Op::OpRayQueryGetIntersectionLSSPositionsNV:                             return "OpRayQueryGetIntersectionLSSPositionsNV";
1603
    case (int)Op::OpRayQueryGetIntersectionLSSRadiiNV:                                 return "OpRayQueryGetIntersectionLSSRadiiNV";
1604
    case (int)Op::OpRayQueryIsSphereHitNV:                                             return "OpRayQueryIsSphereHitNV";
1605
    case (int)Op::OpRayQueryIsLSSHitNV:                                                return "OpRayQueryIsLSSHitNV";
1606

1607
    case (int)Op::OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
1608
    case (int)Op::OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
1609
    case (int)Op::OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
1610
    case (int)Op::OpCooperativeMatrixMulAddNV:       return "OpCooperativeMatrixMulAddNV";
1611
    case (int)Op::OpCooperativeMatrixLengthNV:       return "OpCooperativeMatrixLengthNV";
1612
    case (int)Op::OpTypeCooperativeMatrixKHR:        return "OpTypeCooperativeMatrixKHR";
1613
    case (int)Op::OpCooperativeMatrixLoadKHR:        return "OpCooperativeMatrixLoadKHR";
1614
    case (int)Op::OpCooperativeMatrixStoreKHR:       return "OpCooperativeMatrixStoreKHR";
1615
    case (int)Op::OpCooperativeMatrixMulAddKHR:      return "OpCooperativeMatrixMulAddKHR";
1616
    case (int)Op::OpCooperativeMatrixLengthKHR:      return "OpCooperativeMatrixLengthKHR";
1617
    case (int)Op::OpDemoteToHelperInvocationEXT:     return "OpDemoteToHelperInvocationEXT";
1618
    case (int)Op::OpIsHelperInvocationEXT:           return "OpIsHelperInvocationEXT";
1619

1620
    case (int)Op::OpCooperativeMatrixConvertNV:      return "OpCooperativeMatrixConvertNV";
1621
    case (int)Op::OpCooperativeMatrixTransposeNV:    return "OpCooperativeMatrixTransposeNV";
1622
    case (int)Op::OpCooperativeMatrixReduceNV:       return "OpCooperativeMatrixReduceNV";
1623
    case (int)Op::OpCooperativeMatrixLoadTensorNV:   return "OpCooperativeMatrixLoadTensorNV";
1624
    case (int)Op::OpCooperativeMatrixStoreTensorNV:  return "OpCooperativeMatrixStoreTensorNV";
1625
    case (int)Op::OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
1626
    case (int)Op::OpTypeTensorLayoutNV:              return "OpTypeTensorLayoutNV";
1627
    case (int)Op::OpTypeTensorViewNV:                return "OpTypeTensorViewNV";
1628
    case (int)Op::OpCreateTensorLayoutNV:            return "OpCreateTensorLayoutNV";
1629
    case (int)Op::OpTensorLayoutSetBlockSizeNV:      return "OpTensorLayoutSetBlockSizeNV";
1630
    case (int)Op::OpTensorLayoutSetDimensionNV:      return "OpTensorLayoutSetDimensionNV";
1631
    case (int)Op::OpTensorLayoutSetStrideNV:         return "OpTensorLayoutSetStrideNV";
1632
    case (int)Op::OpTensorLayoutSliceNV:             return "OpTensorLayoutSliceNV";
1633
    case (int)Op::OpTensorLayoutSetClampValueNV:     return "OpTensorLayoutSetClampValueNV";
1634
    case (int)Op::OpCreateTensorViewNV:              return "OpCreateTensorViewNV";
1635
    case (int)Op::OpTensorViewSetDimensionNV:        return "OpTensorViewSetDimensionNV";
1636
    case (int)Op::OpTensorViewSetStrideNV:           return "OpTensorViewSetStrideNV";
1637
    case (int)Op::OpTensorViewSetClipNV:             return "OpTensorViewSetClipNV";
1638

1639
    case (int)Op::OpTypeTensorARM:                   return "OpTypeTensorARM";
1640
    case (int)Op::OpTensorReadARM:                   return "OpTensorReadARM";
1641
    case (int)Op::OpTensorWriteARM:                  return "OpTensorWriteARM";
1642
    case (int)Op::OpTensorQuerySizeARM:              return "OpTensorQuerySizeARM";
1643

1644
    case (int)Op::OpTypeCooperativeVectorNV:         return "OpTypeCooperativeVectorNV";
1645
    case (int)Op::OpCooperativeVectorMatrixMulNV:    return "OpCooperativeVectorMatrixMulNV";
1646
    case (int)Op::OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
1647
    case (int)Op::OpCooperativeVectorLoadNV:         return "OpCooperativeVectorLoadNV";
1648
    case (int)Op::OpCooperativeVectorStoreNV:        return "OpCooperativeVectorStoreNV";
1649
    case (int)Op::OpCooperativeVectorOuterProductAccumulateNV:   return "OpCooperativeVectorOuterProductAccumulateNV";
1650
    case (int)Op::OpCooperativeVectorReduceSumAccumulateNV:      return "OpCooperativeVectorReduceSumAccumulateNV";
1651

1652
    case (int)Op::OpBeginInvocationInterlockEXT:     return "OpBeginInvocationInterlockEXT";
1653
    case (int)Op::OpEndInvocationInterlockEXT:       return "OpEndInvocationInterlockEXT";
1654

1655
    case (int)Op::OpTypeHitObjectNV:                     return "OpTypeHitObjectNV";
1656
    case (int)Op::OpHitObjectTraceRayNV:                 return "OpHitObjectTraceRayNV";
1657
    case (int)Op::OpHitObjectTraceRayMotionNV:           return "OpHitObjectTraceRayMotionNV";
1658
    case (int)Op::OpHitObjectRecordHitNV:                return "OpHitObjectRecordHitNV";
1659
    case (int)Op::OpHitObjectRecordHitMotionNV:          return "OpHitObjectRecordHitMotionNV";
1660
    case (int)Op::OpHitObjectRecordHitWithIndexNV:       return "OpHitObjectRecordHitWithIndexNV";
1661
    case (int)Op::OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
1662
    case (int)Op::OpHitObjectRecordMissNV:               return "OpHitObjectRecordMissNV";
1663
    case (int)Op::OpHitObjectRecordMissMotionNV:         return "OpHitObjectRecordMissMotionNV";
1664
    case (int)Op::OpHitObjectRecordEmptyNV:              return "OpHitObjectRecordEmptyNV";
1665
    case (int)Op::OpHitObjectExecuteShaderNV:            return "OpHitObjectExecuteShaderNV";
1666
    case (int)Op::OpReorderThreadWithHintNV:             return "OpReorderThreadWithHintNV";
1667
    case (int)Op::OpReorderThreadWithHitObjectNV:        return "OpReorderThreadWithHitObjectNV";
1668
    case (int)Op::OpHitObjectGetCurrentTimeNV:           return "OpHitObjectGetCurrentTimeNV";
1669
    case (int)Op::OpHitObjectGetAttributesNV:            return "OpHitObjectGetAttributesNV";
1670
    case (int)Op::OpHitObjectGetHitKindNV:               return "OpHitObjectGetFrontFaceNV";
1671
    case (int)Op::OpHitObjectGetPrimitiveIndexNV:        return "OpHitObjectGetPrimitiveIndexNV";
1672
    case (int)Op::OpHitObjectGetGeometryIndexNV:         return "OpHitObjectGetGeometryIndexNV";
1673
    case (int)Op::OpHitObjectGetInstanceIdNV:            return "OpHitObjectGetInstanceIdNV";
1674
    case (int)Op::OpHitObjectGetInstanceCustomIndexNV:   return "OpHitObjectGetInstanceCustomIndexNV";
1675
    case (int)Op::OpHitObjectGetObjectRayDirectionNV:    return "OpHitObjectGetObjectRayDirectionNV";
1676
    case (int)Op::OpHitObjectGetObjectRayOriginNV:       return "OpHitObjectGetObjectRayOriginNV";
1677
    case (int)Op::OpHitObjectGetWorldRayDirectionNV:     return "OpHitObjectGetWorldRayDirectionNV";
1678
    case (int)Op::OpHitObjectGetWorldRayOriginNV:        return "OpHitObjectGetWorldRayOriginNV";
1679
    case (int)Op::OpHitObjectGetWorldToObjectNV:         return "OpHitObjectGetWorldToObjectNV";
1680
    case (int)Op::OpHitObjectGetObjectToWorldNV:         return "OpHitObjectGetObjectToWorldNV";
1681
    case (int)Op::OpHitObjectGetRayTMaxNV:               return "OpHitObjectGetRayTMaxNV";
1682
    case (int)Op::OpHitObjectGetRayTMinNV:               return "OpHitObjectGetRayTMinNV";
1683
    case (int)Op::OpHitObjectIsEmptyNV:                  return "OpHitObjectIsEmptyNV";
1684
    case (int)Op::OpHitObjectIsHitNV:                    return "OpHitObjectIsHitNV";
1685
    case (int)Op::OpHitObjectIsMissNV:                   return "OpHitObjectIsMissNV";
1686
    case (int)Op::OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
1687
    case (int)Op::OpHitObjectGetShaderRecordBufferHandleNV:   return "OpHitObjectGetShaderRecordBufferHandleNV";
1688
    case (int)Op::OpHitObjectGetClusterIdNV:             return "OpHitObjectGetClusterIdNV";
1689
    case (int)Op::OpHitObjectGetSpherePositionNV:        return "OpHitObjectGetSpherePositionNV";
1690
    case (int)Op::OpHitObjectGetSphereRadiusNV:          return "OpHitObjectGetSphereRadiusNV";
1691
    case (int)Op::OpHitObjectGetLSSPositionsNV:          return "OpHitObjectGetLSSPositionsNV";
1692
    case (int)Op::OpHitObjectGetLSSRadiiNV:              return "OpHitObjectGetLSSRadiiNV";
1693
    case (int)Op::OpHitObjectIsSphereHitNV:              return "OpHitObjectIsSphereHitNV";
1694
    case (int)Op::OpHitObjectIsLSSHitNV:                 return "OpHitObjectIsLSSHitNV";
1695

1696
    case (int)Op::OpFetchMicroTriangleVertexBarycentricNV:       return "OpFetchMicroTriangleVertexBarycentricNV";
1697
    case (int)Op::OpFetchMicroTriangleVertexPositionNV:    return "OpFetchMicroTriangleVertexPositionNV";
1698

1699
    case (int)Op::OpColorAttachmentReadEXT:          return "OpColorAttachmentReadEXT";
1700
    case (int)Op::OpDepthAttachmentReadEXT:          return "OpDepthAttachmentReadEXT";
1701
    case (int)Op::OpStencilAttachmentReadEXT:        return "OpStencilAttachmentReadEXT";
1702

1703
    case (int)Op::OpImageSampleWeightedQCOM:         return "OpImageSampleWeightedQCOM";
1704
    case (int)Op::OpImageBoxFilterQCOM:              return "OpImageBoxFilterQCOM";
1705
    case (int)Op::OpImageBlockMatchSADQCOM:          return "OpImageBlockMatchSADQCOM";
1706
    case (int)Op::OpImageBlockMatchSSDQCOM:          return "OpImageBlockMatchSSDQCOM";
1707
    case (int)Op::OpImageBlockMatchWindowSSDQCOM:    return "OpImageBlockMatchWindowSSDQCOM";
1708
    case (int)Op::OpImageBlockMatchWindowSADQCOM:    return "OpImageBlockMatchWindowSADQCOM";
1709
    case (int)Op::OpImageBlockMatchGatherSSDQCOM:    return "OpImageBlockMatchGatherSSDQCOM";
1710
    case (int)Op::OpImageBlockMatchGatherSADQCOM:    return "OpImageBlockMatchGatherSADQCOM";
1711

1712
    case (int)Op::OpBitCastArrayQCOM:                return "OpBitCastArrayQCOM";
1713
    case (int)Op::OpCompositeConstructCoopMatQCOM:   return "OpCompositeConstructCoopMatQCOM";
1714
    case (int)Op::OpCompositeExtractCoopMatQCOM:     return "OpCompositeExtractCoopMatQCOM";
1715
    case (int)Op::OpExtractSubArrayQCOM:             return "OpExtractSubArrayQCOM";
1716

1717
    case (int)Op::OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
1718
    case (int)Op::OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
1719
    case (int)Op::OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
1720

1721
    case (int)Op::OpSDotKHR: return "OpSDotKHR";
1722
    case (int)Op::OpUDotKHR: return "OpUDotKHR";
1723
    case (int)Op::OpSUDotKHR: return "OpSUDotKHR";
1724
    case (int)Op::OpSDotAccSatKHR: return "OpSDotAccSatKHR";
1725
    case (int)Op::OpUDotAccSatKHR: return "OpUDotAccSatKHR";
1726
    case (int)Op::OpSUDotAccSatKHR: return "OpSUDotAccSatKHR";
1727

1728
    case (int)Op::OpTypeHitObjectEXT:                     return "OpTypeHitObjectEXT";
1729
    case (int)Op::OpHitObjectTraceRayEXT:                 return "OpHitObjectTraceRayEXT";
1730
    case (int)Op::OpHitObjectTraceRayMotionEXT:           return "OpHitObjectTraceRayMotionEXT";
1731
    case (int)Op::OpHitObjectRecordMissEXT:               return "OpHitObjectRecordMissEXT";
1732
    case (int)Op::OpHitObjectRecordMissMotionEXT:         return "OpHitObjectRecordMissMotionEXT";
1733
    case (int)Op::OpHitObjectRecordEmptyEXT:              return "OpHitObjectRecordEmptyEXT";
1734
    case (int)Op::OpHitObjectExecuteShaderEXT:            return "OpHitObjectExecuteShaderEXT";
1735
    case (int)Op::OpReorderThreadWithHintEXT:             return "OpReorderThreadWithHintEXT";
1736
    case (int)Op::OpReorderThreadWithHitObjectEXT:        return "OpReorderThreadWithHitObjectEXT";
1737
    case (int)Op::OpHitObjectGetCurrentTimeEXT:           return "OpHitObjectGetCurrentTimeEXT";
1738
    case (int)Op::OpHitObjectGetAttributesEXT:            return "OpHitObjectGetAttributesEXT";
1739
    case (int)Op::OpHitObjectGetHitKindEXT:               return "OpHitObjectGetHitKindEXT";
1740
    case (int)Op::OpHitObjectGetPrimitiveIndexEXT:        return "OpHitObjectGetPrimitiveIndexEXT";
1741
    case (int)Op::OpHitObjectGetGeometryIndexEXT:         return "OpHitObjectGetGeometryIndexEXT";
1742
    case (int)Op::OpHitObjectGetInstanceIdEXT:            return "OpHitObjectGetInstanceIdEXT";
1743
    case (int)Op::OpHitObjectGetInstanceCustomIndexEXT:   return "OpHitObjectGetInstanceCustomIndexEXT";
1744
    case (int)Op::OpHitObjectGetObjectRayDirectionEXT:    return "OpHitObjectGetObjectRayDirectionEXT";
1745
    case (int)Op::OpHitObjectGetObjectRayOriginEXT:       return "OpHitObjectGetObjectRayOriginEXT";
1746
    case (int)Op::OpHitObjectGetWorldRayDirectionEXT:     return "OpHitObjectGetWorldRayDirectionEXT";
1747
    case (int)Op::OpHitObjectGetWorldRayOriginEXT:        return "OpHitObjectGetWorldRayOriginEXT";
1748
    case (int)Op::OpHitObjectGetWorldToObjectEXT:         return "OpHitObjectGetWorldToObjectEXT";
1749
    case (int)Op::OpHitObjectGetObjectToWorldEXT:         return "OpHitObjectGetObjectToWorldEXT";
1750
    case (int)Op::OpHitObjectGetRayTMaxEXT:               return "OpHitObjectGetRayTMaxEXT";
1751
    case (int)Op::OpHitObjectGetRayTMinEXT:               return "OpHitObjectGetRayTMinEXT";
1752
    case (int)Op::OpHitObjectGetRayFlagsEXT:              return "OpHitObjectGetRayFlagsEXT";
1753
    case (int)Op::OpHitObjectIsEmptyEXT:                  return "OpHitObjectIsEmptyEXT";
1754
    case (int)Op::OpHitObjectIsHitEXT:                    return "OpHitObjectIsHitEXT";
1755
    case (int)Op::OpHitObjectIsMissEXT:                   return "OpHitObjectIsMissEXT";
1756
    case (int)Op::OpHitObjectGetShaderBindingTableRecordIndexEXT: return "OpHitObjectGetShaderBindingTableRecordIndexEXT";
1757
    case (int)Op::OpHitObjectGetShaderRecordBufferHandleEXT:   return "OpHitObjectGetShaderRecordBufferHandleEXT";
1758
    case (int)Op::OpHitObjectSetShaderBindingTableRecordIndexEXT: return "OpHitObjectSetShaderBindingTableRecordIndexEXT";
1759
    case (int)Op::OpHitObjectReorderExecuteShaderEXT:     return "OpHitObjectReorderExecuteEXT";
1760
    case (int)Op::OpHitObjectTraceReorderExecuteEXT:      return "OpHitObjectTraceReorderExecuteEXT";
1761
    case (int)Op::OpHitObjectTraceMotionReorderExecuteEXT: return "OpHitObjectTraceMotionReorderExecuteEXT";
1762
    case (int)Op::OpHitObjectRecordFromQueryEXT:          return "OpHitObjectRecordFromQueryEXT";
1763
    case (int)Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT: return "OpHitObjectGetIntersectionTriangleVertexPositionsEXT";
1764

1765
    default:
1766
        return "Bad";
1767
    }
1768
}
1769

1770
// The set of objects that hold all the instruction/operand
1771
// parameterization information.
1772
InstructionParameters InstructionDesc[OpCodeMask + 1];
1773
OperandParameters ExecutionModeOperands[ExecutionModeCeiling];
1774
OperandParameters DecorationOperands[DecorationCeiling];
1775

1776
EnumDefinition OperandClassParams[OperandCount];
1777
EnumParameters ExecutionModeParams[ExecutionModeCeiling];
1778
EnumParameters ImageOperandsParams[ImageOperandsCeiling];
1779
EnumParameters DecorationParams[DecorationCeiling];
1780
EnumParameters LoopControlParams[FunctionControlCeiling];
1781
EnumParameters SelectionControlParams[SelectControlCeiling];
1782
EnumParameters FunctionControlParams[FunctionControlCeiling];
1783
EnumParameters MemoryAccessParams[MemoryAccessCeiling];
1784
EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling];
1785
EnumParameters TensorAddressingOperandsParams[TensorAddressingOperandsCeiling];
1786

1787
// Set up all the parameterizing descriptions of the opcodes, operands, etc.
1788
void Parameterize()
1789
{
1790
    // only do this once.
1791
    static std::once_flag initialized;
1792
    std::call_once(initialized, [](){
1793

1794
        // Exceptions to having a result <id> and a resulting type <id>.
1795
        // (Everything is initialized to have both).
1796

1797
        InstructionDesc[enumCast(Op::OpNop)].setResultAndType(false, false);
1798
        InstructionDesc[enumCast(Op::OpSource)].setResultAndType(false, false);
1799
        InstructionDesc[enumCast(Op::OpSourceContinued)].setResultAndType(false, false);
1800
        InstructionDesc[enumCast(Op::OpSourceExtension)].setResultAndType(false, false);
1801
        InstructionDesc[enumCast(Op::OpExtension)].setResultAndType(false, false);
1802
        InstructionDesc[enumCast(Op::OpExtInstImport)].setResultAndType(true, false);
1803
        InstructionDesc[enumCast(Op::OpCapability)].setResultAndType(false, false);
1804
        InstructionDesc[enumCast(Op::OpMemoryModel)].setResultAndType(false, false);
1805
        InstructionDesc[enumCast(Op::OpEntryPoint)].setResultAndType(false, false);
1806
        InstructionDesc[enumCast(Op::OpExecutionMode)].setResultAndType(false, false);
1807
        InstructionDesc[enumCast(Op::OpExecutionModeId)].setResultAndType(false, false);
1808
        InstructionDesc[enumCast(Op::OpTypeVoid)].setResultAndType(true, false);
1809
        InstructionDesc[enumCast(Op::OpTypeBool)].setResultAndType(true, false);
1810
        InstructionDesc[enumCast(Op::OpTypeInt)].setResultAndType(true, false);
1811
        InstructionDesc[enumCast(Op::OpTypeFloat)].setResultAndType(true, false);
1812
        InstructionDesc[enumCast(Op::OpTypeVector)].setResultAndType(true, false);
1813
        InstructionDesc[enumCast(Op::OpTypeMatrix)].setResultAndType(true, false);
1814
        InstructionDesc[enumCast(Op::OpTypeImage)].setResultAndType(true, false);
1815
        InstructionDesc[enumCast(Op::OpTypeSampler)].setResultAndType(true, false);
1816
        InstructionDesc[enumCast(Op::OpTypeSampledImage)].setResultAndType(true, false);
1817
        InstructionDesc[enumCast(Op::OpTypeArray)].setResultAndType(true, false);
1818
        InstructionDesc[enumCast(Op::OpTypeRuntimeArray)].setResultAndType(true, false);
1819
        InstructionDesc[enumCast(Op::OpTypeStruct)].setResultAndType(true, false);
1820
        InstructionDesc[enumCast(Op::OpTypeOpaque)].setResultAndType(true, false);
1821
        InstructionDesc[enumCast(Op::OpTypePointer)].setResultAndType(true, false);
1822
        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].setResultAndType(false, false);
1823
        InstructionDesc[enumCast(Op::OpTypeFunction)].setResultAndType(true, false);
1824
        InstructionDesc[enumCast(Op::OpTypeEvent)].setResultAndType(true, false);
1825
        InstructionDesc[enumCast(Op::OpTypeDeviceEvent)].setResultAndType(true, false);
1826
        InstructionDesc[enumCast(Op::OpTypeReserveId)].setResultAndType(true, false);
1827
        InstructionDesc[enumCast(Op::OpTypeQueue)].setResultAndType(true, false);
1828
        InstructionDesc[enumCast(Op::OpTypePipe)].setResultAndType(true, false);
1829
        InstructionDesc[enumCast(Op::OpFunctionEnd)].setResultAndType(false, false);
1830
        InstructionDesc[enumCast(Op::OpStore)].setResultAndType(false, false);
1831
        InstructionDesc[enumCast(Op::OpImageWrite)].setResultAndType(false, false);
1832
        InstructionDesc[enumCast(Op::OpDecorationGroup)].setResultAndType(true, false);
1833
        InstructionDesc[enumCast(Op::OpDecorate)].setResultAndType(false, false);
1834
        InstructionDesc[enumCast(Op::OpDecorateId)].setResultAndType(false, false);
1835
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].setResultAndType(false, false);
1836
        InstructionDesc[enumCast(Op::OpMemberDecorate)].setResultAndType(false, false);
1837
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].setResultAndType(false, false);
1838
        InstructionDesc[enumCast(Op::OpGroupDecorate)].setResultAndType(false, false);
1839
        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].setResultAndType(false, false);
1840
        InstructionDesc[enumCast(Op::OpName)].setResultAndType(false, false);
1841
        InstructionDesc[enumCast(Op::OpMemberName)].setResultAndType(false, false);
1842
        InstructionDesc[enumCast(Op::OpString)].setResultAndType(true, false);
1843
        InstructionDesc[enumCast(Op::OpLine)].setResultAndType(false, false);
1844
        InstructionDesc[enumCast(Op::OpNoLine)].setResultAndType(false, false);
1845
        InstructionDesc[enumCast(Op::OpCopyMemory)].setResultAndType(false, false);
1846
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].setResultAndType(false, false);
1847
        InstructionDesc[enumCast(Op::OpEmitVertex)].setResultAndType(false, false);
1848
        InstructionDesc[enumCast(Op::OpEndPrimitive)].setResultAndType(false, false);
1849
        InstructionDesc[enumCast(Op::OpEmitStreamVertex)].setResultAndType(false, false);
1850
        InstructionDesc[enumCast(Op::OpEndStreamPrimitive)].setResultAndType(false, false);
1851
        InstructionDesc[enumCast(Op::OpControlBarrier)].setResultAndType(false, false);
1852
        InstructionDesc[enumCast(Op::OpMemoryBarrier)].setResultAndType(false, false);
1853
        InstructionDesc[enumCast(Op::OpAtomicStore)].setResultAndType(false, false);
1854
        InstructionDesc[enumCast(Op::OpLoopMerge)].setResultAndType(false, false);
1855
        InstructionDesc[enumCast(Op::OpSelectionMerge)].setResultAndType(false, false);
1856
        InstructionDesc[enumCast(Op::OpLabel)].setResultAndType(true, false);
1857
        InstructionDesc[enumCast(Op::OpBranch)].setResultAndType(false, false);
1858
        InstructionDesc[enumCast(Op::OpBranchConditional)].setResultAndType(false, false);
1859
        InstructionDesc[enumCast(Op::OpSwitch)].setResultAndType(false, false);
1860
        InstructionDesc[enumCast(Op::OpKill)].setResultAndType(false, false);
1861
        InstructionDesc[enumCast(Op::OpTerminateInvocation)].setResultAndType(false, false);
1862
        InstructionDesc[enumCast(Op::OpReturn)].setResultAndType(false, false);
1863
        InstructionDesc[enumCast(Op::OpReturnValue)].setResultAndType(false, false);
1864
        InstructionDesc[enumCast(Op::OpUnreachable)].setResultAndType(false, false);
1865
        InstructionDesc[enumCast(Op::OpLifetimeStart)].setResultAndType(false, false);
1866
        InstructionDesc[enumCast(Op::OpLifetimeStop)].setResultAndType(false, false);
1867
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].setResultAndType(false, false);
1868
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].setResultAndType(false, false);
1869
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].setResultAndType(false, false);
1870
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].setResultAndType(false, false);
1871
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].setResultAndType(false, false);
1872
        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].setResultAndType(false, false);
1873
        InstructionDesc[enumCast(Op::OpRetainEvent)].setResultAndType(false, false);
1874
        InstructionDesc[enumCast(Op::OpReleaseEvent)].setResultAndType(false, false);
1875
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].setResultAndType(false, false);
1876
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].setResultAndType(false, false);
1877
        InstructionDesc[enumCast(Op::OpModuleProcessed)].setResultAndType(false, false);
1878
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].setResultAndType(true, false);
1879
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].setResultAndType(false, false);
1880
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].setResultAndType(true, false);
1881
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].setResultAndType(false, false);
1882
        InstructionDesc[enumCast(Op::OpBeginInvocationInterlockEXT)].setResultAndType(false, false);
1883
        InstructionDesc[enumCast(Op::OpEndInvocationInterlockEXT)].setResultAndType(false, false);
1884
        InstructionDesc[enumCast(Op::OpAssumeTrueKHR)].setResultAndType(false, false);
1885
        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].setResultAndType(true, false);
1886
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].setResultAndType(true, false);
1887
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].setResultAndType(false, false);
1888
        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].setResultAndType(true, false);
1889
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].setResultAndType(false, false);
1890
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].setResultAndType(false, false);
1891
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].setResultAndType(false, false);
1892

1893
        InstructionDesc[enumCast(Op::OpTypeTensorARM)].setResultAndType(true, false);
1894
        InstructionDesc[enumCast(Op::OpTensorReadARM)].setResultAndType(true, true);
1895
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].setResultAndType(false, false);
1896

1897
        // Specific additional context-dependent operands
1898

1899
        ExecutionModeOperands[enumCast(ExecutionMode::Invocations)].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
1900

1901
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'x size'");
1902
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'y size'");
1903
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'z size'");
1904

1905
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'x size'");
1906
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'y size'");
1907
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'z size'");
1908

1909
        ExecutionModeOperands[enumCast(ExecutionMode::OutputVertices)].push(OperandLiteralNumber, "'Vertex count'");
1910
        ExecutionModeOperands[enumCast(ExecutionMode::VecTypeHint)].push(OperandLiteralNumber, "'Vector type'");
1911

1912
        DecorationOperands[enumCast(Decoration::Stream)].push(OperandLiteralNumber, "'Stream Number'");
1913
        DecorationOperands[enumCast(Decoration::Location)].push(OperandLiteralNumber, "'Location'");
1914
        DecorationOperands[enumCast(Decoration::Component)].push(OperandLiteralNumber, "'Component'");
1915
        DecorationOperands[enumCast(Decoration::Index)].push(OperandLiteralNumber, "'Index'");
1916
        DecorationOperands[enumCast(Decoration::Binding)].push(OperandLiteralNumber, "'Binding Point'");
1917
        DecorationOperands[enumCast(Decoration::DescriptorSet)].push(OperandLiteralNumber, "'Descriptor Set'");
1918
        DecorationOperands[enumCast(Decoration::Offset)].push(OperandLiteralNumber, "'Byte Offset'");
1919
        DecorationOperands[enumCast(Decoration::XfbBuffer)].push(OperandLiteralNumber, "'XFB Buffer Number'");
1920
        DecorationOperands[enumCast(Decoration::XfbStride)].push(OperandLiteralNumber, "'XFB Stride'");
1921
        DecorationOperands[enumCast(Decoration::ArrayStride)].push(OperandLiteralNumber, "'Array Stride'");
1922
        DecorationOperands[enumCast(Decoration::MatrixStride)].push(OperandLiteralNumber, "'Matrix Stride'");
1923
        DecorationOperands[enumCast(Decoration::BuiltIn)].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
1924
        DecorationOperands[enumCast(Decoration::FPRoundingMode)].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
1925
        DecorationOperands[enumCast(Decoration::FPFastMathMode)].push(OperandFPFastMath, "'Fast-Math Mode'");
1926
        DecorationOperands[enumCast(Decoration::LinkageAttributes)].push(OperandLiteralString, "'Name'");
1927
        DecorationOperands[enumCast(Decoration::LinkageAttributes)].push(OperandLinkageType, "'Linkage Type'");
1928
        DecorationOperands[enumCast(Decoration::FuncParamAttr)].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
1929
        DecorationOperands[enumCast(Decoration::SpecId)].push(OperandLiteralNumber, "'Specialization Constant ID'");
1930
        DecorationOperands[enumCast(Decoration::InputAttachmentIndex)].push(OperandLiteralNumber, "'Attachment Index'");
1931
        DecorationOperands[enumCast(Decoration::Alignment)].push(OperandLiteralNumber, "'Alignment'");
1932

1933
        OperandClassParams[OperandSource].set(0, SourceString, nullptr);
1934
        OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
1935
        OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
1936
        OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
1937
        OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
1938
        OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
1939
        OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
1940
        OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
1941
        OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
1942
        OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
1943
        OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
1944
        OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
1945
        OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
1946
        OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
1947
        OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
1948
        OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
1949
        OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
1950
        OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
1951
        OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
1952
        OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
1953
        OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
1954
        OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
1955
        OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
1956
        OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
1957
        OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
1958
        OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
1959
        OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
1960
        OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
1961
        OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
1962
        OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
1963
        OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
1964
        OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
1965
        OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true);
1966
        OperandClassParams[OperandTensorAddressingOperands].set(TensorAddressingOperandsCeiling, TensorAddressingOperandsString, TensorAddressingOperandsParams, true);
1967
        OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);
1968

1969
        // set name of operator, an initial set of <id> style operands, and the description
1970

1971
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandSource, "");
1972
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandLiteralNumber, "'Version'");
1973
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandId, "'File'", true);
1974
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandLiteralString, "'Source'", true);
1975

1976
        InstructionDesc[enumCast(Op::OpSourceContinued)].operands.push(OperandLiteralString, "'Continued Source'");
1977

1978
        InstructionDesc[enumCast(Op::OpSourceExtension)].operands.push(OperandLiteralString, "'Extension'");
1979

1980
        InstructionDesc[enumCast(Op::OpName)].operands.push(OperandId, "'Target'");
1981
        InstructionDesc[enumCast(Op::OpName)].operands.push(OperandLiteralString, "'Name'");
1982

1983
        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandId, "'Type'");
1984
        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandLiteralNumber, "'Member'");
1985
        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandLiteralString, "'Name'");
1986

1987
        InstructionDesc[enumCast(Op::OpString)].operands.push(OperandLiteralString, "'String'");
1988

1989
        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandId, "'File'");
1990
        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandLiteralNumber, "'Line'");
1991
        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandLiteralNumber, "'Column'");
1992

1993
        InstructionDesc[enumCast(Op::OpExtension)].operands.push(OperandLiteralString, "'Name'");
1994

1995
        InstructionDesc[enumCast(Op::OpExtInstImport)].operands.push(OperandLiteralString, "'Name'");
1996

1997
        InstructionDesc[enumCast(Op::OpCapability)].operands.push(OperandCapability, "'Capability'");
1998

1999
        InstructionDesc[enumCast(Op::OpMemoryModel)].operands.push(OperandAddressing, "");
2000
        InstructionDesc[enumCast(Op::OpMemoryModel)].operands.push(OperandMemory, "");
2001

2002
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandExecutionModel, "");
2003
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandId, "'Entry Point'");
2004
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandLiteralString, "'Name'");
2005
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandVariableIds, "'Interface'");
2006

2007
        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandId, "'Entry Point'");
2008
        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandExecutionMode, "'Mode'");
2009
        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");
2010

2011
        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandId, "'Entry Point'");
2012
        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandExecutionMode, "'Mode'");
2013
        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");
2014

2015
        InstructionDesc[enumCast(Op::OpTypeInt)].operands.push(OperandLiteralNumber, "'Width'");
2016
        InstructionDesc[enumCast(Op::OpTypeInt)].operands.push(OperandLiteralNumber, "'Signedness'");
2017

2018
        InstructionDesc[enumCast(Op::OpTypeFloat)].operands.push(OperandLiteralNumber, "'Width'");
2019
        InstructionDesc[enumCast(Op::OpTypeFloat)].operands.push(OperandOptionalLiteral, "'FP Encoding'");
2020

2021
        InstructionDesc[enumCast(Op::OpTypeVector)].operands.push(OperandId, "'Component Type'");
2022
        InstructionDesc[enumCast(Op::OpTypeVector)].operands.push(OperandLiteralNumber, "'Component Count'");
2023

2024
        InstructionDesc[enumCast(Op::OpTypeMatrix)].operands.push(OperandId, "'Column Type'");
2025
        InstructionDesc[enumCast(Op::OpTypeMatrix)].operands.push(OperandLiteralNumber, "'Column Count'");
2026

2027
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandId, "'Sampled Type'");
2028
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandDimensionality, "");
2029
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Depth'");
2030
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Arrayed'");
2031
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'MS'");
2032
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Sampled'");
2033
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandSamplerImageFormat, "");
2034
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandAccessQualifier, "", true);
2035

2036
        InstructionDesc[enumCast(Op::OpTypeSampledImage)].operands.push(OperandId, "'Image Type'");
2037

2038
        InstructionDesc[enumCast(Op::OpTypeArray)].operands.push(OperandId, "'Element Type'");
2039
        InstructionDesc[enumCast(Op::OpTypeArray)].operands.push(OperandId, "'Length'");
2040

2041
        InstructionDesc[enumCast(Op::OpTypeRuntimeArray)].operands.push(OperandId, "'Element Type'");
2042

2043
        InstructionDesc[enumCast(Op::OpTypeStruct)].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
2044

2045
        InstructionDesc[enumCast(Op::OpTypeOpaque)].operands.push(OperandLiteralString, "The name of the opaque type.");
2046

2047
        InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandStorage, "");
2048
        InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandId, "'Type'");
2049

2050
        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].operands.push(OperandId, "'Pointer Type'");
2051
        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].operands.push(OperandStorage, "");
2052

2053
        InstructionDesc[enumCast(Op::OpTypePipe)].operands.push(OperandAccessQualifier, "'Qualifier'");
2054

2055
        InstructionDesc[enumCast(Op::OpTypeFunction)].operands.push(OperandId, "'Return Type'");
2056
        InstructionDesc[enumCast(Op::OpTypeFunction)].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");
2057

2058
        InstructionDesc[enumCast(Op::OpConstant)].operands.push(OperandVariableLiterals, "'Value'");
2059

2060
        InstructionDesc[enumCast(Op::OpConstantComposite)].operands.push(OperandVariableIds, "'Constituents'");
2061

2062
        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandSamplerAddressingMode, "");
2063
        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandLiteralNumber, "'Param'");
2064
        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandSamplerFilterMode, "");
2065

2066
        InstructionDesc[enumCast(Op::OpSpecConstant)].operands.push(OperandVariableLiterals, "'Value'");
2067

2068
        InstructionDesc[enumCast(Op::OpSpecConstantComposite)].operands.push(OperandVariableIds, "'Constituents'");
2069

2070
        InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandLiteralNumber, "'Opcode'");
2071
        InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandVariableIds, "'Operands'");
2072

2073
        InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandStorage, "");
2074
        InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandId, "'Initializer'", true);
2075

2076
        InstructionDesc[enumCast(Op::OpFunction)].operands.push(OperandFunction, "");
2077
        InstructionDesc[enumCast(Op::OpFunction)].operands.push(OperandId, "'Function Type'");
2078

2079
        InstructionDesc[enumCast(Op::OpFunctionCall)].operands.push(OperandId, "'Function'");
2080
        InstructionDesc[enumCast(Op::OpFunctionCall)].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");
2081

2082
        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandId, "'Set'");
2083
        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandLiteralNumber, "'Instruction'");
2084
        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
2085

2086
        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandId, "'Set'");
2087
        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandLiteralNumber, "'Instruction'");
2088
        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
2089

2090
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandId, "'Pointer'");
2091
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandMemoryAccess, "", true);
2092
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandLiteralNumber, "", true);
2093
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandId, "", true);
2094

2095
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "'Pointer'");
2096
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "'Object'");
2097
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandMemoryAccess, "", true);
2098
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandLiteralNumber, "", true);
2099
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "", true);
2100

2101
        InstructionDesc[enumCast(Op::OpPhi)].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
2102

2103
        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandId, "'Target'");
2104
        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandDecoration, "");
2105
        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
2106

2107
        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandId, "'Target'");
2108
        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandDecoration, "");
2109
        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
2110

2111
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandId, "'Target'");
2112
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandDecoration, "");
2113
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
2114

2115
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandId, "'Structure Type'");
2116
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandLiteralNumber, "'Member'");
2117
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandDecoration, "");
2118
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
2119

2120
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandId, "'Structure Type'");
2121
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandLiteralNumber, "'Member'");
2122
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandDecoration, "");
2123
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
2124

2125
        InstructionDesc[enumCast(Op::OpGroupDecorate)].operands.push(OperandId, "'Decoration Group'");
2126
        InstructionDesc[enumCast(Op::OpGroupDecorate)].operands.push(OperandVariableIds, "'Targets'");
2127

2128
        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].operands.push(OperandId, "'Decoration Group'");
2129
        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].operands.push(OperandVariableIdLiteral, "'Targets'");
2130

2131
        InstructionDesc[enumCast(Op::OpVectorExtractDynamic)].operands.push(OperandId, "'Vector'");
2132
        InstructionDesc[enumCast(Op::OpVectorExtractDynamic)].operands.push(OperandId, "'Index'");
2133

2134
        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Vector'");
2135
        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Component'");
2136
        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Index'");
2137

2138
        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandId, "'Vector 1'");
2139
        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandId, "'Vector 2'");
2140
        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandVariableLiterals, "'Components'");
2141

2142
        InstructionDesc[enumCast(Op::OpCompositeConstruct)].operands.push(OperandVariableIds, "'Constituents'");
2143

2144
        InstructionDesc[enumCast(Op::OpCompositeExtract)].operands.push(OperandId, "'Composite'");
2145
        InstructionDesc[enumCast(Op::OpCompositeExtract)].operands.push(OperandVariableLiterals, "'Indexes'");
2146

2147
        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandId, "'Object'");
2148
        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandId, "'Composite'");
2149
        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandVariableLiterals, "'Indexes'");
2150

2151
        InstructionDesc[enumCast(Op::OpCopyObject)].operands.push(OperandId, "'Operand'");
2152

2153
        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandId, "'Target'");
2154
        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandId, "'Source'");
2155
        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandMemoryAccess, "", true);
2156

2157
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Target'");
2158
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Source'");
2159
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Size'");
2160
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandMemoryAccess, "", true);
2161

2162
        InstructionDesc[enumCast(Op::OpSampledImage)].operands.push(OperandId, "'Image'");
2163
        InstructionDesc[enumCast(Op::OpSampledImage)].operands.push(OperandId, "'Sampler'");
2164

2165
        InstructionDesc[enumCast(Op::OpImage)].operands.push(OperandId, "'Sampled Image'");
2166

2167
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandId, "'Image'");
2168
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandId, "'Coordinate'");
2169
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandImageOperands, "", true);
2170
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandVariableIds, "", true);
2171

2172
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Image'");
2173
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Coordinate'");
2174
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Texel'");
2175
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandImageOperands, "", true);
2176
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandVariableIds, "", true);
2177

2178
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2179
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandId, "'Coordinate'");
2180
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandImageOperands, "", true);
2181
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandVariableIds, "", true);
2182

2183
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2184
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandId, "'Coordinate'");
2185
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandImageOperands, "", true);
2186
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandVariableIds, "", true);
2187

2188
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2189
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
2190
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
2191
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
2192
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandVariableIds, "", true);
2193

2194
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2195
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
2196
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
2197
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
2198
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandVariableIds, "", true);
2199

2200
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2201
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandId, "'Coordinate'");
2202
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandImageOperands, "", true);
2203
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandVariableIds, "", true);
2204

2205
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2206
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandId, "'Coordinate'");
2207
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandImageOperands, "", true);
2208
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandVariableIds, "", true);
2209

2210
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2211
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
2212
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
2213
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
2214
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandVariableIds, "", true);
2215

2216
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2217
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
2218
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
2219
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
2220
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandVariableIds, "", true);
2221

2222
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandId, "'Image'");
2223
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandId, "'Coordinate'");
2224
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandImageOperands, "", true);
2225
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandVariableIds, "", true);
2226

2227
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Sampled Image'");
2228
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Coordinate'");
2229
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Component'");
2230
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandImageOperands, "", true);
2231
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandVariableIds, "", true);
2232

2233
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'Sampled Image'");
2234
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'Coordinate'");
2235
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'D~ref~'");
2236
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandImageOperands, "", true);
2237
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandVariableIds, "", true);
2238

2239
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2240
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandId, "'Coordinate'");
2241
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandImageOperands, "", true);
2242
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandVariableIds, "", true);
2243

2244
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2245
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandId, "'Coordinate'");
2246
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandImageOperands, "", true);
2247
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandVariableIds, "", true);
2248

2249
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2250
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
2251
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
2252
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
2253
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandVariableIds, "", true);
2254

2255
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2256
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
2257
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
2258
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
2259
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandVariableIds, "", true);
2260

2261
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2262
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandId, "'Coordinate'");
2263
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandImageOperands, "", true);
2264
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandVariableIds, "", true);
2265

2266
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2267
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandId, "'Coordinate'");
2268
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandImageOperands, "", true);
2269
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandVariableIds, "", true);
2270

2271
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
2272
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
2273
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
2274
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
2275
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandVariableIds, "", true);
2276

2277
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
2278
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
2279
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
2280
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
2281
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandVariableIds, "", true);
2282

2283
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandId, "'Image'");
2284
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandId, "'Coordinate'");
2285
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandImageOperands, "", true);
2286
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandVariableIds, "", true);
2287

2288
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Sampled Image'");
2289
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Coordinate'");
2290
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Component'");
2291
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandImageOperands, "", true);
2292
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandVariableIds, "", true);
2293

2294
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'Sampled Image'");
2295
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'Coordinate'");
2296
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'D~ref~'");
2297
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandImageOperands, "", true);
2298
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandVariableIds, "", true);
2299

2300
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandId, "'Image'");
2301
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandId, "'Coordinate'");
2302
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandImageOperands, "", true);
2303
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandVariableIds, "", true);
2304

2305
        InstructionDesc[enumCast(Op::OpImageSparseTexelsResident)].operands.push(OperandId, "'Resident Code'");
2306

2307
        InstructionDesc[enumCast(Op::OpImageQuerySizeLod)].operands.push(OperandId, "'Image'");
2308
        InstructionDesc[enumCast(Op::OpImageQuerySizeLod)].operands.push(OperandId, "'Level of Detail'");
2309

2310
        InstructionDesc[enumCast(Op::OpImageQuerySize)].operands.push(OperandId, "'Image'");
2311

2312
        InstructionDesc[enumCast(Op::OpImageQueryLod)].operands.push(OperandId, "'Image'");
2313
        InstructionDesc[enumCast(Op::OpImageQueryLod)].operands.push(OperandId, "'Coordinate'");
2314

2315
        InstructionDesc[enumCast(Op::OpImageQueryLevels)].operands.push(OperandId, "'Image'");
2316

2317
        InstructionDesc[enumCast(Op::OpImageQuerySamples)].operands.push(OperandId, "'Image'");
2318

2319
        InstructionDesc[enumCast(Op::OpImageQueryFormat)].operands.push(OperandId, "'Image'");
2320

2321
        InstructionDesc[enumCast(Op::OpImageQueryOrder)].operands.push(OperandId, "'Image'");
2322

2323
        InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandId, "'Base'");
2324
        InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
2325

2326
        InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandId, "'Base'");
2327
        InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
2328

2329
        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandId, "'Base'");
2330
        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandId, "'Element'");
2331
        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
2332

2333
        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandId, "'Base'");
2334
        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandId, "'Element'");
2335
        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandVariableIds, "'Indexes'");
2336

2337
        InstructionDesc[enumCast(Op::OpSNegate)].operands.push(OperandId, "'Operand'");
2338

2339
        InstructionDesc[enumCast(Op::OpFNegate)].operands.push(OperandId, "'Operand'");
2340

2341
        InstructionDesc[enumCast(Op::OpNot)].operands.push(OperandId, "'Operand'");
2342

2343
        InstructionDesc[enumCast(Op::OpAny)].operands.push(OperandId, "'Vector'");
2344

2345
        InstructionDesc[enumCast(Op::OpAll)].operands.push(OperandId, "'Vector'");
2346

2347
        InstructionDesc[enumCast(Op::OpConvertFToU)].operands.push(OperandId, "'Float Value'");
2348

2349
        InstructionDesc[enumCast(Op::OpConvertFToS)].operands.push(OperandId, "'Float Value'");
2350

2351
        InstructionDesc[enumCast(Op::OpConvertSToF)].operands.push(OperandId, "'Signed Value'");
2352

2353
        InstructionDesc[enumCast(Op::OpConvertUToF)].operands.push(OperandId, "'Unsigned Value'");
2354

2355
        InstructionDesc[enumCast(Op::OpUConvert)].operands.push(OperandId, "'Unsigned Value'");
2356

2357
        InstructionDesc[enumCast(Op::OpSConvert)].operands.push(OperandId, "'Signed Value'");
2358

2359
        InstructionDesc[enumCast(Op::OpFConvert)].operands.push(OperandId, "'Float Value'");
2360

2361
        InstructionDesc[enumCast(Op::OpSatConvertSToU)].operands.push(OperandId, "'Signed Value'");
2362

2363
        InstructionDesc[enumCast(Op::OpSatConvertUToS)].operands.push(OperandId, "'Unsigned Value'");
2364

2365
        InstructionDesc[enumCast(Op::OpConvertPtrToU)].operands.push(OperandId, "'Pointer'");
2366

2367
        InstructionDesc[enumCast(Op::OpConvertUToPtr)].operands.push(OperandId, "'Integer Value'");
2368

2369
        InstructionDesc[enumCast(Op::OpPtrCastToGeneric)].operands.push(OperandId, "'Pointer'");
2370

2371
        InstructionDesc[enumCast(Op::OpGenericCastToPtr)].operands.push(OperandId, "'Pointer'");
2372

2373
        InstructionDesc[enumCast(Op::OpGenericCastToPtrExplicit)].operands.push(OperandId, "'Pointer'");
2374
        InstructionDesc[enumCast(Op::OpGenericCastToPtrExplicit)].operands.push(OperandStorage, "'Storage'");
2375

2376
        InstructionDesc[enumCast(Op::OpGenericPtrMemSemantics)].operands.push(OperandId, "'Pointer'");
2377

2378
        InstructionDesc[enumCast(Op::OpBitcast)].operands.push(OperandId, "'Operand'");
2379

2380
        InstructionDesc[enumCast(Op::OpQuantizeToF16)].operands.push(OperandId, "'Value'");
2381

2382
        InstructionDesc[enumCast(Op::OpTranspose)].operands.push(OperandId, "'Matrix'");
2383

2384
        InstructionDesc[enumCast(Op::OpCopyLogical)].operands.push(OperandId, "'Operand'");
2385

2386
        InstructionDesc[enumCast(Op::OpIsNan)].operands.push(OperandId, "'x'");
2387

2388
        InstructionDesc[enumCast(Op::OpIsInf)].operands.push(OperandId, "'x'");
2389

2390
        InstructionDesc[enumCast(Op::OpIsFinite)].operands.push(OperandId, "'x'");
2391

2392
        InstructionDesc[enumCast(Op::OpIsNormal)].operands.push(OperandId, "'x'");
2393

2394
        InstructionDesc[enumCast(Op::OpSignBitSet)].operands.push(OperandId, "'x'");
2395

2396
        InstructionDesc[enumCast(Op::OpLessOrGreater)].operands.push(OperandId, "'x'");
2397
        InstructionDesc[enumCast(Op::OpLessOrGreater)].operands.push(OperandId, "'y'");
2398

2399
        InstructionDesc[enumCast(Op::OpOrdered)].operands.push(OperandId, "'x'");
2400
        InstructionDesc[enumCast(Op::OpOrdered)].operands.push(OperandId, "'y'");
2401

2402
        InstructionDesc[enumCast(Op::OpUnordered)].operands.push(OperandId, "'x'");
2403
        InstructionDesc[enumCast(Op::OpUnordered)].operands.push(OperandId, "'y'");
2404

2405
        InstructionDesc[enumCast(Op::OpArrayLength)].operands.push(OperandId, "'Structure'");
2406
        InstructionDesc[enumCast(Op::OpArrayLength)].operands.push(OperandLiteralNumber, "'Array member'");
2407

2408
        InstructionDesc[enumCast(Op::OpIAdd)].operands.push(OperandId, "'Operand 1'");
2409
        InstructionDesc[enumCast(Op::OpIAdd)].operands.push(OperandId, "'Operand 2'");
2410

2411
        InstructionDesc[enumCast(Op::OpFAdd)].operands.push(OperandId, "'Operand 1'");
2412
        InstructionDesc[enumCast(Op::OpFAdd)].operands.push(OperandId, "'Operand 2'");
2413

2414
        InstructionDesc[enumCast(Op::OpISub)].operands.push(OperandId, "'Operand 1'");
2415
        InstructionDesc[enumCast(Op::OpISub)].operands.push(OperandId, "'Operand 2'");
2416

2417
        InstructionDesc[enumCast(Op::OpFSub)].operands.push(OperandId, "'Operand 1'");
2418
        InstructionDesc[enumCast(Op::OpFSub)].operands.push(OperandId, "'Operand 2'");
2419

2420
        InstructionDesc[enumCast(Op::OpIMul)].operands.push(OperandId, "'Operand 1'");
2421
        InstructionDesc[enumCast(Op::OpIMul)].operands.push(OperandId, "'Operand 2'");
2422

2423
        InstructionDesc[enumCast(Op::OpFMul)].operands.push(OperandId, "'Operand 1'");
2424
        InstructionDesc[enumCast(Op::OpFMul)].operands.push(OperandId, "'Operand 2'");
2425

2426
        InstructionDesc[enumCast(Op::OpUDiv)].operands.push(OperandId, "'Operand 1'");
2427
        InstructionDesc[enumCast(Op::OpUDiv)].operands.push(OperandId, "'Operand 2'");
2428

2429
        InstructionDesc[enumCast(Op::OpSDiv)].operands.push(OperandId, "'Operand 1'");
2430
        InstructionDesc[enumCast(Op::OpSDiv)].operands.push(OperandId, "'Operand 2'");
2431

2432
        InstructionDesc[enumCast(Op::OpFDiv)].operands.push(OperandId, "'Operand 1'");
2433
        InstructionDesc[enumCast(Op::OpFDiv)].operands.push(OperandId, "'Operand 2'");
2434

2435
        InstructionDesc[enumCast(Op::OpUMod)].operands.push(OperandId, "'Operand 1'");
2436
        InstructionDesc[enumCast(Op::OpUMod)].operands.push(OperandId, "'Operand 2'");
2437

2438
        InstructionDesc[enumCast(Op::OpSRem)].operands.push(OperandId, "'Operand 1'");
2439
        InstructionDesc[enumCast(Op::OpSRem)].operands.push(OperandId, "'Operand 2'");
2440

2441
        InstructionDesc[enumCast(Op::OpSMod)].operands.push(OperandId, "'Operand 1'");
2442
        InstructionDesc[enumCast(Op::OpSMod)].operands.push(OperandId, "'Operand 2'");
2443

2444
        InstructionDesc[enumCast(Op::OpFRem)].operands.push(OperandId, "'Operand 1'");
2445
        InstructionDesc[enumCast(Op::OpFRem)].operands.push(OperandId, "'Operand 2'");
2446

2447
        InstructionDesc[enumCast(Op::OpFMod)].operands.push(OperandId, "'Operand 1'");
2448
        InstructionDesc[enumCast(Op::OpFMod)].operands.push(OperandId, "'Operand 2'");
2449

2450
        InstructionDesc[enumCast(Op::OpVectorTimesScalar)].operands.push(OperandId, "'Vector'");
2451
        InstructionDesc[enumCast(Op::OpVectorTimesScalar)].operands.push(OperandId, "'Scalar'");
2452

2453
        InstructionDesc[enumCast(Op::OpMatrixTimesScalar)].operands.push(OperandId, "'Matrix'");
2454
        InstructionDesc[enumCast(Op::OpMatrixTimesScalar)].operands.push(OperandId, "'Scalar'");
2455

2456
        InstructionDesc[enumCast(Op::OpVectorTimesMatrix)].operands.push(OperandId, "'Vector'");
2457
        InstructionDesc[enumCast(Op::OpVectorTimesMatrix)].operands.push(OperandId, "'Matrix'");
2458

2459
        InstructionDesc[enumCast(Op::OpMatrixTimesVector)].operands.push(OperandId, "'Matrix'");
2460
        InstructionDesc[enumCast(Op::OpMatrixTimesVector)].operands.push(OperandId, "'Vector'");
2461

2462
        InstructionDesc[enumCast(Op::OpMatrixTimesMatrix)].operands.push(OperandId, "'LeftMatrix'");
2463
        InstructionDesc[enumCast(Op::OpMatrixTimesMatrix)].operands.push(OperandId, "'RightMatrix'");
2464

2465
        InstructionDesc[enumCast(Op::OpOuterProduct)].operands.push(OperandId, "'Vector 1'");
2466
        InstructionDesc[enumCast(Op::OpOuterProduct)].operands.push(OperandId, "'Vector 2'");
2467

2468
        InstructionDesc[enumCast(Op::OpDot)].operands.push(OperandId, "'Vector 1'");
2469
        InstructionDesc[enumCast(Op::OpDot)].operands.push(OperandId, "'Vector 2'");
2470

2471
        InstructionDesc[enumCast(Op::OpIAddCarry)].operands.push(OperandId, "'Operand 1'");
2472
        InstructionDesc[enumCast(Op::OpIAddCarry)].operands.push(OperandId, "'Operand 2'");
2473

2474
        InstructionDesc[enumCast(Op::OpISubBorrow)].operands.push(OperandId, "'Operand 1'");
2475
        InstructionDesc[enumCast(Op::OpISubBorrow)].operands.push(OperandId, "'Operand 2'");
2476

2477
        InstructionDesc[enumCast(Op::OpUMulExtended)].operands.push(OperandId, "'Operand 1'");
2478
        InstructionDesc[enumCast(Op::OpUMulExtended)].operands.push(OperandId, "'Operand 2'");
2479

2480
        InstructionDesc[enumCast(Op::OpSMulExtended)].operands.push(OperandId, "'Operand 1'");
2481
        InstructionDesc[enumCast(Op::OpSMulExtended)].operands.push(OperandId, "'Operand 2'");
2482

2483
        InstructionDesc[enumCast(Op::OpShiftRightLogical)].operands.push(OperandId, "'Base'");
2484
        InstructionDesc[enumCast(Op::OpShiftRightLogical)].operands.push(OperandId, "'Shift'");
2485

2486
        InstructionDesc[enumCast(Op::OpShiftRightArithmetic)].operands.push(OperandId, "'Base'");
2487
        InstructionDesc[enumCast(Op::OpShiftRightArithmetic)].operands.push(OperandId, "'Shift'");
2488

2489
        InstructionDesc[enumCast(Op::OpShiftLeftLogical)].operands.push(OperandId, "'Base'");
2490
        InstructionDesc[enumCast(Op::OpShiftLeftLogical)].operands.push(OperandId, "'Shift'");
2491

2492
        InstructionDesc[enumCast(Op::OpLogicalOr)].operands.push(OperandId, "'Operand 1'");
2493
        InstructionDesc[enumCast(Op::OpLogicalOr)].operands.push(OperandId, "'Operand 2'");
2494

2495
        InstructionDesc[enumCast(Op::OpLogicalAnd)].operands.push(OperandId, "'Operand 1'");
2496
        InstructionDesc[enumCast(Op::OpLogicalAnd)].operands.push(OperandId, "'Operand 2'");
2497

2498
        InstructionDesc[enumCast(Op::OpLogicalEqual)].operands.push(OperandId, "'Operand 1'");
2499
        InstructionDesc[enumCast(Op::OpLogicalEqual)].operands.push(OperandId, "'Operand 2'");
2500

2501
        InstructionDesc[enumCast(Op::OpLogicalNotEqual)].operands.push(OperandId, "'Operand 1'");
2502
        InstructionDesc[enumCast(Op::OpLogicalNotEqual)].operands.push(OperandId, "'Operand 2'");
2503

2504
        InstructionDesc[enumCast(Op::OpLogicalNot)].operands.push(OperandId, "'Operand'");
2505

2506
        InstructionDesc[enumCast(Op::OpBitwiseOr)].operands.push(OperandId, "'Operand 1'");
2507
        InstructionDesc[enumCast(Op::OpBitwiseOr)].operands.push(OperandId, "'Operand 2'");
2508

2509
        InstructionDesc[enumCast(Op::OpBitwiseXor)].operands.push(OperandId, "'Operand 1'");
2510
        InstructionDesc[enumCast(Op::OpBitwiseXor)].operands.push(OperandId, "'Operand 2'");
2511

2512
        InstructionDesc[enumCast(Op::OpBitwiseAnd)].operands.push(OperandId, "'Operand 1'");
2513
        InstructionDesc[enumCast(Op::OpBitwiseAnd)].operands.push(OperandId, "'Operand 2'");
2514

2515
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Base'");
2516
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Insert'");
2517
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Offset'");
2518
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Count'");
2519

2520
        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Base'");
2521
        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Offset'");
2522
        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Count'");
2523

2524
        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Base'");
2525
        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Offset'");
2526
        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Count'");
2527

2528
        InstructionDesc[enumCast(Op::OpBitReverse)].operands.push(OperandId, "'Base'");
2529

2530
        InstructionDesc[enumCast(Op::OpBitCount)].operands.push(OperandId, "'Base'");
2531

2532
        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Condition'");
2533
        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Object 1'");
2534
        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Object 2'");
2535

2536
        InstructionDesc[enumCast(Op::OpIEqual)].operands.push(OperandId, "'Operand 1'");
2537
        InstructionDesc[enumCast(Op::OpIEqual)].operands.push(OperandId, "'Operand 2'");
2538

2539
        InstructionDesc[enumCast(Op::OpFOrdEqual)].operands.push(OperandId, "'Operand 1'");
2540
        InstructionDesc[enumCast(Op::OpFOrdEqual)].operands.push(OperandId, "'Operand 2'");
2541

2542
        InstructionDesc[enumCast(Op::OpFUnordEqual)].operands.push(OperandId, "'Operand 1'");
2543
        InstructionDesc[enumCast(Op::OpFUnordEqual)].operands.push(OperandId, "'Operand 2'");
2544

2545
        InstructionDesc[enumCast(Op::OpINotEqual)].operands.push(OperandId, "'Operand 1'");
2546
        InstructionDesc[enumCast(Op::OpINotEqual)].operands.push(OperandId, "'Operand 2'");
2547

2548
        InstructionDesc[enumCast(Op::OpFOrdNotEqual)].operands.push(OperandId, "'Operand 1'");
2549
        InstructionDesc[enumCast(Op::OpFOrdNotEqual)].operands.push(OperandId, "'Operand 2'");
2550

2551
        InstructionDesc[enumCast(Op::OpFUnordNotEqual)].operands.push(OperandId, "'Operand 1'");
2552
        InstructionDesc[enumCast(Op::OpFUnordNotEqual)].operands.push(OperandId, "'Operand 2'");
2553

2554
        InstructionDesc[enumCast(Op::OpULessThan)].operands.push(OperandId, "'Operand 1'");
2555
        InstructionDesc[enumCast(Op::OpULessThan)].operands.push(OperandId, "'Operand 2'");
2556

2557
        InstructionDesc[enumCast(Op::OpSLessThan)].operands.push(OperandId, "'Operand 1'");
2558
        InstructionDesc[enumCast(Op::OpSLessThan)].operands.push(OperandId, "'Operand 2'");
2559

2560
        InstructionDesc[enumCast(Op::OpFOrdLessThan)].operands.push(OperandId, "'Operand 1'");
2561
        InstructionDesc[enumCast(Op::OpFOrdLessThan)].operands.push(OperandId, "'Operand 2'");
2562

2563
        InstructionDesc[enumCast(Op::OpFUnordLessThan)].operands.push(OperandId, "'Operand 1'");
2564
        InstructionDesc[enumCast(Op::OpFUnordLessThan)].operands.push(OperandId, "'Operand 2'");
2565

2566
        InstructionDesc[enumCast(Op::OpUGreaterThan)].operands.push(OperandId, "'Operand 1'");
2567
        InstructionDesc[enumCast(Op::OpUGreaterThan)].operands.push(OperandId, "'Operand 2'");
2568

2569
        InstructionDesc[enumCast(Op::OpSGreaterThan)].operands.push(OperandId, "'Operand 1'");
2570
        InstructionDesc[enumCast(Op::OpSGreaterThan)].operands.push(OperandId, "'Operand 2'");
2571

2572
        InstructionDesc[enumCast(Op::OpFOrdGreaterThan)].operands.push(OperandId, "'Operand 1'");
2573
        InstructionDesc[enumCast(Op::OpFOrdGreaterThan)].operands.push(OperandId, "'Operand 2'");
2574

2575
        InstructionDesc[enumCast(Op::OpFUnordGreaterThan)].operands.push(OperandId, "'Operand 1'");
2576
        InstructionDesc[enumCast(Op::OpFUnordGreaterThan)].operands.push(OperandId, "'Operand 2'");
2577

2578
        InstructionDesc[enumCast(Op::OpULessThanEqual)].operands.push(OperandId, "'Operand 1'");
2579
        InstructionDesc[enumCast(Op::OpULessThanEqual)].operands.push(OperandId, "'Operand 2'");
2580

2581
        InstructionDesc[enumCast(Op::OpSLessThanEqual)].operands.push(OperandId, "'Operand 1'");
2582
        InstructionDesc[enumCast(Op::OpSLessThanEqual)].operands.push(OperandId, "'Operand 2'");
2583

2584
        InstructionDesc[enumCast(Op::OpFOrdLessThanEqual)].operands.push(OperandId, "'Operand 1'");
2585
        InstructionDesc[enumCast(Op::OpFOrdLessThanEqual)].operands.push(OperandId, "'Operand 2'");
2586

2587
        InstructionDesc[enumCast(Op::OpFUnordLessThanEqual)].operands.push(OperandId, "'Operand 1'");
2588
        InstructionDesc[enumCast(Op::OpFUnordLessThanEqual)].operands.push(OperandId, "'Operand 2'");
2589

2590
        InstructionDesc[enumCast(Op::OpUGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
2591
        InstructionDesc[enumCast(Op::OpUGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");
2592

2593
        InstructionDesc[enumCast(Op::OpSGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
2594
        InstructionDesc[enumCast(Op::OpSGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");
2595

2596
        InstructionDesc[enumCast(Op::OpFOrdGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
2597
        InstructionDesc[enumCast(Op::OpFOrdGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");
2598

2599
        InstructionDesc[enumCast(Op::OpFUnordGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
2600
        InstructionDesc[enumCast(Op::OpFUnordGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");
2601

2602
        InstructionDesc[enumCast(Op::OpDPdx)].operands.push(OperandId, "'P'");
2603

2604
        InstructionDesc[enumCast(Op::OpDPdy)].operands.push(OperandId, "'P'");
2605

2606
        InstructionDesc[enumCast(Op::OpFwidth)].operands.push(OperandId, "'P'");
2607

2608
        InstructionDesc[enumCast(Op::OpDPdxFine)].operands.push(OperandId, "'P'");
2609

2610
        InstructionDesc[enumCast(Op::OpDPdyFine)].operands.push(OperandId, "'P'");
2611

2612
        InstructionDesc[enumCast(Op::OpFwidthFine)].operands.push(OperandId, "'P'");
2613

2614
        InstructionDesc[enumCast(Op::OpDPdxCoarse)].operands.push(OperandId, "'P'");
2615

2616
        InstructionDesc[enumCast(Op::OpDPdyCoarse)].operands.push(OperandId, "'P'");
2617

2618
        InstructionDesc[enumCast(Op::OpFwidthCoarse)].operands.push(OperandId, "'P'");
2619

2620
        InstructionDesc[enumCast(Op::OpEmitStreamVertex)].operands.push(OperandId, "'Stream'");
2621

2622
        InstructionDesc[enumCast(Op::OpEndStreamPrimitive)].operands.push(OperandId, "'Stream'");
2623

2624
        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandScope, "'Execution'");
2625
        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandScope, "'Memory'");
2626
        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandMemorySemantics, "'Semantics'");
2627

2628
        InstructionDesc[enumCast(Op::OpMemoryBarrier)].operands.push(OperandScope, "'Memory'");
2629
        InstructionDesc[enumCast(Op::OpMemoryBarrier)].operands.push(OperandMemorySemantics, "'Semantics'");
2630

2631
        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Image'");
2632
        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Coordinate'");
2633
        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Sample'");
2634

2635
        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandId, "'Pointer'");
2636
        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandScope, "'Scope'");
2637
        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandMemorySemantics, "'Semantics'");
2638

2639
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandId, "'Pointer'");
2640
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandScope, "'Scope'");
2641
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandMemorySemantics, "'Semantics'");
2642
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandId, "'Value'");
2643

2644
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandId, "'Pointer'");
2645
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandScope, "'Scope'");
2646
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandMemorySemantics, "'Semantics'");
2647
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandId, "'Value'");
2648

2649
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Pointer'");
2650
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandScope, "'Scope'");
2651
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandMemorySemantics, "'Equal'");
2652
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandMemorySemantics, "'Unequal'");
2653
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Value'");
2654
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Comparator'");
2655

2656
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Pointer'");
2657
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandScope, "'Scope'");
2658
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandMemorySemantics, "'Equal'");
2659
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandMemorySemantics, "'Unequal'");
2660
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Value'");
2661
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Comparator'");
2662

2663
        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandId, "'Pointer'");
2664
        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandScope, "'Scope'");
2665
        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandMemorySemantics, "'Semantics'");
2666

2667
        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandId, "'Pointer'");
2668
        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandScope, "'Scope'");
2669
        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandMemorySemantics, "'Semantics'");
2670

2671
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandId, "'Pointer'");
2672
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandScope, "'Scope'");
2673
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandMemorySemantics, "'Semantics'");
2674
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandId, "'Value'");
2675

2676
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandId, "'Pointer'");
2677
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandScope, "'Scope'");
2678
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
2679
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandId, "'Value'");
2680

2681
        InstructionDesc[enumCast(Op::OpAssumeTrueKHR)].operands.push(OperandId, "'Condition'");
2682

2683
        InstructionDesc[enumCast(Op::OpExpectKHR)].operands.push(OperandId, "'Value'");
2684
        InstructionDesc[enumCast(Op::OpExpectKHR)].operands.push(OperandId, "'ExpectedValue'");
2685

2686
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandId, "'Pointer'");
2687
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandScope, "'Scope'");
2688
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandMemorySemantics, "'Semantics'");
2689
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandId, "'Value'");
2690

2691
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandId, "'Pointer'");
2692
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandScope, "'Scope'");
2693
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandMemorySemantics, "'Semantics'");
2694
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandId, "'Value'");
2695

2696
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandId, "'Pointer'");
2697
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandScope, "'Scope'");
2698
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandMemorySemantics, "'Semantics'");
2699
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandId, "'Value'");
2700

2701
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandId, "'Pointer'");
2702
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandScope, "'Scope'");
2703
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandMemorySemantics, "'Semantics'");
2704
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandId, "'Value'");
2705

2706
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandId, "'Pointer'");
2707
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandScope, "'Scope'");
2708
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandMemorySemantics, "'Semantics'");
2709
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandId, "'Value'");
2710

2711
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandId, "'Pointer'");
2712
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandScope, "'Scope'");
2713
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
2714
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandId, "'Value'");
2715

2716
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandId, "'Pointer'");
2717
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandScope, "'Scope'");
2718
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
2719
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandId, "'Value'");
2720

2721
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandId, "'Pointer'");
2722
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandScope, "'Scope'");
2723
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandMemorySemantics, "'Semantics'");
2724
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandId, "'Value'");
2725

2726
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandId, "'Pointer'");
2727
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandScope, "'Scope'");
2728
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandMemorySemantics, "'Semantics'");
2729
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandId, "'Value'");
2730

2731
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandId, "'Pointer'");
2732
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandScope, "'Scope'");
2733
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandMemorySemantics, "'Semantics'");
2734
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandId, "'Value'");
2735

2736
        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandId, "'Pointer'");
2737
        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandScope, "'Scope'");
2738
        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandMemorySemantics, "'Semantics'");
2739

2740
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandId, "'Pointer'");
2741
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandScope, "'Scope'");
2742
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandMemorySemantics, "'Semantics'");
2743

2744
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandId, "'Merge Block'");
2745
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandId, "'Continue Target'");
2746
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandLoop, "");
2747
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandOptionalLiteral, "");
2748

2749
        InstructionDesc[enumCast(Op::OpSelectionMerge)].operands.push(OperandId, "'Merge Block'");
2750
        InstructionDesc[enumCast(Op::OpSelectionMerge)].operands.push(OperandSelect, "");
2751

2752
        InstructionDesc[enumCast(Op::OpBranch)].operands.push(OperandId, "'Target Label'");
2753

2754
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'Condition'");
2755
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'True Label'");
2756
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'False Label'");
2757
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandVariableLiterals, "'Branch weights'");
2758

2759
        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandId, "'Selector'");
2760
        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandId, "'Default'");
2761
        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandVariableLiteralId, "'Target'");
2762

2763

2764
        InstructionDesc[enumCast(Op::OpReturnValue)].operands.push(OperandId, "'Value'");
2765

2766
        InstructionDesc[enumCast(Op::OpLifetimeStart)].operands.push(OperandId, "'Pointer'");
2767
        InstructionDesc[enumCast(Op::OpLifetimeStart)].operands.push(OperandLiteralNumber, "'Size'");
2768

2769
        InstructionDesc[enumCast(Op::OpLifetimeStop)].operands.push(OperandId, "'Pointer'");
2770
        InstructionDesc[enumCast(Op::OpLifetimeStop)].operands.push(OperandLiteralNumber, "'Size'");
2771

2772
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandScope, "'Execution'");
2773
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Destination'");
2774
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Source'");
2775
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Num Elements'");
2776
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Stride'");
2777
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Event'");
2778

2779
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandScope, "'Execution'");
2780
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandId, "'Num Events'");
2781
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandId, "'Events List'");
2782

2783
        InstructionDesc[enumCast(Op::OpGroupAll)].operands.push(OperandScope, "'Execution'");
2784
        InstructionDesc[enumCast(Op::OpGroupAll)].operands.push(OperandId, "'Predicate'");
2785

2786
        InstructionDesc[enumCast(Op::OpGroupAny)].operands.push(OperandScope, "'Execution'");
2787
        InstructionDesc[enumCast(Op::OpGroupAny)].operands.push(OperandId, "'Predicate'");
2788

2789
        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandScope, "'Execution'");
2790
        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandId, "'Value'");
2791
        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandId, "'LocalId'");
2792

2793
        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandScope, "'Execution'");
2794
        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandGroupOperation, "'Operation'");
2795
        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandId, "'X'");
2796

2797
        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandScope, "'Execution'");
2798
        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandGroupOperation, "'Operation'");
2799
        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandId, "'X'");
2800

2801
        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandScope, "'Execution'");
2802
        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandGroupOperation, "'Operation'");
2803
        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandId, "'X'");
2804

2805
        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandScope, "'Execution'");
2806
        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandGroupOperation, "'Operation'");
2807
        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandId, "X");
2808

2809
        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandScope, "'Execution'");
2810
        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandGroupOperation, "'Operation'");
2811
        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandId, "X");
2812

2813
        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandScope, "'Execution'");
2814
        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandGroupOperation, "'Operation'");
2815
        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandId, "X");
2816

2817
        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandScope, "'Execution'");
2818
        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandGroupOperation, "'Operation'");
2819
        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandId, "X");
2820

2821
        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandScope, "'Execution'");
2822
        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandGroupOperation, "'Operation'");
2823
        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandId, "X");
2824

2825
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Pipe'");
2826
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Pointer'");
2827
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Packet Size'");
2828
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Packet Alignment'");
2829

2830
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Pipe'");
2831
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Pointer'");
2832
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Packet Size'");
2833
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Packet Alignment'");
2834

2835
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Pipe'");
2836
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Reserve Id'");
2837
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Index'");
2838
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Pointer'");
2839
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Packet Size'");
2840
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Packet Alignment'");
2841

2842
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Pipe'");
2843
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Reserve Id'");
2844
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Index'");
2845
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Pointer'");
2846
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Packet Size'");
2847
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Packet Alignment'");
2848

2849
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Pipe'");
2850
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Num Packets'");
2851
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Packet Size'");
2852
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Packet Alignment'");
2853

2854
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Pipe'");
2855
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Num Packets'");
2856
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Packet Size'");
2857
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Packet Alignment'");
2858

2859
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Pipe'");
2860
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Reserve Id'");
2861
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Packet Size'");
2862
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Packet Alignment'");
2863

2864
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Pipe'");
2865
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Reserve Id'");
2866
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Packet Size'");
2867
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Packet Alignment'");
2868

2869
        InstructionDesc[enumCast(Op::OpIsValidReserveId)].operands.push(OperandId, "'Reserve Id'");
2870

2871
        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Pipe'");
2872
        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Packet Size'");
2873
        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Packet Alignment'");
2874

2875
        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Pipe'");
2876
        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Packet Size'");
2877
        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Packet Alignment'");
2878

2879
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandScope, "'Execution'");
2880
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Pipe'");
2881
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Num Packets'");
2882
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Packet Size'");
2883
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Packet Alignment'");
2884

2885
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandScope, "'Execution'");
2886
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Pipe'");
2887
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Num Packets'");
2888
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Packet Size'");
2889
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Packet Alignment'");
2890

2891
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandScope, "'Execution'");
2892
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Pipe'");
2893
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Reserve Id'");
2894
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Packet Size'");
2895
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Packet Alignment'");
2896

2897
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandScope, "'Execution'");
2898
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Pipe'");
2899
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Reserve Id'");
2900
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Packet Size'");
2901
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Packet Alignment'");
2902

2903
        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'GlobalWorkSize'");
2904
        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'LocalWorkSize'");
2905
        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'GlobalWorkOffset'");
2906

2907
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Event'");
2908
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Profiling Info'");
2909
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Value'");
2910

2911
        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].operands.push(OperandId, "'Event'");
2912
        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].operands.push(OperandId, "'Status'");
2913

2914
        InstructionDesc[enumCast(Op::OpIsValidEvent)].operands.push(OperandId, "'Event'");
2915

2916
        InstructionDesc[enumCast(Op::OpRetainEvent)].operands.push(OperandId, "'Event'");
2917

2918
        InstructionDesc[enumCast(Op::OpReleaseEvent)].operands.push(OperandId, "'Event'");
2919

2920
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Invoke'");
2921
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param'");
2922
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param Size'");
2923
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param Align'");
2924

2925
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Invoke'");
2926
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param'");
2927
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param Size'");
2928
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param Align'");
2929

2930
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'ND Range'");
2931
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Invoke'");
2932
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param'");
2933
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param Size'");
2934
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param Align'");
2935

2936
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'ND Range'");
2937
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Invoke'");
2938
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param'");
2939
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param Size'");
2940
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param Align'");
2941

2942
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Queue'");
2943
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Flags'");
2944
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'ND Range'");
2945
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Num Events'");
2946
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Wait Events'");
2947
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Ret Event'");
2948
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Invoke'");
2949
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param'");
2950
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param Size'");
2951
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param Align'");
2952
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandVariableIds, "'Local Size'");
2953

2954
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Queue'");
2955
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Num Events'");
2956
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Wait Events'");
2957
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Ret Event'");
2958

2959
        InstructionDesc[enumCast(Op::OpGroupNonUniformElect)].operands.push(OperandScope, "'Execution'");
2960

2961
        InstructionDesc[enumCast(Op::OpGroupNonUniformAll)].operands.push(OperandScope, "'Execution'");
2962
        InstructionDesc[enumCast(Op::OpGroupNonUniformAll)].operands.push(OperandId, "X");
2963

2964
        InstructionDesc[enumCast(Op::OpGroupNonUniformAny)].operands.push(OperandScope, "'Execution'");
2965
        InstructionDesc[enumCast(Op::OpGroupNonUniformAny)].operands.push(OperandId, "X");
2966

2967
        InstructionDesc[enumCast(Op::OpGroupNonUniformAllEqual)].operands.push(OperandScope, "'Execution'");
2968
        InstructionDesc[enumCast(Op::OpGroupNonUniformAllEqual)].operands.push(OperandId, "X");
2969

2970
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandScope, "'Execution'");
2971
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandId, "X");
2972
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandId, "ID");
2973

2974
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcastFirst)].operands.push(OperandScope, "'Execution'");
2975
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcastFirst)].operands.push(OperandId, "X");
2976

2977
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallot)].operands.push(OperandScope, "'Execution'");
2978
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallot)].operands.push(OperandId, "X");
2979

2980
        InstructionDesc[enumCast(Op::OpGroupNonUniformInverseBallot)].operands.push(OperandScope, "'Execution'");
2981
        InstructionDesc[enumCast(Op::OpGroupNonUniformInverseBallot)].operands.push(OperandId, "X");
2982

2983
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandScope, "'Execution'");
2984
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandId, "X");
2985
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandId, "Bit");
2986

2987
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandScope, "'Execution'");
2988
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandGroupOperation, "'Operation'");
2989
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandId, "X");
2990

2991
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindLSB)].operands.push(OperandScope, "'Execution'");
2992
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindLSB)].operands.push(OperandId, "X");
2993

2994
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindMSB)].operands.push(OperandScope, "'Execution'");
2995
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindMSB)].operands.push(OperandId, "X");
2996

2997
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandScope, "'Execution'");
2998
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandId, "X");
2999
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandId, "'Id'");
3000

3001
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandScope, "'Execution'");
3002
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandId, "X");
3003
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandId, "Mask");
3004

3005
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandScope, "'Execution'");
3006
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandId, "X");
3007
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandId, "Offset");
3008

3009
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandScope, "'Execution'");
3010
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandId, "X");
3011
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandId, "Offset");
3012

3013
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandScope, "'Execution'");
3014
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandGroupOperation, "'Operation'");
3015
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandId, "X");
3016
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandId, "'ClusterSize'", true);
3017

3018
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandScope, "'Execution'");
3019
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandGroupOperation, "'Operation'");
3020
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandId, "X");
3021
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandId, "'ClusterSize'", true);
3022

3023
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandScope, "'Execution'");
3024
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandGroupOperation, "'Operation'");
3025
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandId, "X");
3026
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandId, "'ClusterSize'", true);
3027

3028
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandScope, "'Execution'");
3029
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandGroupOperation, "'Operation'");
3030
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandId, "X");
3031
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandId, "'ClusterSize'", true);
3032

3033
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandScope, "'Execution'");
3034
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandGroupOperation, "'Operation'");
3035
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandId, "X");
3036
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandId, "'ClusterSize'", true);
3037

3038
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandScope, "'Execution'");
3039
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandGroupOperation, "'Operation'");
3040
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandId, "X");
3041
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandId, "'ClusterSize'", true);
3042

3043
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandScope, "'Execution'");
3044
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandGroupOperation, "'Operation'");
3045
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandId, "X");
3046
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandId, "'ClusterSize'", true);
3047

3048
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandScope, "'Execution'");
3049
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandGroupOperation, "'Operation'");
3050
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandId, "X");
3051
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandId, "'ClusterSize'", true);
3052

3053
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandScope, "'Execution'");
3054
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandGroupOperation, "'Operation'");
3055
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandId, "X");
3056
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandId, "'ClusterSize'", true);
3057

3058
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandScope, "'Execution'");
3059
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandGroupOperation, "'Operation'");
3060
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandId, "X");
3061
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandId, "'ClusterSize'", true);
3062

3063
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandScope, "'Execution'");
3064
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandGroupOperation, "'Operation'");
3065
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandId, "X");
3066
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandId, "'ClusterSize'", true);
3067

3068
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandScope, "'Execution'");
3069
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandGroupOperation, "'Operation'");
3070
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandId, "X");
3071
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandId, "'ClusterSize'", true);
3072

3073
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandScope, "'Execution'");
3074
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandGroupOperation, "'Operation'");
3075
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandId, "X");
3076
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandId, "'ClusterSize'", true);
3077

3078
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandScope, "'Execution'");
3079
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandGroupOperation, "'Operation'");
3080
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandId, "X");
3081
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandId, "'ClusterSize'", true);
3082

3083
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandScope, "'Execution'");
3084
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandGroupOperation, "'Operation'");
3085
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandId, "X");
3086
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandId, "'ClusterSize'", true);
3087

3088
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandScope, "'Execution'");
3089
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandGroupOperation, "'Operation'");
3090
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandId, "X");
3091
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandId, "'ClusterSize'", true);
3092

3093
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandScope, "'Execution'");
3094
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandId, "X");
3095
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandId, "'Id'");
3096

3097
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandScope, "'Execution'");
3098
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandId, "X");
3099
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandId, "'Direction'");
3100

3101
        InstructionDesc[enumCast(Op::OpSubgroupBallotKHR)].operands.push(OperandId, "'Predicate'");
3102

3103
        InstructionDesc[enumCast(Op::OpSubgroupFirstInvocationKHR)].operands.push(OperandId, "'Value'");
3104

3105
        InstructionDesc[enumCast(Op::OpSubgroupAnyKHR)].operands.push(OperandScope, "'Execution'");
3106
        InstructionDesc[enumCast(Op::OpSubgroupAnyKHR)].operands.push(OperandId, "'Predicate'");
3107

3108
        InstructionDesc[enumCast(Op::OpSubgroupAllKHR)].operands.push(OperandScope, "'Execution'");
3109
        InstructionDesc[enumCast(Op::OpSubgroupAllKHR)].operands.push(OperandId, "'Predicate'");
3110

3111
        InstructionDesc[enumCast(Op::OpSubgroupAllEqualKHR)].operands.push(OperandScope, "'Execution'");
3112
        InstructionDesc[enumCast(Op::OpSubgroupAllEqualKHR)].operands.push(OperandId, "'Predicate'");
3113

3114
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandScope, "'Execution'");
3115
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'X'");
3116
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'Delta'");
3117
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'ClusterSize'", true);
3118

3119
        InstructionDesc[enumCast(Op::OpSubgroupReadInvocationKHR)].operands.push(OperandId, "'Value'");
3120
        InstructionDesc[enumCast(Op::OpSubgroupReadInvocationKHR)].operands.push(OperandId, "'Index'");
3121

3122
        InstructionDesc[enumCast(Op::OpModuleProcessed)].operands.push(OperandLiteralString, "'process'");
3123

3124
        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3125
        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3126
        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandId, "'X'");
3127

3128
        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3129
        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3130
        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandId, "'X'");
3131

3132
        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3133
        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3134
        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandId, "'X'");
3135

3136
        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3137
        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3138
        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandId, "X");
3139

3140
        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3141
        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3142
        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandId, "X");
3143

3144
        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3145
        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3146
        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandId, "X");
3147

3148
        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3149
        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3150
        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandId, "X");
3151

3152
        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
3153
        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
3154
        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandId, "X");
3155

3156
        InstructionDesc[enumCast(Op::OpFragmentMaskFetchAMD)].operands.push(OperandId, "'Image'");
3157
        InstructionDesc[enumCast(Op::OpFragmentMaskFetchAMD)].operands.push(OperandId, "'Coordinate'");
3158

3159
        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Image'");
3160
        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Coordinate'");
3161
        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Fragment Index'");
3162

3163
        InstructionDesc[enumCast(Op::OpGroupNonUniformPartitionNV)].operands.push(OperandId, "X");
3164

3165
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadAllKHR)].operands.push(OperandId, "'Predicate'");
3166
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadAnyKHR)].operands.push(OperandId, "'Predicate'");
3167
        InstructionDesc[enumCast(Op::OpTypeAccelerationStructureKHR)].setResultAndType(true, false);
3168

3169
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Acceleration Structure'");
3170
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Flags'");
3171
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Cull Mask'");
3172
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'SBT Record Offset'");
3173
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'SBT Record Stride'");
3174
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Miss Index'");
3175
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Origin'");
3176
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'TMin'");
3177
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Direction'");
3178
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'TMax'");
3179
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Payload'");
3180
        InstructionDesc[enumCast(Op::OpTraceNV)].setResultAndType(false, false);
3181

3182
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
3183
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Flags'");
3184
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Cull Mask'");
3185
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
3186
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
3187
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Miss Index'");
3188
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Origin'");
3189
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'TMin'");
3190
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Direction'");
3191
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'TMax'");
3192
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Time'");
3193
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Payload'");
3194
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].setResultAndType(false, false);
3195

3196
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Acceleration Structure'");
3197
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Flags'");
3198
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Cull Mask'");
3199
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'SBT Record Offset'");
3200
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'SBT Record Stride'");
3201
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Miss Index'");
3202
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Origin'");
3203
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'TMin'");
3204
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Direction'");
3205
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'TMax'");
3206
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Payload'");
3207
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].setResultAndType(false, false);
3208

3209
        InstructionDesc[enumCast(Op::OpReportIntersectionKHR)].operands.push(OperandId, "'Hit Parameter'");
3210
        InstructionDesc[enumCast(Op::OpReportIntersectionKHR)].operands.push(OperandId, "'Hit Kind'");
3211

3212
        InstructionDesc[enumCast(Op::OpIgnoreIntersectionNV)].setResultAndType(false, false);
3213

3214
        InstructionDesc[enumCast(Op::OpIgnoreIntersectionKHR)].setResultAndType(false, false);
3215

3216
        InstructionDesc[enumCast(Op::OpTerminateRayNV)].setResultAndType(false, false);
3217

3218
        InstructionDesc[enumCast(Op::OpTerminateRayKHR)].setResultAndType(false, false);
3219

3220
        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].operands.push(OperandId, "SBT Record Index");
3221
        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].operands.push(OperandId, "CallableData ID");
3222
        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].setResultAndType(false, false);
3223

3224
        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].operands.push(OperandId, "SBT Record Index");
3225
        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].operands.push(OperandId, "CallableData");
3226
        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].setResultAndType(false, false);
3227

3228
        InstructionDesc[enumCast(Op::OpConvertUToAccelerationStructureKHR)].operands.push(OperandId, "Value");
3229
        InstructionDesc[enumCast(Op::OpConvertUToAccelerationStructureKHR)].setResultAndType(true, true);
3230

3231
        // Ray Query
3232
        InstructionDesc[enumCast(Op::OpTypeAccelerationStructureKHR)].setResultAndType(true, false);
3233
        InstructionDesc[enumCast(Op::OpTypeRayQueryKHR)].setResultAndType(true, false);
3234

3235
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'RayQuery'");
3236
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'AccelerationS'");
3237
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'RayFlags'");
3238
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'CullMask'");
3239
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Origin'");
3240
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Tmin'");
3241
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Direction'");
3242
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Tmax'");
3243
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].setResultAndType(false, false);
3244

3245
        InstructionDesc[enumCast(Op::OpRayQueryTerminateKHR)].operands.push(OperandId, "'RayQuery'");
3246
        InstructionDesc[enumCast(Op::OpRayQueryTerminateKHR)].setResultAndType(false, false);
3247

3248
        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].operands.push(OperandId, "'RayQuery'");
3249
        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].operands.push(OperandId, "'THit'");
3250
        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].setResultAndType(false, false);
3251

3252
        InstructionDesc[enumCast(Op::OpRayQueryConfirmIntersectionKHR)].operands.push(OperandId, "'RayQuery'");
3253
        InstructionDesc[enumCast(Op::OpRayQueryConfirmIntersectionKHR)].setResultAndType(false, false);
3254

3255
        InstructionDesc[enumCast(Op::OpRayQueryProceedKHR)].operands.push(OperandId, "'RayQuery'");
3256
        InstructionDesc[enumCast(Op::OpRayQueryProceedKHR)].setResultAndType(true, true);
3257

3258
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].operands.push(OperandId, "'RayQuery'");
3259
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].operands.push(OperandId, "'Committed'");
3260
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].setResultAndType(true, true);
3261

3262
        InstructionDesc[enumCast(Op::OpRayQueryGetRayTMinKHR)].operands.push(OperandId, "'RayQuery'");
3263
        InstructionDesc[enumCast(Op::OpRayQueryGetRayTMinKHR)].setResultAndType(true, true);
3264

3265
        InstructionDesc[enumCast(Op::OpRayQueryGetRayFlagsKHR)].operands.push(OperandId, "'RayQuery'");
3266
        InstructionDesc[enumCast(Op::OpRayQueryGetRayFlagsKHR)].setResultAndType(true, true);
3267

3268
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].operands.push(OperandId, "'RayQuery'");
3269
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].operands.push(OperandId, "'Committed'");
3270
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].setResultAndType(true, true);
3271

3272
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].operands.push(OperandId, "'RayQuery'");
3273
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].operands.push(OperandId, "'Committed'");
3274
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].setResultAndType(true, true);
3275

3276
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].operands.push(OperandId, "'RayQuery'");
3277
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].operands.push(OperandId, "'Committed'");
3278
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].setResultAndType(true, true);
3279

3280
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].operands.push(OperandId, "'RayQuery'");
3281
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].operands.push(OperandId, "'Committed'");
3282
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].setResultAndType(true, true);
3283

3284
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].operands.push(OperandId, "'RayQuery'");
3285
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].operands.push(OperandId, "'Committed'");
3286
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].setResultAndType(true, true);
3287

3288
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].operands.push(OperandId, "'RayQuery'");
3289
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].operands.push(OperandId, "'Committed'");
3290
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].setResultAndType(true, true);
3291

3292
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].operands.push(OperandId, "'RayQuery'");
3293
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].operands.push(OperandId, "'Committed'");
3294
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].setResultAndType(true, true);
3295

3296
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].operands.push(OperandId, "'RayQuery'");
3297
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].operands.push(OperandId, "'Committed'");
3298
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].setResultAndType(true, true);
3299

3300
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)].operands.push(OperandId, "'RayQuery'");
3301
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)].setResultAndType(true, true);
3302

3303
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].operands.push(OperandId, "'RayQuery'");
3304
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].operands.push(OperandId, "'Committed'");
3305
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].setResultAndType(true, true);
3306

3307
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].operands.push(OperandId, "'RayQuery'");
3308
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].operands.push(OperandId, "'Committed'");
3309
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].setResultAndType(true, true);
3310

3311
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayDirectionKHR)].operands.push(OperandId, "'RayQuery'");
3312
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayDirectionKHR)].setResultAndType(true, true);
3313

3314
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayOriginKHR)].operands.push(OperandId, "'RayQuery'");
3315
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayOriginKHR)].setResultAndType(true, true);
3316

3317
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].operands.push(OperandId, "'RayQuery'");
3318
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].operands.push(OperandId, "'Committed'");
3319
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].setResultAndType(true, true);
3320

3321
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].operands.push(OperandId, "'RayQuery'");
3322
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].operands.push(OperandId, "'Committed'");
3323
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].setResultAndType(true, true);
3324

3325
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].operands.push(OperandId, "'RayQuery'");
3326
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].operands.push(OperandId, "'Committed'");
3327
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].setResultAndType(true, true);
3328

3329
        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].operands.push(OperandId, "'RayQuery'");
3330
        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].operands.push(OperandId, "'Committed'");
3331
        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].setResultAndType(true, true);
3332
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].operands.push(OperandId, "'RayQuery'");
3333
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].operands.push(OperandId, "'Committed'");
3334
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].setResultAndType(true, true);
3335

3336
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].operands.push(OperandId, "'RayQuery'");
3337
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].operands.push(OperandId, "'Committed'");
3338
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].setResultAndType(true, true);
3339

3340
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].operands.push(OperandId, "'RayQuery'");
3341
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].operands.push(OperandId, "'Committed'");
3342
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].setResultAndType(true, true);
3343

3344
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].operands.push(OperandId, "'RayQuery'");
3345
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].operands.push(OperandId, "'Committed'");
3346
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].setResultAndType(true, true);
3347

3348
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].operands.push(OperandId, "'RayQuery'");
3349
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].operands.push(OperandId, "'Committed'");
3350
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].setResultAndType(true, true);
3351

3352
        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].operands.push(OperandId, "'RayQuery'");
3353
        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].operands.push(OperandId, "'Committed'");
3354
        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].setResultAndType(true, true);
3355

3356
        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].operands.push(OperandId, "'RayQuery'");
3357
        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].operands.push(OperandId, "'Committed'");
3358
        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].setResultAndType(true, true);
3359

3360
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Sampled Image'");
3361
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Coordinate'");
3362
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Granularity'");
3363
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Coarse'");
3364
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandImageOperands, "", true);
3365
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandVariableIds, "", true);
3366

3367
        InstructionDesc[enumCast(Op::OpWritePackedPrimitiveIndices4x8NV)].operands.push(OperandId, "'Index Offset'");
3368
        InstructionDesc[enumCast(Op::OpWritePackedPrimitiveIndices4x8NV)].operands.push(OperandId, "'Packed Indices'");
3369

3370
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountX'");
3371
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountY'");
3372
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountZ'");
3373
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'Payload'");
3374
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].setResultAndType(false, false);
3375

3376
        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].operands.push(OperandId, "'vertexCount'");
3377
        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].operands.push(OperandId, "'primitiveCount'");
3378
        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].setResultAndType(false, false);
3379

3380

3381
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Component Type'");
3382
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Scope'");
3383
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Rows'");
3384
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Columns'");
3385

3386
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Pointer'");
3387
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Stride'");
3388
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Column Major'");
3389
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3390
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandLiteralNumber, "", true);
3391
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "", true);
3392

3393
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Pointer'");
3394
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Object'");
3395
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Stride'");
3396
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Column Major'");
3397
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3398
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandLiteralNumber, "", true);
3399
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "", true);
3400

3401
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'A'");
3402
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'B'");
3403
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'C'");
3404

3405
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLengthNV)].operands.push(OperandId, "'Type'");
3406

3407
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Component Type'");
3408
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Scope'");
3409
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Rows'");
3410
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Columns'");
3411
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Use'");
3412

3413
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Pointer'");
3414
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Memory Layout'");
3415
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Stride'");
3416
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandMemoryAccess, "'Memory Access'");
3417
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandLiteralNumber, "", true);
3418
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "", true);
3419

3420
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Pointer'");
3421
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Object'");
3422
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Memory Layout'");
3423
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Stride'");
3424
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandMemoryAccess, "'Memory Access'");
3425
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandLiteralNumber, "", true);
3426
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "", true);
3427

3428
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'A'");
3429
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'B'");
3430
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'C'");
3431
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
3432

3433
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLengthKHR)].operands.push(OperandId, "'Type'");
3434

3435
        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].operands.push(OperandId, "'Component Type'");
3436
        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].operands.push(OperandId, "'Components'");
3437

3438
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Input'");
3439
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'InputInterpretation'");
3440
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Matrix'");
3441
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixOffset'");
3442
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixInterpretation'");
3443
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'M'");
3444
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'K'");
3445
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MemoryLayout'");
3446
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Transpose'");
3447
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixStride'", true);
3448
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
3449

3450
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Input'");
3451
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'InputInterpretation'");
3452
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Matrix'");
3453
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixOffset'");
3454
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixInterpretation'");
3455
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Bias'");
3456
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'BiasOffset'");
3457
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'BiasInterpretation'");
3458
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'M'");
3459
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'K'");
3460
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MemoryLayout'");
3461
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Transpose'");
3462
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixStride'", true);
3463
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
3464

3465
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "'Pointer'");
3466
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "'Offset'");
3467
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3468
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandLiteralNumber, "", true);
3469
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "", true);
3470

3471
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Pointer'");
3472
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Offset'");
3473
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Object'");
3474
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3475
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandLiteralNumber, "", true);
3476
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "", true);
3477

3478
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'Pointer'");
3479
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'Offset'");
3480
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'A'");
3481
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'B'");
3482
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MemoryLayout'");
3483
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MatrixInterpretation'");
3484
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MatrixStride'", true);
3485

3486
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'Pointer'");
3487
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'Offset'");
3488
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'V'");
3489

3490
        InstructionDesc[enumCast(Op::OpDemoteToHelperInvocationEXT)].setResultAndType(false, false);
3491

3492
        InstructionDesc[enumCast(Op::OpReadClockKHR)].operands.push(OperandScope, "'Scope'");
3493

3494
        InstructionDesc[enumCast(Op::OpTypeHitObjectNV)].setResultAndType(true, false);
3495

3496
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].operands.push(OperandId, "'HitObject'");
3497
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].setResultAndType(true, true);
3498

3499
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].operands.push(OperandId, "'Hint'");
3500
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].operands.push(OperandId, "'Bits'");
3501
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].setResultAndType(false, false);
3502

3503
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'HitObject'");
3504
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'Hint'");
3505
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'Bits'");
3506
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].setResultAndType(false, false);
3507

3508
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeNV)].operands.push(OperandId, "'HitObject'");
3509
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeNV)].setResultAndType(true, true);
3510

3511
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindNV)].operands.push(OperandId, "'HitObject'");
3512
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindNV)].setResultAndType(true, true);
3513

3514
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexNV)].operands.push(OperandId, "'HitObject'");
3515
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexNV)].setResultAndType(true, true);
3516

3517
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexNV)].operands.push(OperandId, "'HitObject'");
3518
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexNV)].setResultAndType(true, true);
3519

3520
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdNV)].operands.push(OperandId, "'HitObject'");
3521
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdNV)].setResultAndType(true, true);
3522

3523
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexNV)].operands.push(OperandId, "'HitObject'");
3524
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexNV)].setResultAndType(true, true);
3525

3526
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionNV)].operands.push(OperandId, "'HitObject'");
3527
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionNV)].setResultAndType(true, true);
3528

3529
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginNV)].operands.push(OperandId, "'HitObject'");
3530
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginNV)].setResultAndType(true, true);
3531

3532
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionNV)].operands.push(OperandId, "'HitObject'");
3533
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionNV)].setResultAndType(true, true);
3534

3535
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginNV)].operands.push(OperandId, "'HitObject'");
3536
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginNV)].setResultAndType(true, true);
3537

3538
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectNV)].operands.push(OperandId, "'HitObject'");
3539
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectNV)].setResultAndType(true, true);
3540

3541
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldNV)].operands.push(OperandId, "'HitObject'");
3542
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldNV)].setResultAndType(true, true);
3543

3544
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxNV)].operands.push(OperandId, "'HitObject'");
3545
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxNV)].setResultAndType(true, true);
3546

3547
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinNV)].operands.push(OperandId, "'HitObject'");
3548
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinNV)].setResultAndType(true, true);
3549

3550
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexNV)].operands.push(OperandId, "'HitObject'");
3551
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexNV)].setResultAndType(true, true);
3552

3553
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyNV)].operands.push(OperandId, "'HitObject'");
3554
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyNV)].setResultAndType(true, true);
3555

3556
        InstructionDesc[enumCast(Op::OpHitObjectIsHitNV)].operands.push(OperandId, "'HitObject'");
3557
        InstructionDesc[enumCast(Op::OpHitObjectIsHitNV)].setResultAndType(true, true);
3558

3559
        InstructionDesc[enumCast(Op::OpHitObjectIsMissNV)].operands.push(OperandId, "'HitObject'");
3560
        InstructionDesc[enumCast(Op::OpHitObjectIsMissNV)].setResultAndType(true, true);
3561

3562
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].operands.push(OperandId, "'HitObject'");
3563
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].operands.push(OperandId, "'HitObjectAttribute'");
3564
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].setResultAndType(false, false);
3565

3566
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].operands.push(OperandId, "'HitObject'");
3567
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].operands.push(OperandId, "'Payload'");
3568
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].setResultAndType(false, false);
3569

3570
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitObject'");
3571
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Acceleration Structure'");
3572
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'InstanceId'");
3573
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'PrimitiveId'");
3574
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'GeometryIndex'");
3575
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitKind'");
3576
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'SBT Record Offset'");
3577
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'SBT Record Stride'");
3578
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Origin'");
3579
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'TMin'");
3580
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Direction'");
3581
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'TMax'");
3582
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitObject Attribute'");
3583
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].setResultAndType(false, false);
3584

3585
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitObject'");
3586
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
3587
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'InstanceId'");
3588
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'PrimitiveId'");
3589
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'GeometryIndex'");
3590
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitKind'");
3591
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
3592
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
3593
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Origin'");
3594
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'TMin'");
3595
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Direction'");
3596
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'TMax'");
3597
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Current Time'");
3598
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitObject Attribute'");
3599
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].setResultAndType(false, false);
3600

3601
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitObject'");
3602
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Acceleration Structure'");
3603
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'InstanceId'");
3604
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'PrimitiveId'");
3605
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'GeometryIndex'");
3606
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitKind'");
3607
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'SBT Record Index'");
3608
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Origin'");
3609
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'TMin'");
3610
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Direction'");
3611
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'TMax'");
3612
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitObject Attribute'");
3613
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].setResultAndType(false, false);
3614

3615
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitObject'");
3616
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
3617
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'InstanceId'");
3618
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'PrimitiveId'");
3619
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'GeometryIndex'");
3620
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitKind'");
3621
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'SBT Record Index'");
3622
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Origin'");
3623
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'TMin'");
3624
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Direction'");
3625
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'TMax'");
3626
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Current Time'");
3627
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitObject Attribute'");
3628
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].setResultAndType(false, false);
3629

3630
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'HitObject'");
3631
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'SBT Index'");
3632
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'Origin'");
3633
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'TMin'");
3634
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'Direction'");
3635
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'TMax'");
3636
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].setResultAndType(false, false);
3637

3638
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'HitObject'");
3639
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'SBT Index'");
3640
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Origin'");
3641
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'TMin'");
3642
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Direction'");
3643
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'TMax'");
3644
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Current Time'");
3645
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].setResultAndType(false, false);
3646

3647
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyNV)].operands.push(OperandId, "'HitObject'");
3648
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyNV)].setResultAndType(false, false);
3649

3650
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'HitObject'");
3651
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Acceleration Structure'");
3652
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'RayFlags'");
3653
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Cullmask'");
3654
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'SBT Record Offset'");
3655
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'SBT Record Stride'");
3656
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Miss Index'");
3657
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Origin'");
3658
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'TMin'");
3659
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Direction'");
3660
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'TMax'");
3661
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Payload'");
3662
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].setResultAndType(false, false);
3663

3664
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'HitObject'");
3665
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
3666
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'RayFlags'");
3667
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Cullmask'");
3668
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
3669
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
3670
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Miss Index'");
3671
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Origin'");
3672
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'TMin'");
3673
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Direction'");
3674
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'TMax'");
3675
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Time'");
3676
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Payload'");
3677
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].setResultAndType(false, false);
3678

3679
        InstructionDesc[enumCast(Op::OpHitObjectGetClusterIdNV)].operands.push(OperandId, "'HitObject'");
3680
        InstructionDesc[enumCast(Op::OpHitObjectGetClusterIdNV)].setResultAndType(true, true);
3681
        InstructionDesc[enumCast(Op::OpHitObjectGetSpherePositionNV)].operands.push(OperandId, "'HitObject'");
3682
        InstructionDesc[enumCast(Op::OpHitObjectGetSpherePositionNV)].setResultAndType(true, true);
3683

3684
        InstructionDesc[enumCast(Op::OpHitObjectGetSphereRadiusNV)].operands.push(OperandId, "'HitObject'");
3685
        InstructionDesc[enumCast(Op::OpHitObjectGetSphereRadiusNV)].setResultAndType(true, true);
3686

3687
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSPositionsNV)].operands.push(OperandId, "'HitObject'");
3688
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSPositionsNV)].setResultAndType(true, true);
3689

3690
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSRadiiNV)].operands.push(OperandId, "'HitObject'");
3691
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSRadiiNV)].setResultAndType(true, true);
3692

3693
        InstructionDesc[enumCast(Op::OpHitObjectIsSphereHitNV)].operands.push(OperandId, "'HitObject'");
3694
        InstructionDesc[enumCast(Op::OpHitObjectIsSphereHitNV)].setResultAndType(true, true);
3695

3696
        InstructionDesc[enumCast(Op::OpHitObjectIsLSSHitNV)].operands.push(OperandId, "'HitObject'");
3697
        InstructionDesc[enumCast(Op::OpHitObjectIsLSSHitNV)].setResultAndType(true, true);
3698

3699
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Acceleration Structure'");
3700
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Instance ID'");
3701
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Geometry Index'");
3702
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Primitive Index'");
3703
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Barycentrics'");
3704
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].setResultAndType(true, true);
3705

3706
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Acceleration Structure'");
3707
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Instance ID'");
3708
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Geometry Index'");
3709
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Primitive Index'");
3710
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Barycentrics'");
3711
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].setResultAndType(true, true);
3712

3713
        InstructionDesc[enumCast(Op::OpColorAttachmentReadEXT)].operands.push(OperandId, "'Attachment'");
3714
        InstructionDesc[enumCast(Op::OpColorAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);
3715
        InstructionDesc[enumCast(Op::OpStencilAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);
3716
        InstructionDesc[enumCast(Op::OpDepthAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);
3717

3718
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'source texture'");
3719
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'texture coordinates'");
3720
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'weights texture'");
3721
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandImageOperands, "", true);
3722
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].setResultAndType(true, true);
3723

3724
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'source texture'");
3725
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'texture coordinates'");
3726
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'box size'");
3727
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandImageOperands, "", true);
3728
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].setResultAndType(true, true);
3729

3730
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'target texture'");
3731
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'target coordinates'");
3732
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'reference texture'");
3733
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'reference coordinates'");
3734
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'block size'");
3735
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandImageOperands, "", true);
3736
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].setResultAndType(true, true);
3737

3738
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'target texture'");
3739
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'target coordinates'");
3740
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'reference texture'");
3741
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
3742
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'block size'");
3743
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandImageOperands, "", true);
3744
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].setResultAndType(true, true);
3745

3746
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'target texture'");
3747
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'target coordinates'");
3748
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'reference texture'");
3749
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
3750
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'block size'");
3751
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandImageOperands, "", true);
3752
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].setResultAndType(true, true);
3753

3754
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'target texture'");
3755
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'target coordinates'");
3756
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'reference texture'");
3757
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'reference coordinates'");
3758
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'block size'");
3759
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandImageOperands, "", true);
3760
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].setResultAndType(true, true);
3761

3762
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'target texture'");
3763
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'target coordinates'");
3764
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'reference texture'");
3765
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
3766
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'block size'");
3767
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandImageOperands, "", true);
3768
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].setResultAndType(true, true);
3769

3770
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'target texture'");
3771
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'target coordinates'");
3772
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'reference texture'");
3773
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'reference coordinates'");
3774
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'block size'");
3775
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandImageOperands, "", true);
3776
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].setResultAndType(true, true);
3777

3778
        InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].operands.push(OperandId, "'source array'");
3779
        InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].setResultAndType(true, true);
3780

3781
        InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].operands.push(OperandId, "'source array'");
3782
        InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].setResultAndType(true, true);
3783

3784
        InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].operands.push(OperandId, "'source cooperative matrix'");
3785
        InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].setResultAndType(true, true);
3786

3787
        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'source array'");
3788
        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'start index'");
3789
        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].setResultAndType(true, true);
3790

3791
        InstructionDesc[enumCast(Op::OpConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'");
3792
        InstructionDesc[enumCast(Op::OpSpecConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'");
3793
        InstructionDesc[enumCast(Op::OpCompositeConstructReplicateEXT)].operands.push(OperandId, "'Value'");
3794

3795
        InstructionDesc[enumCast(Op::OpCooperativeMatrixConvertNV)].operands.push(OperandId, "'Value'");
3796

3797
        InstructionDesc[enumCast(Op::OpCooperativeMatrixTransposeNV)].operands.push(OperandId, "'Matrix'");
3798

3799
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'Matrix'");
3800
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandLiteralNumber, "'ReduceMask'");
3801
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'CombineFunc'");
3802

3803
        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandId, "'Matrix'");
3804
        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandId, "'Operation'");
3805
        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandVariableIds, "'Operands'");
3806

3807
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'Pointer'");
3808
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'Object'");
3809
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'TensorLayout'");
3810
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3811
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");
3812

3813
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'Pointer'");
3814
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'Object'");
3815
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'TensorLayout'");
3816
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
3817
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");
3818

3819
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'Matrix'");
3820
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandLiteralNumber, "'ReduceMask'");
3821

3822
        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].operands.push(OperandId, "'Dim'");
3823
        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].operands.push(OperandId, "'ClampMode'");
3824

3825
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandId, "'Dim'");
3826
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandId, "'HasDimensions'");
3827
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandVariableIds, "'p'");
3828

3829
        InstructionDesc[enumCast(Op::OpTensorLayoutSetBlockSizeNV)].operands.push(OperandId, "'TensorLayout'");
3830
        InstructionDesc[enumCast(Op::OpTensorLayoutSetBlockSizeNV)].operands.push(OperandVariableIds, "'BlockSize'");
3831

3832
        InstructionDesc[enumCast(Op::OpTensorLayoutSetDimensionNV)].operands.push(OperandId, "'TensorLayout'");
3833
        InstructionDesc[enumCast(Op::OpTensorLayoutSetDimensionNV)].operands.push(OperandVariableIds, "'Dim'");
3834

3835
        InstructionDesc[enumCast(Op::OpTensorLayoutSetStrideNV)].operands.push(OperandId, "'TensorLayout'");
3836
        InstructionDesc[enumCast(Op::OpTensorLayoutSetStrideNV)].operands.push(OperandVariableIds, "'Stride'");
3837

3838
        InstructionDesc[enumCast(Op::OpTensorLayoutSliceNV)].operands.push(OperandId, "'TensorLayout'");
3839
        InstructionDesc[enumCast(Op::OpTensorLayoutSliceNV)].operands.push(OperandVariableIds, "'Operands'");
3840

3841
        InstructionDesc[enumCast(Op::OpTensorLayoutSetClampValueNV)].operands.push(OperandId, "'TensorLayout'");
3842
        InstructionDesc[enumCast(Op::OpTensorLayoutSetClampValueNV)].operands.push(OperandId, "'Value'");
3843

3844
        InstructionDesc[enumCast(Op::OpTensorViewSetDimensionNV)].operands.push(OperandId, "'TensorView'");
3845
        InstructionDesc[enumCast(Op::OpTensorViewSetDimensionNV)].operands.push(OperandVariableIds, "'Dim'");
3846

3847
        InstructionDesc[enumCast(Op::OpTensorViewSetStrideNV)].operands.push(OperandId, "'TensorView'");
3848
        InstructionDesc[enumCast(Op::OpTensorViewSetStrideNV)].operands.push(OperandVariableIds, "'Stride'");
3849

3850
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'TensorView'");
3851
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipRowOffset'");
3852
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipRowSpan'");
3853
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipColOffset'");
3854
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipColSpan'");
3855

3856
        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandId, "'Vector1'");
3857
        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandId, "'Vector2'");
3858
        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3859

3860
        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandId, "'Vector1'");
3861
        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandId, "'Vector2'");
3862
        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3863

3864
        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandId, "'Vector1'");
3865
        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandId, "'Vector2'");
3866
        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3867

3868
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
3869
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
3870
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
3871
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3872

3873
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
3874
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
3875
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
3876
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3877

3878
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
3879
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
3880
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
3881
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
3882

3883
        InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Element Type'");
3884
        InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Rank'");
3885

3886
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Tensor'");
3887
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Coordinate'");
3888
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true);
3889
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandVariableIds, "'Tensor Operands'");
3890

3891
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Tensor'");
3892
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Coordinate'");
3893
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Object'");
3894
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true);
3895
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandVariableIds, "'Tensor Operands'");
3896

3897
        InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Tensor'");
3898
        InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Dimension'", true);
3899

3900
        InstructionDesc[enumCast(Op::OpTypeHitObjectEXT)].setResultAndType(true, false);
3901

3902
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].operands.push(OperandId, "'HitObject'");
3903
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].setResultAndType(true, true);
3904

3905
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleEXT)].operands.push(OperandId, "'HitObject'");
3906
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleEXT)].setResultAndType(true, true);
3907

3908
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].operands.push(OperandId, "'Hint'");
3909
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].operands.push(OperandId, "'Bits'");
3910
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].setResultAndType(false, false);
3911

3912
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'HitObject'");
3913
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'Hint'");
3914
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'Bits'");
3915
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].setResultAndType(false, false);
3916

3917
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeEXT)].operands.push(OperandId, "'HitObject'");
3918
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeEXT)].setResultAndType(true, true);
3919

3920
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindEXT)].operands.push(OperandId, "'HitObject'");
3921
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindEXT)].setResultAndType(true, true);
3922

3923
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexEXT)].operands.push(OperandId, "'HitObject'");
3924
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexEXT)].setResultAndType(true, true);
3925

3926
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexEXT)].operands.push(OperandId, "'HitObject'");
3927
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexEXT)].setResultAndType(true, true);
3928

3929
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdEXT)].operands.push(OperandId, "'HitObject'");
3930
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdEXT)].setResultAndType(true, true);
3931

3932
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexEXT)].operands.push(OperandId, "'HitObject'");
3933
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexEXT)].setResultAndType(true, true);
3934

3935
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionEXT)].operands.push(OperandId, "'HitObject'");
3936
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionEXT)].setResultAndType(true, true);
3937

3938
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginEXT)].operands.push(OperandId, "'HitObject'");
3939
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginEXT)].setResultAndType(true, true);
3940

3941
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionEXT)].operands.push(OperandId, "'HitObject'");
3942
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionEXT)].setResultAndType(true, true);
3943

3944
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginEXT)].operands.push(OperandId, "'HitObject'");
3945
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginEXT)].setResultAndType(true, true);
3946

3947
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectEXT)].operands.push(OperandId, "'HitObject'");
3948
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectEXT)].setResultAndType(true, true);
3949

3950
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldEXT)].operands.push(OperandId, "'HitObject'");
3951
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldEXT)].setResultAndType(true, true);
3952

3953
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxEXT)].operands.push(OperandId, "'HitObject'");
3954
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxEXT)].setResultAndType(true, true);
3955

3956
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinEXT)].operands.push(OperandId, "'HitObject'");
3957
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinEXT)].setResultAndType(true, true);
3958

3959
        InstructionDesc[enumCast(Op::OpHitObjectGetRayFlagsEXT)].operands.push(OperandId, "'HitObject'");
3960
        InstructionDesc[enumCast(Op::OpHitObjectGetRayFlagsEXT)].setResultAndType(true, true);
3961

3962
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'HitObject'");
3963
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexEXT)].setResultAndType(true, true);
3964

3965
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyEXT)].operands.push(OperandId, "'HitObject'");
3966
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyEXT)].setResultAndType(true, true);
3967

3968
        InstructionDesc[enumCast(Op::OpHitObjectIsHitEXT)].operands.push(OperandId, "'HitObject'");
3969
        InstructionDesc[enumCast(Op::OpHitObjectIsHitEXT)].setResultAndType(true, true);
3970

3971
        InstructionDesc[enumCast(Op::OpHitObjectIsMissEXT)].operands.push(OperandId, "'HitObject'");
3972
        InstructionDesc[enumCast(Op::OpHitObjectIsMissEXT)].setResultAndType(true, true);
3973

3974
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].operands.push(OperandId, "'HitObject'");
3975
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].operands.push(OperandId, "'HitObjectAttribute'");
3976
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].setResultAndType(false, false);
3977

3978
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].operands.push(OperandId, "'HitObject'");
3979
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].operands.push(OperandId, "'Payload'");
3980
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].setResultAndType(false, false);
3981

3982
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'HitObject'");
3983
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'RayFlags'");
3984
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'SBT Index'");
3985
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'Origin'");
3986
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'TMin'");
3987
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'Direction'");
3988
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'TMax'");
3989
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].setResultAndType(false, false);
3990

3991
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'HitObject'");
3992
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'RayFlags'");
3993
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'SBT Index'");
3994
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Origin'");
3995
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'TMin'");
3996
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Direction'");
3997
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'TMax'");
3998
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Current Time'");
3999
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].setResultAndType(false, false);
4000

4001
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyEXT)].operands.push(OperandId, "'HitObject'");
4002
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyEXT)].setResultAndType(false, false);
4003

4004
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'HitObject'");
4005
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Acceleration Structure'");
4006
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'RayFlags'");
4007
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Cullmask'");
4008
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'SBT Record Offset'");
4009
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'SBT Record Stride'");
4010
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Miss Index'");
4011
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Origin'");
4012
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'TMin'");
4013
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Direction'");
4014
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'TMax'");
4015
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Payload'");
4016
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].setResultAndType(false, false);
4017

4018
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'HitObject'");
4019
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Acceleration Structure'");
4020
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'RayFlags'");
4021
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Cullmask'");
4022
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'SBT Record Offset'");
4023
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'SBT Record Stride'");
4024
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Miss Index'");
4025
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Origin'");
4026
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'TMin'");
4027
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Direction'");
4028
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'TMax'");
4029
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Time'");
4030
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Payload'");
4031
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].setResultAndType(false, false);
4032

4033
        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'HitObject'");
4034
        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'SBT Record Index'");
4035
        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].setResultAndType(false, false);
4036

4037
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'HitObject'");
4038
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Payload'");
4039
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Hint'");
4040
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Bits'");
4041
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].setResultAndType(false, false);
4042

4043
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'HitObject'");
4044
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Acceleration Structure'");
4045
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'RayFlags'");
4046
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Cullmask'");
4047
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Offset'");
4048
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Stride'");
4049
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Miss Index'");
4050
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Origin'");
4051
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'TMin'");
4052
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Direction'");
4053
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'TMax'");
4054
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Payload'");
4055
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Hint'");
4056
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Bits'");
4057
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].setResultAndType(false, false);
4058

4059
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'HitObject'");
4060
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Acceleration Structure'");
4061
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'RayFlags'");
4062
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Cullmask'");
4063
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Offset'");
4064
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Stride'");
4065
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Miss Index'");
4066
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Origin'");
4067
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'TMin'");
4068
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Direction'");
4069
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'TMax'");
4070
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Time'");
4071
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Payload'");
4072
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Hint'");
4073
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Bits'");
4074
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].setResultAndType(false, false);
4075

4076
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'HitObject'");
4077
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'RayQuery'");
4078
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'SBT Record Index'");
4079
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'HitObjectAttribute'");
4080
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].setResultAndType(false, false);
4081

4082
        InstructionDesc[enumCast(Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT)].operands.push(OperandId, "'HitObject'");
4083
        InstructionDesc[enumCast(Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT)].setResultAndType(true, true);
4084

4085
    });
4086
}
4087

4088
} // end spv namespace
4089

4090
Product

Resources

Company
