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-2024 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

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

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

63
namespace spv {
64

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

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

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

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

107
    default: return "Bad";
108

109
    case ExecutionModelRayGenerationKHR: return "RayGenerationKHR";
110
    case ExecutionModelIntersectionKHR:  return "IntersectionKHR";
111
    case ExecutionModelAnyHitKHR:        return "AnyHitKHR";
112
    case ExecutionModelClosestHitKHR:    return "ClosestHitKHR";
113
    case ExecutionModelMissKHR:          return "MissKHR";
114
    case ExecutionModelCallableKHR:      return "CallableKHR";
115
    }
116
}
117

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

125
    case AddressingModelPhysicalStorageBuffer64EXT: return "PhysicalStorageBuffer64EXT";
126

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

131
const char* MemoryString(int mem)
132
{
133
    switch (mem) {
134
    case MemoryModelSimple:     return "Simple";
135
    case MemoryModelGLSL450:    return "GLSL450";
136
    case MemoryModelOpenCL:     return "OpenCL";
137
    case MemoryModelVulkanKHR:  return "VulkanKHR";
138

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

143
const int ExecutionModeCeiling = 40;
144

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

182
    case ExecutionModeInitializer:                   return "Initializer";
183
    case ExecutionModeFinalizer:                     return "Finalizer";
184
    case ExecutionModeSubgroupSize:                  return "SubgroupSize";
185
    case ExecutionModeSubgroupsPerWorkgroup:         return "SubgroupsPerWorkgroup";
186
    case ExecutionModeSubgroupsPerWorkgroupId:       return "SubgroupsPerWorkgroupId";
187
    case ExecutionModeLocalSizeId:                   return "LocalSizeId";
188
    case ExecutionModeLocalSizeHintId:               return "LocalSizeHintId";
189

190
    case ExecutionModePostDepthCoverage:             return "PostDepthCoverage";
191
    case ExecutionModeDenormPreserve:                return "DenormPreserve";
192
    case ExecutionModeDenormFlushToZero:             return "DenormFlushToZero";
193
    case ExecutionModeSignedZeroInfNanPreserve:      return "SignedZeroInfNanPreserve";
194
    case ExecutionModeRoundingModeRTE:               return "RoundingModeRTE";
195
    case ExecutionModeRoundingModeRTZ:               return "RoundingModeRTZ";
196
    case ExecutionModeEarlyAndLateFragmentTestsAMD:  return "EarlyAndLateFragmentTestsAMD";
197
    case ExecutionModeStencilRefUnchangedFrontAMD:   return "StencilRefUnchangedFrontAMD";
198
    case ExecutionModeStencilRefLessFrontAMD:        return "StencilRefLessFrontAMD";
199
    case ExecutionModeStencilRefGreaterBackAMD:      return "StencilRefGreaterBackAMD";
200
    case ExecutionModeStencilRefReplacingEXT:        return "StencilRefReplacingEXT";
201
    case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
202
    case ExecutionModeMaximallyReconvergesKHR:       return "MaximallyReconverges";
203

204
    case ExecutionModeOutputLinesNV:                 return "OutputLinesNV";
205
    case ExecutionModeOutputPrimitivesNV:            return "OutputPrimitivesNV";
206
    case ExecutionModeOutputTrianglesNV:             return "OutputTrianglesNV";
207
    case ExecutionModeDerivativeGroupQuadsNV:        return "DerivativeGroupQuadsNV";
208
    case ExecutionModeDerivativeGroupLinearNV:       return "DerivativeGroupLinearNV";
209

210
    case ExecutionModePixelInterlockOrderedEXT:         return "PixelInterlockOrderedEXT";
211
    case ExecutionModePixelInterlockUnorderedEXT:       return "PixelInterlockUnorderedEXT";
212
    case ExecutionModeSampleInterlockOrderedEXT:        return "SampleInterlockOrderedEXT";
213
    case ExecutionModeSampleInterlockUnorderedEXT:      return "SampleInterlockUnorderedEXT";
214
    case ExecutionModeShadingRateInterlockOrderedEXT:   return "ShadingRateInterlockOrderedEXT";
215
    case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
216

217
    case ExecutionModeMaxWorkgroupSizeINTEL:    return "MaxWorkgroupSizeINTEL";
218
    case ExecutionModeMaxWorkDimINTEL:          return "MaxWorkDimINTEL";
219
    case ExecutionModeNoGlobalOffsetINTEL:      return "NoGlobalOffsetINTEL";
220
    case ExecutionModeNumSIMDWorkitemsINTEL:    return "NumSIMDWorkitemsINTEL";
221

222
    case ExecutionModeRequireFullQuadsKHR:      return "RequireFullQuadsKHR";
223
    case ExecutionModeQuadDerivativesKHR:       return "QuadDerivativesKHR";
224

225
    case ExecutionModeNonCoherentColorAttachmentReadEXT:        return "NonCoherentColorAttachmentReadEXT";
226
    case ExecutionModeNonCoherentDepthAttachmentReadEXT:        return "NonCoherentDepthAttachmentReadEXT";
227
    case ExecutionModeNonCoherentStencilAttachmentReadEXT:      return "NonCoherentStencilAttachmentReadEXT";
228

229
    case ExecutionModeCeiling:
230
    default: return "Bad";
231
    }
232
}
233

234
const char* StorageClassString(int StorageClass)
235
{
236
    switch (StorageClass) {
237
    case 0:  return "UniformConstant";
238
    case 1:  return "Input";
239
    case 2:  return "Uniform";
240
    case 3:  return "Output";
241
    case 4:  return "Workgroup";
242
    case 5:  return "CrossWorkgroup";
243
    case 6:  return "Private";
244
    case 7:  return "Function";
245
    case 8:  return "Generic";
246
    case 9:  return "PushConstant";
247
    case 10: return "AtomicCounter";
248
    case 11: return "Image";
249
    case 12: return "StorageBuffer";
250

251
    case StorageClassRayPayloadKHR:            return "RayPayloadKHR";
252
    case StorageClassHitAttributeKHR:          return "HitAttributeKHR";
253
    case StorageClassIncomingRayPayloadKHR:    return "IncomingRayPayloadKHR";
254
    case StorageClassShaderRecordBufferKHR:    return "ShaderRecordBufferKHR";
255
    case StorageClassCallableDataKHR:          return "CallableDataKHR";
256
    case StorageClassIncomingCallableDataKHR:  return "IncomingCallableDataKHR";
257

258
    case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
259
    case StorageClassTaskPayloadWorkgroupEXT:  return "TaskPayloadWorkgroupEXT";
260
    case StorageClassHitObjectAttributeNV:     return "HitObjectAttributeNV";
261
    case StorageClassTileImageEXT:             return "TileImageEXT";
262
    default: return "Bad";
263
    }
264
}
265

266
const int DecorationCeiling = 45;
267

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

317
    case DecorationCeiling:
318
    default:  return "Bad";
319

320
    case DecorationWeightTextureQCOM:           return "DecorationWeightTextureQCOM";
321
    case DecorationBlockMatchTextureQCOM:       return "DecorationBlockMatchTextureQCOM";
322
    case DecorationBlockMatchSamplerQCOM:       return "DecorationBlockMatchSamplerQCOM";
323
    case DecorationExplicitInterpAMD:           return "ExplicitInterpAMD";
324
    case DecorationOverrideCoverageNV:          return "OverrideCoverageNV";
325
    case DecorationPassthroughNV:               return "PassthroughNV";
326
    case DecorationViewportRelativeNV:          return "ViewportRelativeNV";
327
    case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
328
    case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
329
    case DecorationPerViewNV:                   return "PerViewNV";
330
    case DecorationPerTaskNV:                   return "PerTaskNV";
331

332
    case DecorationPerVertexKHR:                return "PerVertexKHR";
333

334
    case DecorationNonUniformEXT:           return "DecorationNonUniformEXT";
335
    case DecorationHlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
336
    case DecorationHlslSemanticGOOGLE:      return "DecorationHlslSemanticGOOGLE";
337
    case DecorationRestrictPointerEXT:      return "DecorationRestrictPointerEXT";
338
    case DecorationAliasedPointerEXT:       return "DecorationAliasedPointerEXT";
339

340
    case DecorationHitObjectShaderRecordBufferNV:  return "DecorationHitObjectShaderRecordBufferNV";
341
    }
342
}
343

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

392
    case 4416: return "SubgroupEqMaskKHR";
393
    case 4417: return "SubgroupGeMaskKHR";
394
    case 4418: return "SubgroupGtMaskKHR";
395
    case 4419: return "SubgroupLeMaskKHR";
396
    case 4420: return "SubgroupLtMaskKHR";
397
    case 4438: return "DeviceIndex";
398
    case 4440: return "ViewIndex";
399
    case 4424: return "BaseVertex";
400
    case 4425: return "BaseInstance";
401
    case 4426: return "DrawIndex";
402
    case 4432: return "PrimitiveShadingRateKHR";
403
    case 4444: return "ShadingRateKHR";
404
    case 5014: return "FragStencilRefEXT";
405

406
    case 4992: return "BaryCoordNoPerspAMD";
407
    case 4993: return "BaryCoordNoPerspCentroidAMD";
408
    case 4994: return "BaryCoordNoPerspSampleAMD";
409
    case 4995: return "BaryCoordSmoothAMD";
410
    case 4996: return "BaryCoordSmoothCentroidAMD";
411
    case 4997: return "BaryCoordSmoothSampleAMD";
412
    case 4998: return "BaryCoordPullModelAMD";
413
    case BuiltInLaunchIdKHR:                 return "LaunchIdKHR";
414
    case BuiltInLaunchSizeKHR:               return "LaunchSizeKHR";
415
    case BuiltInWorldRayOriginKHR:           return "WorldRayOriginKHR";
416
    case BuiltInWorldRayDirectionKHR:        return "WorldRayDirectionKHR";
417
    case BuiltInObjectRayOriginKHR:          return "ObjectRayOriginKHR";
418
    case BuiltInObjectRayDirectionKHR:       return "ObjectRayDirectionKHR";
419
    case BuiltInRayTminKHR:                  return "RayTminKHR";
420
    case BuiltInRayTmaxKHR:                  return "RayTmaxKHR";
421
    case BuiltInCullMaskKHR:                 return "CullMaskKHR";
422
    case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
423
    case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
424
    case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
425
    case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
426
    case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
427
    case BuiltInInstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
428
    case BuiltInRayGeometryIndexKHR:         return "RayGeometryIndexKHR";
429
    case BuiltInObjectToWorldKHR:            return "ObjectToWorldKHR";
430
    case BuiltInWorldToObjectKHR:            return "WorldToObjectKHR";
431
    case BuiltInHitTNV:                      return "HitTNV";
432
    case BuiltInHitKindKHR:                  return "HitKindKHR";
433
    case BuiltInIncomingRayFlagsKHR:         return "IncomingRayFlagsKHR";
434
    case BuiltInViewportMaskNV:              return "ViewportMaskNV";
435
    case BuiltInSecondaryPositionNV:         return "SecondaryPositionNV";
436
    case BuiltInSecondaryViewportMaskNV:     return "SecondaryViewportMaskNV";
437
    case BuiltInPositionPerViewNV:           return "PositionPerViewNV";
438
    case BuiltInViewportMaskPerViewNV:       return "ViewportMaskPerViewNV";
439
//    case BuiltInFragmentSizeNV:             return "FragmentSizeNV";        // superseded by BuiltInFragSizeEXT
440
//    case BuiltInInvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
441
    case BuiltInBaryCoordKHR:                return "BaryCoordKHR";
442
    case BuiltInBaryCoordNoPerspKHR:         return "BaryCoordNoPerspKHR";
443

444
    case BuiltInFragSizeEXT:                 return "FragSizeEXT";
445
    case BuiltInFragInvocationCountEXT:      return "FragInvocationCountEXT";
446

447
    case 5264: return "FullyCoveredEXT";
448

449
    case BuiltInTaskCountNV:           return "TaskCountNV";
450
    case BuiltInPrimitiveCountNV:      return "PrimitiveCountNV";
451
    case BuiltInPrimitiveIndicesNV:    return "PrimitiveIndicesNV";
452
    case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV";
453
    case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV";
454
    case BuiltInLayerPerViewNV:        return "LayerPerViewNV";
455
    case BuiltInMeshViewCountNV:       return "MeshViewCountNV";
456
    case BuiltInMeshViewIndicesNV:     return "MeshViewIndicesNV";
457
    case BuiltInWarpsPerSMNV:           return "WarpsPerSMNV";
458
    case BuiltInSMCountNV:              return "SMCountNV";
459
    case BuiltInWarpIDNV:               return "WarpIDNV";
460
    case BuiltInSMIDNV:                 return "SMIDNV";
461
    case BuiltInCurrentRayTimeNV:       return "CurrentRayTimeNV";
462
    case BuiltInPrimitivePointIndicesEXT:        return "PrimitivePointIndicesEXT";
463
    case BuiltInPrimitiveLineIndicesEXT:         return "PrimitiveLineIndicesEXT";
464
    case BuiltInPrimitiveTriangleIndicesEXT:     return "PrimitiveTriangleIndicesEXT";
465
    case BuiltInCullPrimitiveEXT:                return "CullPrimitiveEXT";
466
    case BuiltInCoreCountARM:           return "CoreCountARM";
467
    case BuiltInCoreIDARM:              return "CoreIDARM";
468
    case BuiltInCoreMaxIDARM:           return "CoreMaxIDARM";
469
    case BuiltInWarpIDARM:              return "WarpIDARM";
470
    case BuiltInWarpMaxIDARM:           return "BuiltInWarpMaxIDARM";
471

472
    default: return "Bad";
473
    }
474
}
475

476
const char* DimensionString(int dim)
477
{
478
    switch (dim) {
479
    case 0:  return "1D";
480
    case 1:  return "2D";
481
    case 2:  return "3D";
482
    case 3:  return "Cube";
483
    case 4:  return "Rect";
484
    case 5:  return "Buffer";
485
    case 6:  return "SubpassData";
486
    case DimTileImageDataEXT:  return "TileImageDataEXT";
487

488
    default: return "Bad";
489
    }
490
}
491

492
const char* SamplerAddressingModeString(int mode)
493
{
494
    switch (mode) {
495
    case 0:  return "None";
496
    case 1:  return "ClampToEdge";
497
    case 2:  return "Clamp";
498
    case 3:  return "Repeat";
499
    case 4:  return "RepeatMirrored";
500

501
    default: return "Bad";
502
    }
503
}
504

505
const char* SamplerFilterModeString(int mode)
506
{
507
    switch (mode) {
508
    case 0: return "Nearest";
509
    case 1: return "Linear";
510

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

515
const char* ImageFormatString(int format)
516
{
517
    switch (format) {
518
    case  0: return "Unknown";
519

520
    // ES/Desktop float
521
    case  1: return "Rgba32f";
522
    case  2: return "Rgba16f";
523
    case  3: return "R32f";
524
    case  4: return "Rgba8";
525
    case  5: return "Rgba8Snorm";
526

527
    // Desktop float
528
    case  6: return "Rg32f";
529
    case  7: return "Rg16f";
530
    case  8: return "R11fG11fB10f";
531
    case  9: return "R16f";
532
    case 10: return "Rgba16";
533
    case 11: return "Rgb10A2";
534
    case 12: return "Rg16";
535
    case 13: return "Rg8";
536
    case 14: return "R16";
537
    case 15: return "R8";
538
    case 16: return "Rgba16Snorm";
539
    case 17: return "Rg16Snorm";
540
    case 18: return "Rg8Snorm";
541
    case 19: return "R16Snorm";
542
    case 20: return "R8Snorm";
543

544
    // ES/Desktop int
545
    case 21: return "Rgba32i";
546
    case 22: return "Rgba16i";
547
    case 23: return "Rgba8i";
548
    case 24: return "R32i";
549

550
    // Desktop int
551
    case 25: return "Rg32i";
552
    case 26: return "Rg16i";
553
    case 27: return "Rg8i";
554
    case 28: return "R16i";
555
    case 29: return "R8i";
556

557
    // ES/Desktop uint
558
    case 30: return "Rgba32ui";
559
    case 31: return "Rgba16ui";
560
    case 32: return "Rgba8ui";
561
    case 33: return "R32ui";
562

563
    // Desktop uint
564
    case 34: return "Rgb10a2ui";
565
    case 35: return "Rg32ui";
566
    case 36: return "Rg16ui";
567
    case 37: return "Rg8ui";
568
    case 38: return "R16ui";
569
    case 39: return "R8ui";
570
    case 40: return "R64ui";
571
    case 41: return "R64i";
572

573
    default:
574
        return "Bad";
575
    }
576
}
577

578
const char* ImageChannelOrderString(int format)
579
{
580
    switch (format) {
581
    case 0:  return "R";
582
    case 1:  return "A";
583
    case 2:  return "RG";
584
    case 3:  return "RA";
585
    case 4:  return "RGB";
586
    case 5:  return "RGBA";
587
    case 6:  return "BGRA";
588
    case 7:  return "ARGB";
589
    case 8:  return "Intensity";
590
    case 9:  return "Luminance";
591
    case 10: return "Rx";
592
    case 11: return "RGx";
593
    case 12: return "RGBx";
594
    case 13: return "Depth";
595
    case 14: return "DepthStencil";
596
    case 15: return "sRGB";
597
    case 16: return "sRGBx";
598
    case 17: return "sRGBA";
599
    case 18: return "sBGRA";
600

601
    default:
602
        return "Bad";
603
    }
604
}
605

606
const char* ImageChannelDataTypeString(int type)
607
{
608
    switch (type)
609
    {
610
    case 0: return "SnormInt8";
611
    case 1: return "SnormInt16";
612
    case 2: return "UnormInt8";
613
    case 3: return "UnormInt16";
614
    case 4: return "UnormShort565";
615
    case 5: return "UnormShort555";
616
    case 6: return "UnormInt101010";
617
    case 7: return "SignedInt8";
618
    case 8: return "SignedInt16";
619
    case 9: return "SignedInt32";
620
    case 10: return "UnsignedInt8";
621
    case 11: return "UnsignedInt16";
622
    case 12: return "UnsignedInt32";
623
    case 13: return "HalfFloat";
624
    case 14: return "Float";
625
    case 15: return "UnormInt24";
626
    case 16: return "UnormInt101010_2";
627

628
    default:
629
        return "Bad";
630
    }
631
}
632

633
const int ImageOperandsCeiling = 14;
634

635
const char* ImageOperandsString(int format)
636
{
637
    switch (format) {
638
    case ImageOperandsBiasShift:                    return "Bias";
639
    case ImageOperandsLodShift:                     return "Lod";
640
    case ImageOperandsGradShift:                    return "Grad";
641
    case ImageOperandsConstOffsetShift:             return "ConstOffset";
642
    case ImageOperandsOffsetShift:                  return "Offset";
643
    case ImageOperandsConstOffsetsShift:            return "ConstOffsets";
644
    case ImageOperandsSampleShift:                  return "Sample";
645
    case ImageOperandsMinLodShift:                  return "MinLod";
646
    case ImageOperandsMakeTexelAvailableKHRShift:   return "MakeTexelAvailableKHR";
647
    case ImageOperandsMakeTexelVisibleKHRShift:     return "MakeTexelVisibleKHR";
648
    case ImageOperandsNonPrivateTexelKHRShift:      return "NonPrivateTexelKHR";
649
    case ImageOperandsVolatileTexelKHRShift:        return "VolatileTexelKHR";
650
    case ImageOperandsSignExtendShift:              return "SignExtend";
651
    case ImageOperandsZeroExtendShift:              return "ZeroExtend";
652

653
    case ImageOperandsCeiling:
654
    default:
655
        return "Bad";
656
    }
657
}
658

659
const char* FPFastMathString(int mode)
660
{
661
    switch (mode) {
662
    case 0: return "NotNaN";
663
    case 1: return "NotInf";
664
    case 2: return "NSZ";
665
    case 3: return "AllowRecip";
666
    case 4: return "Fast";
667

668
    default:     return "Bad";
669
    }
670
}
671

672
const char* FPRoundingModeString(int mode)
673
{
674
    switch (mode) {
675
    case 0:  return "RTE";
676
    case 1:  return "RTZ";
677
    case 2:  return "RTP";
678
    case 3:  return "RTN";
679

680
    default: return "Bad";
681
    }
682
}
683

684
const char* LinkageTypeString(int type)
685
{
686
    switch (type) {
687
    case 0:  return "Export";
688
    case 1:  return "Import";
689

690
    default: return "Bad";
691
    }
692
}
693

694
const char* FuncParamAttrString(int attr)
695
{
696
    switch (attr) {
697
    case 0:  return "Zext";
698
    case 1:  return "Sext";
699
    case 2:  return "ByVal";
700
    case 3:  return "Sret";
701
    case 4:  return "NoAlias";
702
    case 5:  return "NoCapture";
703
    case 6:  return "NoWrite";
704
    case 7:  return "NoReadWrite";
705

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

710
const char* AccessQualifierString(int attr)
711
{
712
    switch (attr) {
713
    case 0:  return "ReadOnly";
714
    case 1:  return "WriteOnly";
715
    case 2:  return "ReadWrite";
716

717
    default: return "Bad";
718
    }
719
}
720

721
const int SelectControlCeiling = 2;
722

723
const char* SelectControlString(int cont)
724
{
725
    switch (cont) {
726
    case 0:  return "Flatten";
727
    case 1:  return "DontFlatten";
728

729
    case SelectControlCeiling:
730
    default: return "Bad";
731
    }
732
}
733

734
const int LoopControlCeiling = LoopControlPartialCountShift + 1;
735

736
const char* LoopControlString(int cont)
737
{
738
    switch (cont) {
739
    case LoopControlUnrollShift:             return "Unroll";
740
    case LoopControlDontUnrollShift:         return "DontUnroll";
741
    case LoopControlDependencyInfiniteShift: return "DependencyInfinite";
742
    case LoopControlDependencyLengthShift:   return "DependencyLength";
743
    case LoopControlMinIterationsShift:      return "MinIterations";
744
    case LoopControlMaxIterationsShift:      return "MaxIterations";
745
    case LoopControlIterationMultipleShift:  return "IterationMultiple";
746
    case LoopControlPeelCountShift:          return "PeelCount";
747
    case LoopControlPartialCountShift:       return "PartialCount";
748

749
    case LoopControlCeiling:
750
    default: return "Bad";
751
    }
752
}
753

754
const int FunctionControlCeiling = 4;
755

756
const char* FunctionControlString(int cont)
757
{
758
    switch (cont) {
759
    case 0:  return "Inline";
760
    case 1:  return "DontInline";
761
    case 2:  return "Pure";
762
    case 3:  return "Const";
763

764
    case FunctionControlCeiling:
765
    default: return "Bad";
766
    }
767
}
768

769
const char* MemorySemanticsString(int mem)
770
{
771
    // Note: No bits set (None) means "Relaxed"
772
    switch (mem) {
773
    case 0: return "Bad"; // Note: this is a placeholder for 'Consume'
774
    case 1: return "Acquire";
775
    case 2: return "Release";
776
    case 3: return "AcquireRelease";
777
    case 4: return "SequentiallyConsistent";
778
    case 5: return "Bad"; // Note: reserved for future expansion
779
    case 6: return "UniformMemory";
780
    case 7: return "SubgroupMemory";
781
    case 8: return "WorkgroupMemory";
782
    case 9: return "CrossWorkgroupMemory";
783
    case 10: return "AtomicCounterMemory";
784
    case 11: return "ImageMemory";
785

786
    default:     return "Bad";
787
    }
788
}
789

790
const int MemoryAccessCeiling = 6;
791

792
const char* MemoryAccessString(int mem)
793
{
794
    switch (mem) {
795
    case MemoryAccessVolatileShift:                 return "Volatile";
796
    case MemoryAccessAlignedShift:                  return "Aligned";
797
    case MemoryAccessNontemporalShift:              return "Nontemporal";
798
    case MemoryAccessMakePointerAvailableKHRShift:  return "MakePointerAvailableKHR";
799
    case MemoryAccessMakePointerVisibleKHRShift:    return "MakePointerVisibleKHR";
800
    case MemoryAccessNonPrivatePointerKHRShift:     return "NonPrivatePointerKHR";
801

802
    default: return "Bad";
803
    }
804
}
805

806
const int CooperativeMatrixOperandsCeiling = 6;
807

808
const char* CooperativeMatrixOperandsString(int op)
809
{
810
    switch (op) {
811
    case CooperativeMatrixOperandsMatrixASignedComponentsKHRShift:  return "ASignedComponentsKHR";
812
    case CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift:  return "BSignedComponentsKHR";
813
    case CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift:  return "CSignedComponentsKHR";
814
    case CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift:  return "ResultSignedComponentsKHR";
815
    case CooperativeMatrixOperandsSaturatingAccumulationKHRShift:   return "SaturatingAccumulationKHR";
816

817
    default: return "Bad";
818
    }
819
}
820

821
const char* ScopeString(int mem)
822
{
823
    switch (mem) {
824
    case 0:  return "CrossDevice";
825
    case 1:  return "Device";
826
    case 2:  return "Workgroup";
827
    case 3:  return "Subgroup";
828
    case 4:  return "Invocation";
829

830
    default: return "Bad";
831
    }
832
}
833

834
const char* GroupOperationString(int gop)
835
{
836

837
    switch (gop)
838
    {
839
    case GroupOperationReduce:  return "Reduce";
840
    case GroupOperationInclusiveScan:  return "InclusiveScan";
841
    case GroupOperationExclusiveScan:  return "ExclusiveScan";
842
    case GroupOperationClusteredReduce:  return "ClusteredReduce";
843
    case GroupOperationPartitionedReduceNV:  return "PartitionedReduceNV";
844
    case GroupOperationPartitionedInclusiveScanNV:  return "PartitionedInclusiveScanNV";
845
    case GroupOperationPartitionedExclusiveScanNV:  return "PartitionedExclusiveScanNV";
846

847
    default: return "Bad";
848
    }
849
}
850

851
const char* KernelEnqueueFlagsString(int flag)
852
{
853
    switch (flag)
854
    {
855
    case 0:  return "NoWait";
856
    case 1:  return "WaitKernel";
857
    case 2:  return "WaitWorkGroup";
858

859
    default: return "Bad";
860
    }
861
}
862

863
const char* KernelProfilingInfoString(int info)
864
{
865
    switch (info)
866
    {
867
    case 0:  return "CmdExecTime";
868

869
    default: return "Bad";
870
    }
871
}
872

873
const char* CapabilityString(int info)
874
{
875
    switch (info)
876
    {
877
    case 0:  return "Matrix";
878
    case 1:  return "Shader";
879
    case 2:  return "Geometry";
880
    case 3:  return "Tessellation";
881
    case 4:  return "Addresses";
882
    case 5:  return "Linkage";
883
    case 6:  return "Kernel";
884
    case 7:  return "Vector16";
885
    case 8:  return "Float16Buffer";
886
    case 9:  return "Float16";
887
    case 10: return "Float64";
888
    case 11: return "Int64";
889
    case 12: return "Int64Atomics";
890
    case 13: return "ImageBasic";
891
    case 14: return "ImageReadWrite";
892
    case 15: return "ImageMipmap";
893
    case 16: return "Bad";
894
    case 17: return "Pipes";
895
    case 18: return "Groups";
896
    case 19: return "DeviceEnqueue";
897
    case 20: return "LiteralSampler";
898
    case 21: return "AtomicStorage";
899
    case 22: return "Int16";
900
    case 23: return "TessellationPointSize";
901
    case 24: return "GeometryPointSize";
902
    case 25: return "ImageGatherExtended";
903
    case 26: return "Bad";
904
    case 27: return "StorageImageMultisample";
905
    case 28: return "UniformBufferArrayDynamicIndexing";
906
    case 29: return "SampledImageArrayDynamicIndexing";
907
    case 30: return "StorageBufferArrayDynamicIndexing";
908
    case 31: return "StorageImageArrayDynamicIndexing";
909
    case 32: return "ClipDistance";
910
    case 33: return "CullDistance";
911
    case 34: return "ImageCubeArray";
912
    case 35: return "SampleRateShading";
913
    case 36: return "ImageRect";
914
    case 37: return "SampledRect";
915
    case 38: return "GenericPointer";
916
    case 39: return "Int8";
917
    case 40: return "InputAttachment";
918
    case 41: return "SparseResidency";
919
    case 42: return "MinLod";
920
    case 43: return "Sampled1D";
921
    case 44: return "Image1D";
922
    case 45: return "SampledCubeArray";
923
    case 46: return "SampledBuffer";
924
    case 47: return "ImageBuffer";
925
    case 48: return "ImageMSArray";
926
    case 49: return "StorageImageExtendedFormats";
927
    case 50: return "ImageQuery";
928
    case 51: return "DerivativeControl";
929
    case 52: return "InterpolationFunction";
930
    case 53: return "TransformFeedback";
931
    case 54: return "GeometryStreams";
932
    case 55: return "StorageImageReadWithoutFormat";
933
    case 56: return "StorageImageWriteWithoutFormat";
934
    case 57: return "MultiViewport";
935
    case 61: return "GroupNonUniform";
936
    case 62: return "GroupNonUniformVote";
937
    case 63: return "GroupNonUniformArithmetic";
938
    case 64: return "GroupNonUniformBallot";
939
    case 65: return "GroupNonUniformShuffle";
940
    case 66: return "GroupNonUniformShuffleRelative";
941
    case 67: return "GroupNonUniformClustered";
942
    case 68: return "GroupNonUniformQuad";
943

944
    case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR";
945
    case CapabilityDrawParameters:    return "DrawParameters";
946
    case CapabilitySubgroupVoteKHR:   return "SubgroupVoteKHR";
947
    case CapabilityGroupNonUniformRotateKHR: return "CapabilityGroupNonUniformRotateKHR";
948

949
    case CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
950
    case CapabilityStorageUniform16:            return "StorageUniform16";
951
    case CapabilityStoragePushConstant16:       return "StoragePushConstant16";
952
    case CapabilityStorageInputOutput16:        return "StorageInputOutput16";
953

954
    case CapabilityStorageBuffer8BitAccess:             return "StorageBuffer8BitAccess";
955
    case CapabilityUniformAndStorageBuffer8BitAccess:   return "UniformAndStorageBuffer8BitAccess";
956
    case CapabilityStoragePushConstant8:                return "StoragePushConstant8";
957

958
    case CapabilityDeviceGroup: return "DeviceGroup";
959
    case CapabilityMultiView:   return "MultiView";
960

961
    case CapabilityDenormPreserve:           return "DenormPreserve";
962
    case CapabilityDenormFlushToZero:        return "DenormFlushToZero";
963
    case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
964
    case CapabilityRoundingModeRTE:          return "RoundingModeRTE";
965
    case CapabilityRoundingModeRTZ:          return "RoundingModeRTZ";
966

967
    case CapabilityStencilExportEXT: return "StencilExportEXT";
968

969
    case CapabilityFloat16ImageAMD:       return "Float16ImageAMD";
970
    case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
971
    case CapabilityFragmentMaskAMD:       return "FragmentMaskAMD";
972
    case CapabilityImageReadWriteLodAMD:  return "ImageReadWriteLodAMD";
973

974
    case CapabilityAtomicStorageOps:             return "AtomicStorageOps";
975

976
    case CapabilitySampleMaskPostDepthCoverage:  return "SampleMaskPostDepthCoverage";
977
    case CapabilityGeometryShaderPassthroughNV:     return "GeometryShaderPassthroughNV";
978
    case CapabilityShaderViewportIndexLayerNV:      return "ShaderViewportIndexLayerNV";
979
    case CapabilityShaderViewportMaskNV:            return "ShaderViewportMaskNV";
980
    case CapabilityShaderStereoViewNV:              return "ShaderStereoViewNV";
981
    case CapabilityPerViewAttributesNV:             return "PerViewAttributesNV";
982
    case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
983
    case CapabilityRayTracingNV:                    return "RayTracingNV";
984
    case CapabilityRayTracingMotionBlurNV:          return "RayTracingMotionBlurNV";
985
    case CapabilityRayTracingKHR:                   return "RayTracingKHR";
986
    case CapabilityRayCullMaskKHR:                  return "RayCullMaskKHR";
987
    case CapabilityRayQueryKHR:                     return "RayQueryKHR";
988
    case CapabilityRayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
989
    case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
990
    case CapabilityRayTracingPositionFetchKHR:      return "RayTracingPositionFetchKHR";
991
    case CapabilityDisplacementMicromapNV:           return "DisplacementMicromapNV";
992
    case CapabilityRayTracingDisplacementMicromapNV: return "CapabilityRayTracingDisplacementMicromapNV";
993
    case CapabilityRayQueryPositionFetchKHR:        return "RayQueryPositionFetchKHR";
994
    case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
995
    case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
996
    case CapabilityFragmentBarycentricKHR:          return "FragmentBarycentricKHR";
997
    case CapabilityMeshShadingNV:                   return "MeshShadingNV";
998
    case CapabilityImageFootprintNV:                return "ImageFootprintNV";
999
    case CapabilityMeshShadingEXT:                  return "MeshShadingEXT";
1000
//    case CapabilityShadingRateNV:                   return "ShadingRateNV";  // superseded by FragmentDensityEXT
1001
    case CapabilitySampleMaskOverrideCoverageNV:    return "SampleMaskOverrideCoverageNV";
1002
    case CapabilityFragmentDensityEXT:              return "FragmentDensityEXT";
1003

1004
    case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
1005

1006
    case CapabilityShaderNonUniformEXT:                          return "ShaderNonUniformEXT";
1007
    case CapabilityRuntimeDescriptorArrayEXT:                    return "RuntimeDescriptorArrayEXT";
1008
    case CapabilityInputAttachmentArrayDynamicIndexingEXT:       return "InputAttachmentArrayDynamicIndexingEXT";
1009
    case CapabilityUniformTexelBufferArrayDynamicIndexingEXT:    return "UniformTexelBufferArrayDynamicIndexingEXT";
1010
    case CapabilityStorageTexelBufferArrayDynamicIndexingEXT:    return "StorageTexelBufferArrayDynamicIndexingEXT";
1011
    case CapabilityUniformBufferArrayNonUniformIndexingEXT:      return "UniformBufferArrayNonUniformIndexingEXT";
1012
    case CapabilitySampledImageArrayNonUniformIndexingEXT:       return "SampledImageArrayNonUniformIndexingEXT";
1013
    case CapabilityStorageBufferArrayNonUniformIndexingEXT:      return "StorageBufferArrayNonUniformIndexingEXT";
1014
    case CapabilityStorageImageArrayNonUniformIndexingEXT:       return "StorageImageArrayNonUniformIndexingEXT";
1015
    case CapabilityInputAttachmentArrayNonUniformIndexingEXT:    return "InputAttachmentArrayNonUniformIndexingEXT";
1016
    case CapabilityUniformTexelBufferArrayNonUniformIndexingEXT: return "UniformTexelBufferArrayNonUniformIndexingEXT";
1017
    case CapabilityStorageTexelBufferArrayNonUniformIndexingEXT: return "StorageTexelBufferArrayNonUniformIndexingEXT";
1018

1019
    case CapabilityVulkanMemoryModelKHR:                return "VulkanMemoryModelKHR";
1020
    case CapabilityVulkanMemoryModelDeviceScopeKHR:     return "VulkanMemoryModelDeviceScopeKHR";
1021

1022
    case CapabilityPhysicalStorageBufferAddressesEXT:   return "PhysicalStorageBufferAddressesEXT";
1023

1024
    case CapabilityVariablePointers:                    return "VariablePointers";
1025

1026
    case CapabilityCooperativeMatrixNV:     return "CooperativeMatrixNV";
1027
    case CapabilityCooperativeMatrixKHR:    return "CooperativeMatrixKHR";
1028
    case CapabilityShaderSMBuiltinsNV:      return "ShaderSMBuiltinsNV";
1029

1030
    case CapabilityFragmentShaderSampleInterlockEXT:        return "CapabilityFragmentShaderSampleInterlockEXT";
1031
    case CapabilityFragmentShaderPixelInterlockEXT:         return "CapabilityFragmentShaderPixelInterlockEXT";
1032
    case CapabilityFragmentShaderShadingRateInterlockEXT:   return "CapabilityFragmentShaderShadingRateInterlockEXT";
1033

1034
    case CapabilityTileImageColorReadAccessEXT:           return "TileImageColorReadAccessEXT";
1035
    case CapabilityTileImageDepthReadAccessEXT:           return "TileImageDepthReadAccessEXT";
1036
    case CapabilityTileImageStencilReadAccessEXT:         return "TileImageStencilReadAccessEXT";
1037

1038
    case CapabilityFragmentShadingRateKHR:                  return "FragmentShadingRateKHR";
1039

1040
    case CapabilityDemoteToHelperInvocationEXT:             return "DemoteToHelperInvocationEXT";
1041
    case CapabilityAtomicFloat16VectorNV:                   return "AtomicFloat16VectorNV";
1042
    case CapabilityShaderClockKHR:                          return "ShaderClockKHR";
1043
    case CapabilityQuadControlKHR:                          return "QuadControlKHR";
1044
    case CapabilityInt64ImageEXT:                           return "Int64ImageEXT";
1045

1046
    case CapabilityIntegerFunctions2INTEL:              return "CapabilityIntegerFunctions2INTEL";
1047

1048
    case CapabilityExpectAssumeKHR:                         return "ExpectAssumeKHR";
1049

1050
    case CapabilityAtomicFloat16AddEXT:                     return "AtomicFloat16AddEXT";
1051
    case CapabilityAtomicFloat32AddEXT:                     return "AtomicFloat32AddEXT";
1052
    case CapabilityAtomicFloat64AddEXT:                     return "AtomicFloat64AddEXT";
1053
    case CapabilityAtomicFloat16MinMaxEXT:                  return "AtomicFloat16MinMaxEXT";
1054
    case CapabilityAtomicFloat32MinMaxEXT:                  return "AtomicFloat32MinMaxEXT";
1055
    case CapabilityAtomicFloat64MinMaxEXT:                  return "AtomicFloat64MinMaxEXT";
1056

1057
    case CapabilityWorkgroupMemoryExplicitLayoutKHR:            return "CapabilityWorkgroupMemoryExplicitLayoutKHR";
1058
    case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR:  return "CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR";
1059
    case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR";
1060
    case CapabilityCoreBuiltinsARM:                             return "CoreBuiltinsARM";
1061

1062
    case CapabilityShaderInvocationReorderNV:                return "ShaderInvocationReorderNV";
1063

1064
    case CapabilityTextureSampleWeightedQCOM:           return "TextureSampleWeightedQCOM";
1065
    case CapabilityTextureBoxFilterQCOM:                return "TextureBoxFilterQCOM";
1066
    case CapabilityTextureBlockMatchQCOM:               return "TextureBlockMatchQCOM";
1067
    case CapabilityTextureBlockMatch2QCOM:              return "TextureBlockMatch2QCOM";
1068

1069
    default: return "Bad";
1070
    }
1071
}
1072

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

1399
    case OpModuleProcessed: return "OpModuleProcessed";
1400
    case OpExecutionModeId: return "OpExecutionModeId";
1401
    case OpDecorateId:      return "OpDecorateId";
1402

1403
    case 333: return "OpGroupNonUniformElect";
1404
    case 334: return "OpGroupNonUniformAll";
1405
    case 335: return "OpGroupNonUniformAny";
1406
    case 336: return "OpGroupNonUniformAllEqual";
1407
    case 337: return "OpGroupNonUniformBroadcast";
1408
    case 338: return "OpGroupNonUniformBroadcastFirst";
1409
    case 339: return "OpGroupNonUniformBallot";
1410
    case 340: return "OpGroupNonUniformInverseBallot";
1411
    case 341: return "OpGroupNonUniformBallotBitExtract";
1412
    case 342: return "OpGroupNonUniformBallotBitCount";
1413
    case 343: return "OpGroupNonUniformBallotFindLSB";
1414
    case 344: return "OpGroupNonUniformBallotFindMSB";
1415
    case 345: return "OpGroupNonUniformShuffle";
1416
    case 346: return "OpGroupNonUniformShuffleXor";
1417
    case 347: return "OpGroupNonUniformShuffleUp";
1418
    case 348: return "OpGroupNonUniformShuffleDown";
1419
    case 349: return "OpGroupNonUniformIAdd";
1420
    case 350: return "OpGroupNonUniformFAdd";
1421
    case 351: return "OpGroupNonUniformIMul";
1422
    case 352: return "OpGroupNonUniformFMul";
1423
    case 353: return "OpGroupNonUniformSMin";
1424
    case 354: return "OpGroupNonUniformUMin";
1425
    case 355: return "OpGroupNonUniformFMin";
1426
    case 356: return "OpGroupNonUniformSMax";
1427
    case 357: return "OpGroupNonUniformUMax";
1428
    case 358: return "OpGroupNonUniformFMax";
1429
    case 359: return "OpGroupNonUniformBitwiseAnd";
1430
    case 360: return "OpGroupNonUniformBitwiseOr";
1431
    case 361: return "OpGroupNonUniformBitwiseXor";
1432
    case 362: return "OpGroupNonUniformLogicalAnd";
1433
    case 363: return "OpGroupNonUniformLogicalOr";
1434
    case 364: return "OpGroupNonUniformLogicalXor";
1435
    case 365: return "OpGroupNonUniformQuadBroadcast";
1436
    case 366: return "OpGroupNonUniformQuadSwap";
1437

1438
    case OpTerminateInvocation: return "OpTerminateInvocation";
1439

1440
    case 4421: return "OpSubgroupBallotKHR";
1441
    case 4422: return "OpSubgroupFirstInvocationKHR";
1442
    case 4428: return "OpSubgroupAllKHR";
1443
    case 4429: return "OpSubgroupAnyKHR";
1444
    case 4430: return "OpSubgroupAllEqualKHR";
1445
    case 4432: return "OpSubgroupReadInvocationKHR";
1446

1447
    case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
1448
    case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
1449

1450
    case OpAtomicFAddEXT: return "OpAtomicFAddEXT";
1451
    case OpAtomicFMinEXT: return "OpAtomicFMinEXT";
1452
    case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
1453

1454
    case OpAssumeTrueKHR: return "OpAssumeTrueKHR";
1455
    case OpExpectKHR: return "OpExpectKHR";
1456

1457
    case 5000: return "OpGroupIAddNonUniformAMD";
1458
    case 5001: return "OpGroupFAddNonUniformAMD";
1459
    case 5002: return "OpGroupFMinNonUniformAMD";
1460
    case 5003: return "OpGroupUMinNonUniformAMD";
1461
    case 5004: return "OpGroupSMinNonUniformAMD";
1462
    case 5005: return "OpGroupFMaxNonUniformAMD";
1463
    case 5006: return "OpGroupUMaxNonUniformAMD";
1464
    case 5007: return "OpGroupSMaxNonUniformAMD";
1465

1466
    case 5011: return "OpFragmentMaskFetchAMD";
1467
    case 5012: return "OpFragmentFetchAMD";
1468

1469
    case OpReadClockKHR:               return "OpReadClockKHR";
1470

1471
    case OpDecorateStringGOOGLE:       return "OpDecorateStringGOOGLE";
1472
    case OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";
1473

1474
    case OpReportIntersectionKHR:             return "OpReportIntersectionKHR";
1475
    case OpIgnoreIntersectionNV:              return "OpIgnoreIntersectionNV";
1476
    case OpIgnoreIntersectionKHR:             return "OpIgnoreIntersectionKHR";
1477
    case OpTerminateRayNV:                    return "OpTerminateRayNV";
1478
    case OpTerminateRayKHR:                   return "OpTerminateRayKHR";
1479
    case OpTraceNV:                           return "OpTraceNV";
1480
    case OpTraceRayMotionNV:                  return "OpTraceRayMotionNV";
1481
    case OpTraceRayKHR:                       return "OpTraceRayKHR";
1482
    case OpTypeAccelerationStructureKHR:      return "OpTypeAccelerationStructureKHR";
1483
    case OpExecuteCallableNV:                 return "OpExecuteCallableNV";
1484
    case OpExecuteCallableKHR:                return "OpExecuteCallableKHR";
1485
    case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
1486

1487
    case OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
1488
    case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
1489
    case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
1490
    case OpEmitMeshTasksEXT:                 return "OpEmitMeshTasksEXT";
1491
    case OpSetMeshOutputsEXT:                return "OpSetMeshOutputsEXT";
1492

1493
    case OpGroupNonUniformRotateKHR:         return "OpGroupNonUniformRotateKHR";
1494

1495
    case OpTypeRayQueryKHR:                                                   return "OpTypeRayQueryKHR";
1496
    case OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
1497
    case OpRayQueryTerminateKHR:                                              return "OpRayQueryTerminateKHR";
1498
    case OpRayQueryGenerateIntersectionKHR:                                   return "OpRayQueryGenerateIntersectionKHR";
1499
    case OpRayQueryConfirmIntersectionKHR:                                    return "OpRayQueryConfirmIntersectionKHR";
1500
    case OpRayQueryProceedKHR:                                                return "OpRayQueryProceedKHR";
1501
    case OpRayQueryGetIntersectionTypeKHR:                                    return "OpRayQueryGetIntersectionTypeKHR";
1502
    case OpRayQueryGetRayTMinKHR:                                             return "OpRayQueryGetRayTMinKHR";
1503
    case OpRayQueryGetRayFlagsKHR:                                            return "OpRayQueryGetRayFlagsKHR";
1504
    case OpRayQueryGetIntersectionTKHR:                                       return "OpRayQueryGetIntersectionTKHR";
1505
    case OpRayQueryGetIntersectionInstanceCustomIndexKHR:                     return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
1506
    case OpRayQueryGetIntersectionInstanceIdKHR:                              return "OpRayQueryGetIntersectionInstanceIdKHR";
1507
    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:  return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
1508
    case OpRayQueryGetIntersectionGeometryIndexKHR:                           return "OpRayQueryGetIntersectionGeometryIndexKHR";
1509
    case OpRayQueryGetIntersectionPrimitiveIndexKHR:                          return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
1510
    case OpRayQueryGetIntersectionBarycentricsKHR:                            return "OpRayQueryGetIntersectionBarycentricsKHR";
1511
    case OpRayQueryGetIntersectionFrontFaceKHR:                               return "OpRayQueryGetIntersectionFrontFaceKHR";
1512
    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:                     return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
1513
    case OpRayQueryGetIntersectionObjectRayDirectionKHR:                      return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
1514
    case OpRayQueryGetIntersectionObjectRayOriginKHR:                         return "OpRayQueryGetIntersectionObjectRayOriginKHR";
1515
    case OpRayQueryGetWorldRayDirectionKHR:                                   return "OpRayQueryGetWorldRayDirectionKHR";
1516
    case OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
1517
    case OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
1518
    case OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
1519
    case OpRayQueryGetIntersectionTriangleVertexPositionsKHR:                 return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
1520

1521
    case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
1522
    case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
1523
    case OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
1524
    case OpCooperativeMatrixMulAddNV:       return "OpCooperativeMatrixMulAddNV";
1525
    case OpCooperativeMatrixLengthNV:       return "OpCooperativeMatrixLengthNV";
1526
    case OpTypeCooperativeMatrixKHR:        return "OpTypeCooperativeMatrixKHR";
1527
    case OpCooperativeMatrixLoadKHR:        return "OpCooperativeMatrixLoadKHR";
1528
    case OpCooperativeMatrixStoreKHR:       return "OpCooperativeMatrixStoreKHR";
1529
    case OpCooperativeMatrixMulAddKHR:      return "OpCooperativeMatrixMulAddKHR";
1530
    case OpCooperativeMatrixLengthKHR:      return "OpCooperativeMatrixLengthKHR";
1531
    case OpDemoteToHelperInvocationEXT:     return "OpDemoteToHelperInvocationEXT";
1532
    case OpIsHelperInvocationEXT:           return "OpIsHelperInvocationEXT";
1533

1534
    case OpBeginInvocationInterlockEXT:     return "OpBeginInvocationInterlockEXT";
1535
    case OpEndInvocationInterlockEXT:       return "OpEndInvocationInterlockEXT";
1536

1537
    case OpTypeHitObjectNV:                     return "OpTypeHitObjectNV";
1538
    case OpHitObjectTraceRayNV:                 return "OpHitObjectTraceRayNV";
1539
    case OpHitObjectTraceRayMotionNV:           return "OpHitObjectTraceRayMotionNV";
1540
    case OpHitObjectRecordHitNV:                return "OpHitObjectRecordHitNV";
1541
    case OpHitObjectRecordHitMotionNV:          return "OpHitObjectRecordHitMotionNV";
1542
    case OpHitObjectRecordHitWithIndexNV:       return "OpHitObjectRecordHitWithIndexNV";
1543
    case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
1544
    case OpHitObjectRecordMissNV:               return "OpHitObjectRecordMissNV";
1545
    case OpHitObjectRecordMissMotionNV:         return "OpHitObjectRecordMissMotionNV";
1546
    case OpHitObjectRecordEmptyNV:              return "OpHitObjectRecordEmptyNV";
1547
    case OpHitObjectExecuteShaderNV:            return "OpHitObjectExecuteShaderNV";
1548
    case OpReorderThreadWithHintNV:             return "OpReorderThreadWithHintNV";
1549
    case OpReorderThreadWithHitObjectNV:        return "OpReorderThreadWithHitObjectNV";
1550
    case OpHitObjectGetCurrentTimeNV:           return "OpHitObjectGetCurrentTimeNV";
1551
    case OpHitObjectGetAttributesNV:            return "OpHitObjectGetAttributesNV";
1552
    case OpHitObjectGetHitKindNV:               return "OpHitObjectGetFrontFaceNV";
1553
    case OpHitObjectGetPrimitiveIndexNV:        return "OpHitObjectGetPrimitiveIndexNV";
1554
    case OpHitObjectGetGeometryIndexNV:         return "OpHitObjectGetGeometryIndexNV";
1555
    case OpHitObjectGetInstanceIdNV:            return "OpHitObjectGetInstanceIdNV";
1556
    case OpHitObjectGetInstanceCustomIndexNV:   return "OpHitObjectGetInstanceCustomIndexNV";
1557
    case OpHitObjectGetObjectRayDirectionNV:    return "OpHitObjectGetObjectRayDirectionNV";
1558
    case OpHitObjectGetObjectRayOriginNV:       return "OpHitObjectGetObjectRayOriginNV";
1559
    case OpHitObjectGetWorldRayDirectionNV:     return "OpHitObjectGetWorldRayDirectionNV";
1560
    case OpHitObjectGetWorldRayOriginNV:        return "OpHitObjectGetWorldRayOriginNV";
1561
    case OpHitObjectGetWorldToObjectNV:         return "OpHitObjectGetWorldToObjectNV";
1562
    case OpHitObjectGetObjectToWorldNV:         return "OpHitObjectGetObjectToWorldNV";
1563
    case OpHitObjectGetRayTMaxNV:               return "OpHitObjectGetRayTMaxNV";
1564
    case OpHitObjectGetRayTMinNV:               return "OpHitObjectGetRayTMinNV";
1565
    case OpHitObjectIsEmptyNV:                  return "OpHitObjectIsEmptyNV";
1566
    case OpHitObjectIsHitNV:                    return "OpHitObjectIsHitNV";
1567
    case OpHitObjectIsMissNV:                   return "OpHitObjectIsMissNV";
1568
    case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
1569
    case OpHitObjectGetShaderRecordBufferHandleNV:   return "OpHitObjectGetShaderRecordBufferHandleNV";
1570

1571
    case OpFetchMicroTriangleVertexBarycentricNV:       return "OpFetchMicroTriangleVertexBarycentricNV";
1572
    case OpFetchMicroTriangleVertexPositionNV:    return "OpFetchMicroTriangleVertexPositionNV";
1573

1574
    case OpColorAttachmentReadEXT:          return "OpColorAttachmentReadEXT";
1575
    case OpDepthAttachmentReadEXT:          return "OpDepthAttachmentReadEXT";
1576
    case OpStencilAttachmentReadEXT:        return "OpStencilAttachmentReadEXT";
1577

1578
    case OpImageSampleWeightedQCOM:         return "OpImageSampleWeightedQCOM";
1579
    case OpImageBoxFilterQCOM:              return "OpImageBoxFilterQCOM";
1580
    case OpImageBlockMatchSADQCOM:          return "OpImageBlockMatchSADQCOM";
1581
    case OpImageBlockMatchSSDQCOM:          return "OpImageBlockMatchSSDQCOM";
1582
    case OpImageBlockMatchWindowSSDQCOM:    return "OpImageBlockMatchWindowSSDQCOM";
1583
    case OpImageBlockMatchWindowSADQCOM:    return "OpImageBlockMatchWindowSADQCOM";
1584
    case OpImageBlockMatchGatherSSDQCOM:    return "OpImageBlockMatchGatherSSDQCOM";
1585
    case OpImageBlockMatchGatherSADQCOM:    return "OpImageBlockMatchGatherSADQCOM";
1586

1587
    default:
1588
        return "Bad";
1589
    }
1590
}
1591

1592
// The set of objects that hold all the instruction/operand
1593
// parameterization information.
1594
InstructionParameters InstructionDesc[OpCodeMask + 1];
1595
OperandParameters ExecutionModeOperands[ExecutionModeCeiling];
1596
OperandParameters DecorationOperands[DecorationCeiling];
1597

1598
EnumDefinition OperandClassParams[OperandCount];
1599
EnumParameters ExecutionModeParams[ExecutionModeCeiling];
1600
EnumParameters ImageOperandsParams[ImageOperandsCeiling];
1601
EnumParameters DecorationParams[DecorationCeiling];
1602
EnumParameters LoopControlParams[FunctionControlCeiling];
1603
EnumParameters SelectionControlParams[SelectControlCeiling];
1604
EnumParameters FunctionControlParams[FunctionControlCeiling];
1605
EnumParameters MemoryAccessParams[MemoryAccessCeiling];
1606
EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling];
1607

1608
// Set up all the parameterizing descriptions of the opcodes, operands, etc.
1609
void Parameterize()
1610
{
1611
    // only do this once.
1612
    static std::once_flag initialized;
1613
    std::call_once(initialized, [](){
1614

1615
        // Exceptions to having a result <id> and a resulting type <id>.
1616
        // (Everything is initialized to have both).
1617

1618
        InstructionDesc[OpNop].setResultAndType(false, false);
1619
        InstructionDesc[OpSource].setResultAndType(false, false);
1620
        InstructionDesc[OpSourceContinued].setResultAndType(false, false);
1621
        InstructionDesc[OpSourceExtension].setResultAndType(false, false);
1622
        InstructionDesc[OpExtension].setResultAndType(false, false);
1623
        InstructionDesc[OpExtInstImport].setResultAndType(true, false);
1624
        InstructionDesc[OpCapability].setResultAndType(false, false);
1625
        InstructionDesc[OpMemoryModel].setResultAndType(false, false);
1626
        InstructionDesc[OpEntryPoint].setResultAndType(false, false);
1627
        InstructionDesc[OpExecutionMode].setResultAndType(false, false);
1628
        InstructionDesc[OpExecutionModeId].setResultAndType(false, false);
1629
        InstructionDesc[OpTypeVoid].setResultAndType(true, false);
1630
        InstructionDesc[OpTypeBool].setResultAndType(true, false);
1631
        InstructionDesc[OpTypeInt].setResultAndType(true, false);
1632
        InstructionDesc[OpTypeFloat].setResultAndType(true, false);
1633
        InstructionDesc[OpTypeVector].setResultAndType(true, false);
1634
        InstructionDesc[OpTypeMatrix].setResultAndType(true, false);
1635
        InstructionDesc[OpTypeImage].setResultAndType(true, false);
1636
        InstructionDesc[OpTypeSampler].setResultAndType(true, false);
1637
        InstructionDesc[OpTypeSampledImage].setResultAndType(true, false);
1638
        InstructionDesc[OpTypeArray].setResultAndType(true, false);
1639
        InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false);
1640
        InstructionDesc[OpTypeStruct].setResultAndType(true, false);
1641
        InstructionDesc[OpTypeOpaque].setResultAndType(true, false);
1642
        InstructionDesc[OpTypePointer].setResultAndType(true, false);
1643
        InstructionDesc[OpTypeForwardPointer].setResultAndType(false, false);
1644
        InstructionDesc[OpTypeFunction].setResultAndType(true, false);
1645
        InstructionDesc[OpTypeEvent].setResultAndType(true, false);
1646
        InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false);
1647
        InstructionDesc[OpTypeReserveId].setResultAndType(true, false);
1648
        InstructionDesc[OpTypeQueue].setResultAndType(true, false);
1649
        InstructionDesc[OpTypePipe].setResultAndType(true, false);
1650
        InstructionDesc[OpFunctionEnd].setResultAndType(false, false);
1651
        InstructionDesc[OpStore].setResultAndType(false, false);
1652
        InstructionDesc[OpImageWrite].setResultAndType(false, false);
1653
        InstructionDesc[OpDecorationGroup].setResultAndType(true, false);
1654
        InstructionDesc[OpDecorate].setResultAndType(false, false);
1655
        InstructionDesc[OpDecorateId].setResultAndType(false, false);
1656
        InstructionDesc[OpDecorateStringGOOGLE].setResultAndType(false, false);
1657
        InstructionDesc[OpMemberDecorate].setResultAndType(false, false);
1658
        InstructionDesc[OpMemberDecorateStringGOOGLE].setResultAndType(false, false);
1659
        InstructionDesc[OpGroupDecorate].setResultAndType(false, false);
1660
        InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false);
1661
        InstructionDesc[OpName].setResultAndType(false, false);
1662
        InstructionDesc[OpMemberName].setResultAndType(false, false);
1663
        InstructionDesc[OpString].setResultAndType(true, false);
1664
        InstructionDesc[OpLine].setResultAndType(false, false);
1665
        InstructionDesc[OpNoLine].setResultAndType(false, false);
1666
        InstructionDesc[OpCopyMemory].setResultAndType(false, false);
1667
        InstructionDesc[OpCopyMemorySized].setResultAndType(false, false);
1668
        InstructionDesc[OpEmitVertex].setResultAndType(false, false);
1669
        InstructionDesc[OpEndPrimitive].setResultAndType(false, false);
1670
        InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false);
1671
        InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false);
1672
        InstructionDesc[OpControlBarrier].setResultAndType(false, false);
1673
        InstructionDesc[OpMemoryBarrier].setResultAndType(false, false);
1674
        InstructionDesc[OpAtomicStore].setResultAndType(false, false);
1675
        InstructionDesc[OpLoopMerge].setResultAndType(false, false);
1676
        InstructionDesc[OpSelectionMerge].setResultAndType(false, false);
1677
        InstructionDesc[OpLabel].setResultAndType(true, false);
1678
        InstructionDesc[OpBranch].setResultAndType(false, false);
1679
        InstructionDesc[OpBranchConditional].setResultAndType(false, false);
1680
        InstructionDesc[OpSwitch].setResultAndType(false, false);
1681
        InstructionDesc[OpKill].setResultAndType(false, false);
1682
        InstructionDesc[OpTerminateInvocation].setResultAndType(false, false);
1683
        InstructionDesc[OpReturn].setResultAndType(false, false);
1684
        InstructionDesc[OpReturnValue].setResultAndType(false, false);
1685
        InstructionDesc[OpUnreachable].setResultAndType(false, false);
1686
        InstructionDesc[OpLifetimeStart].setResultAndType(false, false);
1687
        InstructionDesc[OpLifetimeStop].setResultAndType(false, false);
1688
        InstructionDesc[OpCommitReadPipe].setResultAndType(false, false);
1689
        InstructionDesc[OpCommitWritePipe].setResultAndType(false, false);
1690
        InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false);
1691
        InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false);
1692
        InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false);
1693
        InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false);
1694
        InstructionDesc[OpRetainEvent].setResultAndType(false, false);
1695
        InstructionDesc[OpReleaseEvent].setResultAndType(false, false);
1696
        InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
1697
        InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
1698
        InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
1699
        InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false);
1700
        InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false);
1701
        InstructionDesc[OpTypeCooperativeMatrixKHR].setResultAndType(true, false);
1702
        InstructionDesc[OpCooperativeMatrixStoreKHR].setResultAndType(false, false);
1703
        InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false);
1704
        InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false);
1705
        InstructionDesc[OpAssumeTrueKHR].setResultAndType(false, false);
1706
        // Specific additional context-dependent operands
1707

1708
        ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
1709

1710
        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'");
1711
        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'");
1712
        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'");
1713

1714
        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'");
1715
        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'");
1716
        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'");
1717

1718
        ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'");
1719
        ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'");
1720

1721
        DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'");
1722
        DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'");
1723
        DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'");
1724
        DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'");
1725
        DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'");
1726
        DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'");
1727
        DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'");
1728
        DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'");
1729
        DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'");
1730
        DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'");
1731
        DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'");
1732
        DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
1733
        DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
1734
        DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'");
1735
        DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'");
1736
        DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'");
1737
        DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
1738
        DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'");
1739
        DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
1740
        DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");
1741

1742
        OperandClassParams[OperandSource].set(0, SourceString, nullptr);
1743
        OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
1744
        OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
1745
        OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
1746
        OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
1747
        OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
1748
        OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
1749
        OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
1750
        OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
1751
        OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
1752
        OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
1753
        OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
1754
        OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
1755
        OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
1756
        OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
1757
        OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
1758
        OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
1759
        OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
1760
        OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
1761
        OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
1762
        OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
1763
        OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
1764
        OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
1765
        OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
1766
        OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
1767
        OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
1768
        OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
1769
        OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
1770
        OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
1771
        OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
1772
        OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
1773
        OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
1774
        OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true);
1775
        OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);
1776

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

1779
        InstructionDesc[OpSource].operands.push(OperandSource, "");
1780
        InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'");
1781
        InstructionDesc[OpSource].operands.push(OperandId, "'File'", true);
1782
        InstructionDesc[OpSource].operands.push(OperandLiteralString, "'Source'", true);
1783

1784
        InstructionDesc[OpSourceContinued].operands.push(OperandLiteralString, "'Continued Source'");
1785

1786
        InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'");
1787

1788
        InstructionDesc[OpName].operands.push(OperandId, "'Target'");
1789
        InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'");
1790

1791
        InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'");
1792
        InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'");
1793
        InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'");
1794

1795
        InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'");
1796

1797
        InstructionDesc[OpLine].operands.push(OperandId, "'File'");
1798
        InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'");
1799
        InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'");
1800

1801
        InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'");
1802

1803
        InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'");
1804

1805
        InstructionDesc[OpCapability].operands.push(OperandCapability, "'Capability'");
1806

1807
        InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, "");
1808
        InstructionDesc[OpMemoryModel].operands.push(OperandMemory, "");
1809

1810
        InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, "");
1811
        InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'");
1812
        InstructionDesc[OpEntryPoint].operands.push(OperandLiteralString, "'Name'");
1813
        InstructionDesc[OpEntryPoint].operands.push(OperandVariableIds, "'Interface'");
1814

1815
        InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'");
1816
        InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'");
1817
        InstructionDesc[OpExecutionMode].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");
1818

1819
        InstructionDesc[OpExecutionModeId].operands.push(OperandId, "'Entry Point'");
1820
        InstructionDesc[OpExecutionModeId].operands.push(OperandExecutionMode, "'Mode'");
1821
        InstructionDesc[OpExecutionModeId].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");
1822

1823
        InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'");
1824
        InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'");
1825

1826
        InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'");
1827

1828
        InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component Type'");
1829
        InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component Count'");
1830

1831
        InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column Type'");
1832
        InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column Count'");
1833

1834
        InstructionDesc[OpTypeImage].operands.push(OperandId, "'Sampled Type'");
1835
        InstructionDesc[OpTypeImage].operands.push(OperandDimensionality, "");
1836
        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Depth'");
1837
        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Arrayed'");
1838
        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'MS'");
1839
        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Sampled'");
1840
        InstructionDesc[OpTypeImage].operands.push(OperandSamplerImageFormat, "");
1841
        InstructionDesc[OpTypeImage].operands.push(OperandAccessQualifier, "", true);
1842

1843
        InstructionDesc[OpTypeSampledImage].operands.push(OperandId, "'Image Type'");
1844

1845
        InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element Type'");
1846
        InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'");
1847

1848
        InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element Type'");
1849

1850
        InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
1851

1852
        InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type.");
1853

1854
        InstructionDesc[OpTypePointer].operands.push(OperandStorage, "");
1855
        InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'");
1856

1857
        InstructionDesc[OpTypeForwardPointer].operands.push(OperandId, "'Pointer Type'");
1858
        InstructionDesc[OpTypeForwardPointer].operands.push(OperandStorage, "");
1859

1860
        InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'");
1861

1862
        InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'");
1863
        InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");
1864

1865
        InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'");
1866

1867
        InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
1868

1869
        InstructionDesc[OpConstantSampler].operands.push(OperandSamplerAddressingMode, "");
1870
        InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'");
1871
        InstructionDesc[OpConstantSampler].operands.push(OperandSamplerFilterMode, "");
1872

1873
        InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'");
1874

1875
        InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
1876

1877
        InstructionDesc[OpSpecConstantOp].operands.push(OperandLiteralNumber, "'Opcode'");
1878
        InstructionDesc[OpSpecConstantOp].operands.push(OperandVariableIds, "'Operands'");
1879

1880
        InstructionDesc[OpVariable].operands.push(OperandStorage, "");
1881
        InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true);
1882

1883
        InstructionDesc[OpFunction].operands.push(OperandFunction, "");
1884
        InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'");
1885

1886
        InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'");
1887
        InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");
1888

1889
        InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'");
1890
        InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'");
1891
        InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
1892

1893
        InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'");
1894
        InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true);
1895
        InstructionDesc[OpLoad].operands.push(OperandLiteralNumber, "", true);
1896
        InstructionDesc[OpLoad].operands.push(OperandId, "", true);
1897

1898
        InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'");
1899
        InstructionDesc[OpStore].operands.push(OperandId, "'Object'");
1900
        InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true);
1901
        InstructionDesc[OpStore].operands.push(OperandLiteralNumber, "", true);
1902
        InstructionDesc[OpStore].operands.push(OperandId, "", true);
1903

1904
        InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
1905

1906
        InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'");
1907
        InstructionDesc[OpDecorate].operands.push(OperandDecoration, "");
1908
        InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
1909

1910
        InstructionDesc[OpDecorateId].operands.push(OperandId, "'Target'");
1911
        InstructionDesc[OpDecorateId].operands.push(OperandDecoration, "");
1912
        InstructionDesc[OpDecorateId].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
1913

1914
        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandId, "'Target'");
1915
        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandDecoration, "");
1916
        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
1917

1918
        InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure Type'");
1919
        InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'");
1920
        InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, "");
1921
        InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
1922

1923
        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandId, "'Structure Type'");
1924
        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralNumber, "'Member'");
1925
        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandDecoration, "");
1926
        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
1927

1928
        InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration Group'");
1929
        InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Targets'");
1930

1931
        InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration Group'");
1932
        InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIdLiteral, "'Targets'");
1933

1934
        InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'");
1935
        InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'");
1936

1937
        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'");
1938
        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'");
1939
        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'");
1940

1941
        InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'");
1942
        InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'");
1943
        InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'");
1944

1945
        InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'");
1946

1947
        InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'");
1948
        InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'");
1949

1950
        InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'");
1951
        InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'");
1952
        InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'");
1953

1954
        InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'");
1955

1956
        InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'");
1957
        InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'");
1958
        InstructionDesc[OpCopyMemory].operands.push(OperandMemoryAccess, "", true);
1959

1960
        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'");
1961
        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'");
1962
        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'");
1963
        InstructionDesc[OpCopyMemorySized].operands.push(OperandMemoryAccess, "", true);
1964

1965
        InstructionDesc[OpSampledImage].operands.push(OperandId, "'Image'");
1966
        InstructionDesc[OpSampledImage].operands.push(OperandId, "'Sampler'");
1967

1968
        InstructionDesc[OpImage].operands.push(OperandId, "'Sampled Image'");
1969

1970
        InstructionDesc[OpImageRead].operands.push(OperandId, "'Image'");
1971
        InstructionDesc[OpImageRead].operands.push(OperandId, "'Coordinate'");
1972
        InstructionDesc[OpImageRead].operands.push(OperandImageOperands, "", true);
1973
        InstructionDesc[OpImageRead].operands.push(OperandVariableIds, "", true);
1974

1975
        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Image'");
1976
        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Coordinate'");
1977
        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Texel'");
1978
        InstructionDesc[OpImageWrite].operands.push(OperandImageOperands, "", true);
1979
        InstructionDesc[OpImageWrite].operands.push(OperandVariableIds, "", true);
1980

1981
        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
1982
        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
1983
        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandImageOperands, "", true);
1984
        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandVariableIds, "", true);
1985

1986
        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
1987
        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
1988
        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandImageOperands, "", true);
1989
        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandVariableIds, "", true);
1990

1991
        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
1992
        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
1993
        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
1994
        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
1995
        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
1996

1997
        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
1998
        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
1999
        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
2000
        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
2001
        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
2002

2003
        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
2004
        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
2005
        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
2006
        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
2007

2008
        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
2009
        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
2010
        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
2011
        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
2012

2013
        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
2014
        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
2015
        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
2016
        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
2017
        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
2018

2019
        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
2020
        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
2021
        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
2022
        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
2023
        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
2024

2025
        InstructionDesc[OpImageFetch].operands.push(OperandId, "'Image'");
2026
        InstructionDesc[OpImageFetch].operands.push(OperandId, "'Coordinate'");
2027
        InstructionDesc[OpImageFetch].operands.push(OperandImageOperands, "", true);
2028
        InstructionDesc[OpImageFetch].operands.push(OperandVariableIds, "", true);
2029

2030
        InstructionDesc[OpImageGather].operands.push(OperandId, "'Sampled Image'");
2031
        InstructionDesc[OpImageGather].operands.push(OperandId, "'Coordinate'");
2032
        InstructionDesc[OpImageGather].operands.push(OperandId, "'Component'");
2033
        InstructionDesc[OpImageGather].operands.push(OperandImageOperands, "", true);
2034
        InstructionDesc[OpImageGather].operands.push(OperandVariableIds, "", true);
2035

2036
        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Sampled Image'");
2037
        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Coordinate'");
2038
        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'D~ref~'");
2039
        InstructionDesc[OpImageDrefGather].operands.push(OperandImageOperands, "", true);
2040
        InstructionDesc[OpImageDrefGather].operands.push(OperandVariableIds, "", true);
2041

2042
        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
2043
        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
2044
        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandImageOperands, "", true);
2045
        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandVariableIds, "", true);
2046

2047
        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
2048
        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
2049
        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandImageOperands, "", true);
2050
        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandVariableIds, "", true);
2051

2052
        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
2053
        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
2054
        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
2055
        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
2056
        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
2057

2058
        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
2059
        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
2060
        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
2061
        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
2062
        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
2063

2064
        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
2065
        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
2066
        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
2067
        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
2068

2069
        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
2070
        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
2071
        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
2072
        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
2073

2074
        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
2075
        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
2076
        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
2077
        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
2078
        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
2079

2080
        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
2081
        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
2082
        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
2083
        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
2084
        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
2085

2086
        InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Image'");
2087
        InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Coordinate'");
2088
        InstructionDesc[OpImageSparseFetch].operands.push(OperandImageOperands, "", true);
2089
        InstructionDesc[OpImageSparseFetch].operands.push(OperandVariableIds, "", true);
2090

2091
        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Sampled Image'");
2092
        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Coordinate'");
2093
        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Component'");
2094
        InstructionDesc[OpImageSparseGather].operands.push(OperandImageOperands, "", true);
2095
        InstructionDesc[OpImageSparseGather].operands.push(OperandVariableIds, "", true);
2096

2097
        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Sampled Image'");
2098
        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Coordinate'");
2099
        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'D~ref~'");
2100
        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandImageOperands, "", true);
2101
        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandVariableIds, "", true);
2102

2103
        InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Image'");
2104
        InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Coordinate'");
2105
        InstructionDesc[OpImageSparseRead].operands.push(OperandImageOperands, "", true);
2106
        InstructionDesc[OpImageSparseRead].operands.push(OperandVariableIds, "", true);
2107

2108
        InstructionDesc[OpImageSparseTexelsResident].operands.push(OperandId, "'Resident Code'");
2109

2110
        InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Image'");
2111
        InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Level of Detail'");
2112

2113
        InstructionDesc[OpImageQuerySize].operands.push(OperandId, "'Image'");
2114

2115
        InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Image'");
2116
        InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Coordinate'");
2117

2118
        InstructionDesc[OpImageQueryLevels].operands.push(OperandId, "'Image'");
2119

2120
        InstructionDesc[OpImageQuerySamples].operands.push(OperandId, "'Image'");
2121

2122
        InstructionDesc[OpImageQueryFormat].operands.push(OperandId, "'Image'");
2123

2124
        InstructionDesc[OpImageQueryOrder].operands.push(OperandId, "'Image'");
2125

2126
        InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'");
2127
        InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'");
2128

2129
        InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'");
2130
        InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'");
2131

2132
        InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Base'");
2133
        InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Element'");
2134
        InstructionDesc[OpPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
2135

2136
        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Base'");
2137
        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Element'");
2138
        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
2139

2140
        InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'");
2141

2142
        InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'");
2143

2144
        InstructionDesc[OpNot].operands.push(OperandId, "'Operand'");
2145

2146
        InstructionDesc[OpAny].operands.push(OperandId, "'Vector'");
2147

2148
        InstructionDesc[OpAll].operands.push(OperandId, "'Vector'");
2149

2150
        InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'");
2151

2152
        InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'");
2153

2154
        InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'");
2155

2156
        InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned Value'");
2157

2158
        InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned Value'");
2159

2160
        InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'");
2161

2162
        InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'");
2163

2164
        InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'");
2165

2166
        InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'");
2167

2168
        InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'");
2169

2170
        InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer Value'");
2171

2172
        InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Pointer'");
2173

2174
        InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Pointer'");
2175

2176
        InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Pointer'");
2177
        InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'Storage'");
2178

2179
        InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'Pointer'");
2180

2181
        InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'");
2182

2183
        InstructionDesc[OpQuantizeToF16].operands.push(OperandId, "'Value'");
2184

2185
        InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'");
2186

2187
        InstructionDesc[OpCopyLogical].operands.push(OperandId, "'Operand'");
2188

2189
        InstructionDesc[OpIsNan].operands.push(OperandId, "'x'");
2190

2191
        InstructionDesc[OpIsInf].operands.push(OperandId, "'x'");
2192

2193
        InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'");
2194

2195
        InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'");
2196

2197
        InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'");
2198

2199
        InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'");
2200
        InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'");
2201

2202
        InstructionDesc[OpOrdered].operands.push(OperandId, "'x'");
2203
        InstructionDesc[OpOrdered].operands.push(OperandId, "'y'");
2204

2205
        InstructionDesc[OpUnordered].operands.push(OperandId, "'x'");
2206
        InstructionDesc[OpUnordered].operands.push(OperandId, "'y'");
2207

2208
        InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'");
2209
        InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'");
2210

2211
        InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'");
2212
        InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'");
2213

2214
        InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'");
2215
        InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'");
2216

2217
        InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'");
2218
        InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'");
2219

2220
        InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'");
2221
        InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'");
2222

2223
        InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'");
2224
        InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'");
2225

2226
        InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'");
2227
        InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'");
2228

2229
        InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'");
2230
        InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'");
2231

2232
        InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'");
2233
        InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'");
2234

2235
        InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'");
2236
        InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'");
2237

2238
        InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'");
2239
        InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'");
2240

2241
        InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'");
2242
        InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'");
2243

2244
        InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'");
2245
        InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'");
2246

2247
        InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'");
2248
        InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'");
2249

2250
        InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'");
2251
        InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'");
2252

2253
        InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'");
2254
        InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'");
2255

2256
        InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'");
2257
        InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'");
2258

2259
        InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'");
2260
        InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'");
2261

2262
        InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'");
2263
        InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'");
2264

2265
        InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'");
2266
        InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'");
2267

2268
        InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 1'");
2269
        InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 2'");
2270

2271
        InstructionDesc[OpDot].operands.push(OperandId, "'Vector 1'");
2272
        InstructionDesc[OpDot].operands.push(OperandId, "'Vector 2'");
2273

2274
        InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 1'");
2275
        InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 2'");
2276

2277
        InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 1'");
2278
        InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 2'");
2279

2280
        InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 1'");
2281
        InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 2'");
2282

2283
        InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 1'");
2284
        InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 2'");
2285

2286
        InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Base'");
2287
        InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Shift'");
2288

2289
        InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Base'");
2290
        InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Shift'");
2291

2292
        InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Base'");
2293
        InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Shift'");
2294

2295
        InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 1'");
2296
        InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 2'");
2297

2298
        InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 1'");
2299
        InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 2'");
2300

2301
        InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 1'");
2302
        InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 2'");
2303

2304
        InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 1'");
2305
        InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 2'");
2306

2307
        InstructionDesc[OpLogicalNot].operands.push(OperandId, "'Operand'");
2308

2309
        InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 1'");
2310
        InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 2'");
2311

2312
        InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 1'");
2313
        InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 2'");
2314

2315
        InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 1'");
2316
        InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 2'");
2317

2318
        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Base'");
2319
        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Insert'");
2320
        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Offset'");
2321
        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Count'");
2322

2323
        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'");
2324
        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'");
2325
        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'");
2326

2327
        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'");
2328
        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'");
2329
        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'");
2330

2331
        InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'");
2332

2333
        InstructionDesc[OpBitCount].operands.push(OperandId, "'Base'");
2334

2335
        InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'");
2336
        InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'");
2337
        InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'");
2338

2339
        InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'");
2340
        InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'");
2341

2342
        InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'");
2343
        InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'");
2344

2345
        InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'");
2346
        InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'");
2347

2348
        InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'");
2349
        InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'");
2350

2351
        InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'");
2352
        InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'");
2353

2354
        InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'");
2355
        InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'");
2356

2357
        InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'");
2358
        InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'");
2359

2360
        InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'");
2361
        InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'");
2362

2363
        InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'");
2364
        InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'");
2365

2366
        InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'");
2367
        InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'");
2368

2369
        InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'");
2370
        InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'");
2371

2372
        InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'");
2373
        InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'");
2374

2375
        InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'");
2376
        InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'");
2377

2378
        InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'");
2379
        InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'");
2380

2381
        InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'");
2382
        InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'");
2383

2384
        InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'");
2385
        InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'");
2386

2387
        InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'");
2388
        InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'");
2389

2390
        InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'");
2391
        InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'");
2392

2393
        InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
2394
        InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
2395

2396
        InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
2397
        InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
2398

2399
        InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
2400
        InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
2401

2402
        InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
2403
        InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
2404

2405
        InstructionDesc[OpDPdx].operands.push(OperandId, "'P'");
2406

2407
        InstructionDesc[OpDPdy].operands.push(OperandId, "'P'");
2408

2409
        InstructionDesc[OpFwidth].operands.push(OperandId, "'P'");
2410

2411
        InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'");
2412

2413
        InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'");
2414

2415
        InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'");
2416

2417
        InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'");
2418

2419
        InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'");
2420

2421
        InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'");
2422

2423
        InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'");
2424

2425
        InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'");
2426

2427
        InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Execution'");
2428
        InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Memory'");
2429
        InstructionDesc[OpControlBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
2430

2431
        InstructionDesc[OpMemoryBarrier].operands.push(OperandScope, "'Memory'");
2432
        InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
2433

2434
        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Image'");
2435
        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Coordinate'");
2436
        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Sample'");
2437

2438
        InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'");
2439
        InstructionDesc[OpAtomicLoad].operands.push(OperandScope, "'Scope'");
2440
        InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'");
2441

2442
        InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'");
2443
        InstructionDesc[OpAtomicStore].operands.push(OperandScope, "'Scope'");
2444
        InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'");
2445
        InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'");
2446

2447
        InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'");
2448
        InstructionDesc[OpAtomicExchange].operands.push(OperandScope, "'Scope'");
2449
        InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'");
2450
        InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'");
2451

2452
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'");
2453
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandScope, "'Scope'");
2454
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Equal'");
2455
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Unequal'");
2456
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'");
2457
        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'");
2458

2459
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'");
2460
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandScope, "'Scope'");
2461
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Equal'");
2462
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Unequal'");
2463
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'");
2464
        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'");
2465

2466
        InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'");
2467
        InstructionDesc[OpAtomicIIncrement].operands.push(OperandScope, "'Scope'");
2468
        InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'");
2469

2470
        InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'");
2471
        InstructionDesc[OpAtomicIDecrement].operands.push(OperandScope, "'Scope'");
2472
        InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'");
2473

2474
        InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'");
2475
        InstructionDesc[OpAtomicIAdd].operands.push(OperandScope, "'Scope'");
2476
        InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'");
2477
        InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'");
2478

2479
        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Pointer'");
2480
        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandScope, "'Scope'");
2481
        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandMemorySemantics, "'Semantics'");
2482
        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Value'");
2483

2484
        InstructionDesc[OpAssumeTrueKHR].operands.push(OperandId, "'Condition'");
2485

2486
        InstructionDesc[OpExpectKHR].operands.push(OperandId, "'Value'");
2487
        InstructionDesc[OpExpectKHR].operands.push(OperandId, "'ExpectedValue'");
2488

2489
        InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'");
2490
        InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'");
2491
        InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'");
2492
        InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'");
2493

2494
        InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'");
2495
        InstructionDesc[OpAtomicUMin].operands.push(OperandScope, "'Scope'");
2496
        InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'");
2497
        InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'");
2498

2499
        InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'");
2500
        InstructionDesc[OpAtomicUMax].operands.push(OperandScope, "'Scope'");
2501
        InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'");
2502
        InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'");
2503

2504
        InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Pointer'");
2505
        InstructionDesc[OpAtomicSMin].operands.push(OperandScope, "'Scope'");
2506
        InstructionDesc[OpAtomicSMin].operands.push(OperandMemorySemantics, "'Semantics'");
2507
        InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Value'");
2508

2509
        InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Pointer'");
2510
        InstructionDesc[OpAtomicSMax].operands.push(OperandScope, "'Scope'");
2511
        InstructionDesc[OpAtomicSMax].operands.push(OperandMemorySemantics, "'Semantics'");
2512
        InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Value'");
2513

2514
        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Pointer'");
2515
        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandScope, "'Scope'");
2516
        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandMemorySemantics, "'Semantics'");
2517
        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Value'");
2518

2519
        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Pointer'");
2520
        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandScope, "'Scope'");
2521
        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandMemorySemantics, "'Semantics'");
2522
        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Value'");
2523

2524
        InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Pointer'");
2525
        InstructionDesc[OpAtomicAnd].operands.push(OperandScope, "'Scope'");
2526
        InstructionDesc[OpAtomicAnd].operands.push(OperandMemorySemantics, "'Semantics'");
2527
        InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Value'");
2528

2529
        InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Pointer'");
2530
        InstructionDesc[OpAtomicOr].operands.push(OperandScope, "'Scope'");
2531
        InstructionDesc[OpAtomicOr].operands.push(OperandMemorySemantics, "'Semantics'");
2532
        InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Value'");
2533

2534
        InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Pointer'");
2535
        InstructionDesc[OpAtomicXor].operands.push(OperandScope, "'Scope'");
2536
        InstructionDesc[OpAtomicXor].operands.push(OperandMemorySemantics, "'Semantics'");
2537
        InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Value'");
2538

2539
        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandId, "'Pointer'");
2540
        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandScope, "'Scope'");
2541
        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandMemorySemantics, "'Semantics'");
2542

2543
        InstructionDesc[OpAtomicFlagClear].operands.push(OperandId, "'Pointer'");
2544
        InstructionDesc[OpAtomicFlagClear].operands.push(OperandScope, "'Scope'");
2545
        InstructionDesc[OpAtomicFlagClear].operands.push(OperandMemorySemantics, "'Semantics'");
2546

2547
        InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Merge Block'");
2548
        InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Continue Target'");
2549
        InstructionDesc[OpLoopMerge].operands.push(OperandLoop, "");
2550
        InstructionDesc[OpLoopMerge].operands.push(OperandOptionalLiteral, "");
2551

2552
        InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Merge Block'");
2553
        InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, "");
2554

2555
        InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'");
2556

2557
        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'");
2558
        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'");
2559
        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'");
2560
        InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'");
2561

2562
        InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'");
2563
        InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'");
2564
        InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'");
2565

2566

2567
        InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'");
2568

2569
        InstructionDesc[OpLifetimeStart].operands.push(OperandId, "'Pointer'");
2570
        InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, "'Size'");
2571

2572
        InstructionDesc[OpLifetimeStop].operands.push(OperandId, "'Pointer'");
2573
        InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, "'Size'");
2574

2575
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandScope, "'Execution'");
2576
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Destination'");
2577
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Source'");
2578
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Num Elements'");
2579
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Stride'");
2580
        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Event'");
2581

2582
        InstructionDesc[OpGroupWaitEvents].operands.push(OperandScope, "'Execution'");
2583
        InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Num Events'");
2584
        InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Events List'");
2585

2586
        InstructionDesc[OpGroupAll].operands.push(OperandScope, "'Execution'");
2587
        InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'");
2588

2589
        InstructionDesc[OpGroupAny].operands.push(OperandScope, "'Execution'");
2590
        InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'");
2591

2592
        InstructionDesc[OpGroupBroadcast].operands.push(OperandScope, "'Execution'");
2593
        InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'");
2594
        InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'");
2595

2596
        InstructionDesc[OpGroupIAdd].operands.push(OperandScope, "'Execution'");
2597
        InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'");
2598
        InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'");
2599

2600
        InstructionDesc[OpGroupFAdd].operands.push(OperandScope, "'Execution'");
2601
        InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'");
2602
        InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'");
2603

2604
        InstructionDesc[OpGroupUMin].operands.push(OperandScope, "'Execution'");
2605
        InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'");
2606
        InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'");
2607

2608
        InstructionDesc[OpGroupSMin].operands.push(OperandScope, "'Execution'");
2609
        InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'");
2610
        InstructionDesc[OpGroupSMin].operands.push(OperandId, "X");
2611

2612
        InstructionDesc[OpGroupFMin].operands.push(OperandScope, "'Execution'");
2613
        InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'");
2614
        InstructionDesc[OpGroupFMin].operands.push(OperandId, "X");
2615

2616
        InstructionDesc[OpGroupUMax].operands.push(OperandScope, "'Execution'");
2617
        InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'");
2618
        InstructionDesc[OpGroupUMax].operands.push(OperandId, "X");
2619

2620
        InstructionDesc[OpGroupSMax].operands.push(OperandScope, "'Execution'");
2621
        InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'");
2622
        InstructionDesc[OpGroupSMax].operands.push(OperandId, "X");
2623

2624
        InstructionDesc[OpGroupFMax].operands.push(OperandScope, "'Execution'");
2625
        InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'");
2626
        InstructionDesc[OpGroupFMax].operands.push(OperandId, "X");
2627

2628
        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pipe'");
2629
        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pointer'");
2630
        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Size'");
2631
        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Alignment'");
2632

2633
        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pipe'");
2634
        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pointer'");
2635
        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Size'");
2636
        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Alignment'");
2637

2638
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pipe'");
2639
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Reserve Id'");
2640
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Index'");
2641
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pointer'");
2642
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Size'");
2643
        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Alignment'");
2644

2645
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pipe'");
2646
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Reserve Id'");
2647
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Index'");
2648
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pointer'");
2649
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Size'");
2650
        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Alignment'");
2651

2652
        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
2653
        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
2654
        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
2655
        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
2656

2657
        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
2658
        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
2659
        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
2660
        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
2661

2662
        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Pipe'");
2663
        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
2664
        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Size'");
2665
        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
2666

2667
        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Pipe'");
2668
        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
2669
        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Size'");
2670
        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
2671

2672
        InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'Reserve Id'");
2673

2674
        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Pipe'");
2675
        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Size'");
2676
        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Alignment'");
2677

2678
        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Pipe'");
2679
        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Size'");
2680
        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Alignment'");
2681

2682
        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandScope, "'Execution'");
2683
        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
2684
        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
2685
        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
2686
        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
2687

2688
        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandScope, "'Execution'");
2689
        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
2690
        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
2691
        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
2692
        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
2693

2694
        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandScope, "'Execution'");
2695
        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Pipe'");
2696
        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
2697
        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Size'");
2698
        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
2699

2700
        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandScope, "'Execution'");
2701
        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Pipe'");
2702
        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
2703
        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Size'");
2704
        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
2705

2706
        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'");
2707
        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'");
2708
        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'");
2709

2710
        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Event'");
2711
        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Profiling Info'");
2712
        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Value'");
2713

2714
        InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Event'");
2715
        InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Status'");
2716

2717
        InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'Event'");
2718

2719
        InstructionDesc[OpRetainEvent].operands.push(OperandId, "'Event'");
2720

2721
        InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'Event'");
2722

2723
        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'");
2724
        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param'");
2725
        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Size'");
2726
        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Align'");
2727

2728
        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'");
2729
        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param'");
2730
        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Size'");
2731
        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Align'");
2732

2733
        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'");
2734
        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'");
2735
        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param'");
2736
        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Size'");
2737
        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Align'");
2738

2739
        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'");
2740
        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'");
2741
        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param'");
2742
        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Size'");
2743
        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Align'");
2744

2745
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Queue'");
2746
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Flags'");
2747
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'");
2748
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'");
2749
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'");
2750
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'");
2751
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'");
2752
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'");
2753
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'");
2754
        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'");
2755
        InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'");
2756

2757
        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Queue'");
2758
        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'");
2759
        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'");
2760
        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'");
2761

2762
        InstructionDesc[OpGroupNonUniformElect].operands.push(OperandScope, "'Execution'");
2763

2764
        InstructionDesc[OpGroupNonUniformAll].operands.push(OperandScope, "'Execution'");
2765
        InstructionDesc[OpGroupNonUniformAll].operands.push(OperandId, "X");
2766

2767
        InstructionDesc[OpGroupNonUniformAny].operands.push(OperandScope, "'Execution'");
2768
        InstructionDesc[OpGroupNonUniformAny].operands.push(OperandId, "X");
2769

2770
        InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandScope, "'Execution'");
2771
        InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandId, "X");
2772

2773
        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandScope, "'Execution'");
2774
        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "X");
2775
        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "ID");
2776

2777
        InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandScope, "'Execution'");
2778
        InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandId, "X");
2779

2780
        InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandScope, "'Execution'");
2781
        InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandId, "X");
2782

2783
        InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandScope, "'Execution'");
2784
        InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandId, "X");
2785

2786
        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandScope, "'Execution'");
2787
        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "X");
2788
        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "Bit");
2789

2790
        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandScope, "'Execution'");
2791
        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandGroupOperation, "'Operation'");
2792
        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandId, "X");
2793

2794
        InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandScope, "'Execution'");
2795
        InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandId, "X");
2796

2797
        InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandScope, "'Execution'");
2798
        InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandId, "X");
2799

2800
        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandScope, "'Execution'");
2801
        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "X");
2802
        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "'Id'");
2803

2804
        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandScope, "'Execution'");
2805
        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "X");
2806
        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "Mask");
2807

2808
        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandScope, "'Execution'");
2809
        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "X");
2810
        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "Offset");
2811

2812
        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandScope, "'Execution'");
2813
        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "X");
2814
        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "Offset");
2815

2816
        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandScope, "'Execution'");
2817
        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandGroupOperation, "'Operation'");
2818
        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "X");
2819
        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "'ClusterSize'", true);
2820

2821
        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandScope, "'Execution'");
2822
        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandGroupOperation, "'Operation'");
2823
        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "X");
2824
        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "'ClusterSize'", true);
2825

2826
        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandScope, "'Execution'");
2827
        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandGroupOperation, "'Operation'");
2828
        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "X");
2829
        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "'ClusterSize'", true);
2830

2831
        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandScope, "'Execution'");
2832
        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandGroupOperation, "'Operation'");
2833
        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "X");
2834
        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "'ClusterSize'", true);
2835

2836
        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandScope, "'Execution'");
2837
        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandGroupOperation, "'Operation'");
2838
        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "X");
2839
        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "'ClusterSize'", true);
2840

2841
        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandScope, "'Execution'");
2842
        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandGroupOperation, "'Operation'");
2843
        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "X");
2844
        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "'ClusterSize'", true);
2845

2846
        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandScope, "'Execution'");
2847
        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandGroupOperation, "'Operation'");
2848
        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "X");
2849
        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "'ClusterSize'", true);
2850

2851
        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandScope, "'Execution'");
2852
        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandGroupOperation, "'Operation'");
2853
        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "X");
2854
        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "'ClusterSize'", true);
2855

2856
        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandScope, "'Execution'");
2857
        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandGroupOperation, "'Operation'");
2858
        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "X");
2859
        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "'ClusterSize'", true);
2860

2861
        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandScope, "'Execution'");
2862
        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandGroupOperation, "'Operation'");
2863
        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "X");
2864
        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "'ClusterSize'", true);
2865

2866
        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandScope, "'Execution'");
2867
        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandGroupOperation, "'Operation'");
2868
        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "X");
2869
        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "'ClusterSize'", true);
2870

2871
        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandScope, "'Execution'");
2872
        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandGroupOperation, "'Operation'");
2873
        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "X");
2874
        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "'ClusterSize'", true);
2875

2876
        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandScope, "'Execution'");
2877
        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandGroupOperation, "'Operation'");
2878
        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "X");
2879
        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "'ClusterSize'", true);
2880

2881
        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandScope, "'Execution'");
2882
        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandGroupOperation, "'Operation'");
2883
        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "X");
2884
        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "'ClusterSize'", true);
2885

2886
        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandScope, "'Execution'");
2887
        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandGroupOperation, "'Operation'");
2888
        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "X");
2889
        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "'ClusterSize'", true);
2890

2891
        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandScope, "'Execution'");
2892
        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandGroupOperation, "'Operation'");
2893
        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "X");
2894
        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "'ClusterSize'", true);
2895

2896
        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandScope, "'Execution'");
2897
        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "X");
2898
        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "'Id'");
2899

2900
        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandScope, "'Execution'");
2901
        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "X");
2902
        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "'Direction'");
2903

2904
        InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'");
2905

2906
        InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'");
2907

2908
        InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandScope, "'Execution'");
2909
        InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandId, "'Predicate'");
2910

2911
        InstructionDesc[OpSubgroupAllKHR].operands.push(OperandScope, "'Execution'");
2912
        InstructionDesc[OpSubgroupAllKHR].operands.push(OperandId, "'Predicate'");
2913

2914
        InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'");
2915
        InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'");
2916

2917
        InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandScope, "'Execution'");
2918
        InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'X'");
2919
        InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'Delta'");
2920
        InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'ClusterSize'", true);
2921

2922
        InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
2923
        InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
2924

2925
        InstructionDesc[OpModuleProcessed].operands.push(OperandLiteralString, "'process'");
2926

2927
        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
2928
        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2929
        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'");
2930

2931
        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
2932
        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2933
        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandId, "'X'");
2934

2935
        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
2936
        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2937
        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandId, "'X'");
2938

2939
        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
2940
        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2941
        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandId, "X");
2942

2943
        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
2944
        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2945
        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandId, "X");
2946

2947
        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
2948
        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2949
        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandId, "X");
2950

2951
        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
2952
        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2953
        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandId, "X");
2954

2955
        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
2956
        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
2957
        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandId, "X");
2958

2959
        InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Image'");
2960
        InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Coordinate'");
2961

2962
        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Image'");
2963
        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Coordinate'");
2964
        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Fragment Index'");
2965

2966
        InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
2967

2968
        InstructionDesc[OpGroupNonUniformQuadAllKHR].operands.push(OperandId, "'Predicate'");
2969
        InstructionDesc[OpGroupNonUniformQuadAnyKHR].operands.push(OperandId, "'Predicate'");
2970
        InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
2971

2972
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Acceleration Structure'");
2973
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
2974
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
2975
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
2976
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
2977
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
2978
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
2979
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
2980
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
2981
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
2982
        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
2983
        InstructionDesc[OpTraceNV].setResultAndType(false, false);
2984

2985
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
2986
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Flags'");
2987
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Cull Mask'");
2988
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
2989
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
2990
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
2991
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Origin'");
2992
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMin'");
2993
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Direction'");
2994
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMax'");
2995
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Time'");
2996
        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Payload'");
2997
        InstructionDesc[OpTraceRayMotionNV].setResultAndType(false, false);
2998

2999
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Acceleration Structure'");
3000
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Flags'");
3001
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Cull Mask'");
3002
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Offset'");
3003
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Stride'");
3004
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Miss Index'");
3005
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Origin'");
3006
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMin'");
3007
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Direction'");
3008
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMax'");
3009
        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Payload'");
3010
        InstructionDesc[OpTraceRayKHR].setResultAndType(false, false);
3011

3012
        InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Parameter'");
3013
        InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Kind'");
3014

3015
        InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
3016

3017
        InstructionDesc[OpIgnoreIntersectionKHR].setResultAndType(false, false);
3018

3019
        InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
3020

3021
        InstructionDesc[OpTerminateRayKHR].setResultAndType(false, false);
3022

3023
        InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
3024
        InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
3025
        InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
3026

3027
        InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "SBT Record Index");
3028
        InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData");
3029
        InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
3030

3031
        InstructionDesc[OpConvertUToAccelerationStructureKHR].operands.push(OperandId, "Value");
3032
        InstructionDesc[OpConvertUToAccelerationStructureKHR].setResultAndType(true, true);
3033

3034
        // Ray Query
3035
        InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
3036
        InstructionDesc[OpTypeRayQueryKHR].setResultAndType(true, false);
3037

3038
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
3039
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
3040
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
3041
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
3042
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
3043
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
3044
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
3045
        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
3046
        InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
3047

3048
        InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
3049
        InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
3050

3051
        InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
3052
        InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
3053
        InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
3054

3055
        InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
3056
        InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
3057

3058
        InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
3059
        InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
3060

3061
        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
3062
        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
3063
        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
3064

3065
        InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
3066
        InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
3067

3068
        InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
3069
        InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
3070

3071
        InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
3072
        InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
3073
        InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
3074

3075
        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
3076
        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
3077
        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
3078

3079
        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
3080
        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
3081
        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
3082

3083
        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
3084
        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
3085
        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
3086

3087
        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
3088
        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
3089
        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
3090

3091
        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
3092
        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
3093
        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
3094

3095
        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
3096
        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
3097
        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
3098

3099
        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
3100
        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
3101
        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
3102

3103
        InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
3104
        InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
3105

3106
        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
3107
        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
3108
        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
3109

3110
        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
3111
        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
3112
        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
3113

3114
        InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
3115
        InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
3116

3117
        InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
3118
        InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
3119

3120
        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
3121
        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
3122
        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
3123

3124
        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
3125
        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
3126
        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
3127

3128
        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'RayQuery'");
3129
        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
3130
        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].setResultAndType(true, true);
3131

3132
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
3133
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
3134
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
3135
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'");
3136
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true);
3137
        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true);
3138

3139
        InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
3140
        InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
3141

3142
        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountX'");
3143
        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountY'");
3144
        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountZ'");
3145
        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'Payload'");
3146
        InstructionDesc[OpEmitMeshTasksEXT].setResultAndType(false, false);
3147

3148
        InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
3149
        InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
3150
        InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
3151

3152

3153
        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
3154
        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
3155
        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
3156
        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'");
3157

3158
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'");
3159
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'");
3160
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'");
3161
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
3162
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true);
3163
        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true);
3164

3165
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'");
3166
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'");
3167
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'");
3168
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'");
3169
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
3170
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true);
3171
        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true);
3172

3173
        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'");
3174
        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'");
3175
        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'");
3176

3177
        InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'");
3178

3179
        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Component Type'");
3180
        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Scope'");
3181
        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Rows'");
3182
        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Columns'");
3183
        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Use'");
3184

3185
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Pointer'");
3186
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Memory Layout'");
3187
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Stride'");
3188
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
3189
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandLiteralNumber, "", true);
3190
        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "", true);
3191

3192
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Pointer'");
3193
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Object'");
3194
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Memory Layout'");
3195
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Stride'");
3196
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
3197
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandLiteralNumber, "", true);
3198
        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "", true);
3199

3200
        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'A'");
3201
        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'B'");
3202
        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'C'");
3203
        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
3204

3205
        InstructionDesc[OpCooperativeMatrixLengthKHR].operands.push(OperandId, "'Type'");
3206

3207
        InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
3208

3209
        InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
3210

3211
        InstructionDesc[OpTypeHitObjectNV].setResultAndType(true, false);
3212

3213
        InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].operands.push(OperandId, "'HitObject'");
3214
        InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].setResultAndType(true, true);
3215

3216
        InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Hint'");
3217
        InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Bits'");
3218
        InstructionDesc[OpReorderThreadWithHintNV].setResultAndType(false, false);
3219

3220
        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'HitObject'");
3221
        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Hint'");
3222
        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Bits'");
3223
        InstructionDesc[OpReorderThreadWithHitObjectNV].setResultAndType(false, false);
3224

3225
        InstructionDesc[OpHitObjectGetCurrentTimeNV].operands.push(OperandId, "'HitObject'");
3226
        InstructionDesc[OpHitObjectGetCurrentTimeNV].setResultAndType(true, true);
3227

3228
        InstructionDesc[OpHitObjectGetHitKindNV].operands.push(OperandId, "'HitObject'");
3229
        InstructionDesc[OpHitObjectGetHitKindNV].setResultAndType(true, true);
3230

3231
        InstructionDesc[OpHitObjectGetPrimitiveIndexNV].operands.push(OperandId, "'HitObject'");
3232
        InstructionDesc[OpHitObjectGetPrimitiveIndexNV].setResultAndType(true, true);
3233

3234
        InstructionDesc[OpHitObjectGetGeometryIndexNV].operands.push(OperandId, "'HitObject'");
3235
        InstructionDesc[OpHitObjectGetGeometryIndexNV].setResultAndType(true, true);
3236

3237
        InstructionDesc[OpHitObjectGetInstanceIdNV].operands.push(OperandId, "'HitObject'");
3238
        InstructionDesc[OpHitObjectGetInstanceIdNV].setResultAndType(true, true);
3239

3240
        InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].operands.push(OperandId, "'HitObject'");
3241
        InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].setResultAndType(true, true);
3242

3243
        InstructionDesc[OpHitObjectGetObjectRayDirectionNV].operands.push(OperandId, "'HitObject'");
3244
        InstructionDesc[OpHitObjectGetObjectRayDirectionNV].setResultAndType(true, true);
3245

3246
        InstructionDesc[OpHitObjectGetObjectRayOriginNV].operands.push(OperandId, "'HitObject'");
3247
        InstructionDesc[OpHitObjectGetObjectRayOriginNV].setResultAndType(true, true);
3248

3249
        InstructionDesc[OpHitObjectGetWorldRayDirectionNV].operands.push(OperandId, "'HitObject'");
3250
        InstructionDesc[OpHitObjectGetWorldRayDirectionNV].setResultAndType(true, true);
3251

3252
        InstructionDesc[OpHitObjectGetWorldRayOriginNV].operands.push(OperandId, "'HitObject'");
3253
        InstructionDesc[OpHitObjectGetWorldRayOriginNV].setResultAndType(true, true);
3254

3255
        InstructionDesc[OpHitObjectGetWorldToObjectNV].operands.push(OperandId, "'HitObject'");
3256
        InstructionDesc[OpHitObjectGetWorldToObjectNV].setResultAndType(true, true);
3257

3258
        InstructionDesc[OpHitObjectGetObjectToWorldNV].operands.push(OperandId, "'HitObject'");
3259
        InstructionDesc[OpHitObjectGetObjectToWorldNV].setResultAndType(true, true);
3260

3261
        InstructionDesc[OpHitObjectGetRayTMaxNV].operands.push(OperandId, "'HitObject'");
3262
        InstructionDesc[OpHitObjectGetRayTMaxNV].setResultAndType(true, true);
3263

3264
        InstructionDesc[OpHitObjectGetRayTMinNV].operands.push(OperandId, "'HitObject'");
3265
        InstructionDesc[OpHitObjectGetRayTMinNV].setResultAndType(true, true);
3266

3267
        InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].operands.push(OperandId, "'HitObject'");
3268
        InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].setResultAndType(true, true);
3269

3270
        InstructionDesc[OpHitObjectIsEmptyNV].operands.push(OperandId, "'HitObject'");
3271
        InstructionDesc[OpHitObjectIsEmptyNV].setResultAndType(true, true);
3272

3273
        InstructionDesc[OpHitObjectIsHitNV].operands.push(OperandId, "'HitObject'");
3274
        InstructionDesc[OpHitObjectIsHitNV].setResultAndType(true, true);
3275

3276
        InstructionDesc[OpHitObjectIsMissNV].operands.push(OperandId, "'HitObject'");
3277
        InstructionDesc[OpHitObjectIsMissNV].setResultAndType(true, true);
3278

3279
        InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObject'");
3280
        InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObjectAttribute'");
3281
        InstructionDesc[OpHitObjectGetAttributesNV].setResultAndType(false, false);
3282

3283
        InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'HitObject'");
3284
        InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'Payload'");
3285
        InstructionDesc[OpHitObjectExecuteShaderNV].setResultAndType(false, false);
3286

3287
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject'");
3288
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Acceleration Structure'");
3289
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'InstanceId'");
3290
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'PrimitiveId'");
3291
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'GeometryIndex'");
3292
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitKind'");
3293
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Offset'");
3294
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Stride'");
3295
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Origin'");
3296
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMin'");
3297
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Direction'");
3298
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMax'");
3299
        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject Attribute'");
3300
        InstructionDesc[OpHitObjectRecordHitNV].setResultAndType(false, false);
3301

3302
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject'");
3303
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Acceleration Structure'");
3304
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'InstanceId'");
3305
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'PrimitiveId'");
3306
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'GeometryIndex'");
3307
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitKind'");
3308
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Offset'");
3309
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Stride'");
3310
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Origin'");
3311
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMin'");
3312
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Direction'");
3313
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMax'");
3314
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Current Time'");
3315
        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject Attribute'");
3316
        InstructionDesc[OpHitObjectRecordHitMotionNV].setResultAndType(false, false);
3317

3318
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject'");
3319
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Acceleration Structure'");
3320
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'InstanceId'");
3321
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'PrimitiveId'");
3322
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'GeometryIndex'");
3323
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitKind'");
3324
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'SBT Record Index'");
3325
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Origin'");
3326
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMin'");
3327
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Direction'");
3328
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMax'");
3329
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject Attribute'");
3330
        InstructionDesc[OpHitObjectRecordHitWithIndexNV].setResultAndType(false, false);
3331

3332
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject'");
3333
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Acceleration Structure'");
3334
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'InstanceId'");
3335
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'PrimitiveId'");
3336
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'GeometryIndex'");
3337
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitKind'");
3338
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'SBT Record Index'");
3339
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Origin'");
3340
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMin'");
3341
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Direction'");
3342
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMax'");
3343
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Current Time'");
3344
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject Attribute'");
3345
        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].setResultAndType(false, false);
3346

3347
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'HitObject'");
3348
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'SBT Index'");
3349
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Origin'");
3350
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMin'");
3351
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Direction'");
3352
        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMax'");
3353
        InstructionDesc[OpHitObjectRecordMissNV].setResultAndType(false, false);
3354

3355
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'HitObject'");
3356
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'SBT Index'");
3357
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Origin'");
3358
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMin'");
3359
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Direction'");
3360
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMax'");
3361
        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Current Time'");
3362
        InstructionDesc[OpHitObjectRecordMissMotionNV].setResultAndType(false, false);
3363

3364
        InstructionDesc[OpHitObjectRecordEmptyNV].operands.push(OperandId, "'HitObject'");
3365
        InstructionDesc[OpHitObjectRecordEmptyNV].setResultAndType(false, false);
3366

3367
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'HitObject'");
3368
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Acceleration Structure'");
3369
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'RayFlags'");
3370
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Cullmask'");
3371
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Offset'");
3372
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Stride'");
3373
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Miss Index'");
3374
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Origin'");
3375
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMin'");
3376
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Direction'");
3377
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMax'");
3378
        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Payload'");
3379
        InstructionDesc[OpHitObjectTraceRayNV].setResultAndType(false, false);
3380

3381
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'HitObject'");
3382
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
3383
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'RayFlags'");
3384
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Cullmask'");
3385
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
3386
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
3387
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
3388
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Origin'");
3389
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMin'");
3390
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Direction'");
3391
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMax'");
3392
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Time'");
3393
        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
3394
        InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
3395

3396
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Acceleration Structure'");
3397
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Instance ID'");
3398
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Geometry Index'");
3399
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Primitive Index'");
3400
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Barycentrics'");
3401
        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].setResultAndType(true, true);
3402

3403
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Acceleration Structure'");
3404
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Instance ID'");
3405
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Geometry Index'");
3406
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Primitive Index'");
3407
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Barycentrics'");
3408
        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].setResultAndType(true, true);
3409

3410
        InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Attachment'");
3411
        InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
3412
        InstructionDesc[OpStencilAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
3413
        InstructionDesc[OpDepthAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
3414

3415
        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'source texture'");
3416
        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'texture coordinates'");
3417
        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'weights texture'");
3418
        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandImageOperands, "", true);
3419
        InstructionDesc[OpImageSampleWeightedQCOM].setResultAndType(true, true);
3420

3421
        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'source texture'");
3422
        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'texture coordinates'");
3423
        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'box size'");
3424
        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandImageOperands, "", true);
3425
        InstructionDesc[OpImageBoxFilterQCOM].setResultAndType(true, true);
3426

3427
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target texture'");
3428
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target coordinates'");
3429
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference texture'");
3430
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference coordinates'");
3431
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'block size'");
3432
        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandImageOperands, "", true);
3433
        InstructionDesc[OpImageBlockMatchSADQCOM].setResultAndType(true, true);
3434

3435
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target texture'");
3436
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target coordinates'");
3437
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference texture'");
3438
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference coordinates'");
3439
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'block size'");
3440
        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandImageOperands, "", true);
3441
        InstructionDesc[OpImageBlockMatchSSDQCOM].setResultAndType(true, true);
3442

3443
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target texture'");
3444
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target coordinates'");
3445
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference texture'");
3446
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference coordinates'");
3447
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'block size'");
3448
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandImageOperands, "", true);
3449
        InstructionDesc[OpImageBlockMatchWindowSSDQCOM].setResultAndType(true, true);
3450

3451
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target texture'");
3452
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target coordinates'");
3453
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference texture'");
3454
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference coordinates'");
3455
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'block size'");
3456
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandImageOperands, "", true);
3457
        InstructionDesc[OpImageBlockMatchWindowSADQCOM].setResultAndType(true, true);
3458

3459
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target texture'");
3460
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target coordinates'");
3461
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference texture'");
3462
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference coordinates'");
3463
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'block size'");
3464
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandImageOperands, "", true);
3465
        InstructionDesc[OpImageBlockMatchGatherSSDQCOM].setResultAndType(true, true);
3466

3467
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target texture'");
3468
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target coordinates'");
3469
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference texture'");
3470
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference coordinates'");
3471
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'block size'");
3472
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandImageOperands, "", true);
3473
        InstructionDesc[OpImageBlockMatchGatherSADQCOM].setResultAndType(true, true);
3474
    });
3475
}
3476

3477
}; // end spv namespace
3478

3479
Product

Resources

Company
