1 // 2 // Copyright (C) 2014-2015 LunarG, Inc. 3 // 4 // All rights reserved. 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions 8 // are met: 9 // 10 // Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 13 // Redistributions in binary form must reproduce the above 14 // copyright notice, this list of conditions and the following 15 // disclaimer in the documentation and/or other materials provided 16 // with the distribution. 17 // 18 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its 19 // contributors may be used to endorse or promote products derived 20 // from this software without specific prior written permission. 21 // 22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 // POSSIBILITY OF SUCH DAMAGE. 34 35 // 36 // 1) Programmatically fill in instruction/operand information. 37 // This can be used for disassembly, printing documentation, etc. 38 // 39 // 2) Print documentation from this parameterization. 40 // 41 42 #include "doc.h" 43 44 #include <cstdio> 45 #include <cstring> 46 #include <algorithm> 47 48 namespace spv { 49 extern "C" { 50 // Include C-based headers that don't have a namespace 51 #include "GLSL.ext.KHR.h" 52 #ifdef AMD_EXTENSIONS 53 #include "GLSL.ext.AMD.h" 54 #endif 55 #ifdef NV_EXTENSIONS 56 #include "GLSL.ext.NV.h" 57 #endif 58 } 59 } 60 61 namespace spv { 62 63 // 64 // Whole set of functions that translate enumerants to their text strings for 65 // the specification (or their sanitized versions for auto-generating the 66 // spirv headers. 67 // 68 // Also, the ceilings are declared next to these, to help keep them in sync. 69 // Ceilings should be 70 // - one more than the maximum value an enumerant takes on, for non-mask enumerants 71 // (for non-sparse enums, this is the number of enumerants) 72 // - the number of bits consumed by the set of masks 73 // (for non-sparse mask enums, this is the number of enumerants) 74 // 75 76 const int SourceLanguageCeiling = 6; // HLSL todo: need official enumerant 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 case SourceLanguageCeiling: 89 default: return "Bad"; 90 } 91 } 92 93 const int ExecutionModelCeiling = 7; 94 95 const char* ExecutionModelString(int model) 96 { 97 switch (model) { 98 case 0: return "Vertex"; 99 case 1: return "TessellationControl"; 100 case 2: return "TessellationEvaluation"; 101 case 3: return "Geometry"; 102 case 4: return "Fragment"; 103 case 5: return "GLCompute"; 104 case 6: return "Kernel"; 105 106 case ExecutionModelCeiling: 107 default: return "Bad"; 108 } 109 } 110 111 const int AddressingModelCeiling = 3; 112 113 const char* AddressingString(int addr) 114 { 115 switch (addr) { 116 case 0: return "Logical"; 117 case 1: return "Physical32"; 118 case 2: return "Physical64"; 119 120 case AddressingModelCeiling: 121 default: return "Bad"; 122 } 123 } 124 125 const int MemoryModelCeiling = 3; 126 127 const char* MemoryString(int mem) 128 { 129 switch (mem) { 130 case 0: return "Simple"; 131 case 1: return "GLSL450"; 132 case 2: return "OpenCL"; 133 134 case MemoryModelCeiling: 135 default: return "Bad"; 136 } 137 } 138 139 const int ExecutionModeCeiling = 33; 140 141 const char* ExecutionModeString(int mode) 142 { 143 switch (mode) { 144 case 0: return "Invocations"; 145 case 1: return "SpacingEqual"; 146 case 2: return "SpacingFractionalEven"; 147 case 3: return "SpacingFractionalOdd"; 148 case 4: return "VertexOrderCw"; 149 case 5: return "VertexOrderCcw"; 150 case 6: return "PixelCenterInteger"; 151 case 7: return "OriginUpperLeft"; 152 case 8: return "OriginLowerLeft"; 153 case 9: return "EarlyFragmentTests"; 154 case 10: return "PointMode"; 155 case 11: return "Xfb"; 156 case 12: return "DepthReplacing"; 157 case 13: return "Bad"; 158 case 14: return "DepthGreater"; 159 case 15: return "DepthLess"; 160 case 16: return "DepthUnchanged"; 161 case 17: return "LocalSize"; 162 case 18: return "LocalSizeHint"; 163 case 19: return "InputPoints"; 164 case 20: return "InputLines"; 165 case 21: return "InputLinesAdjacency"; 166 case 22: return "Triangles"; 167 case 23: return "InputTrianglesAdjacency"; 168 case 24: return "Quads"; 169 case 25: return "Isolines"; 170 case 26: return "OutputVertices"; 171 case 27: return "OutputPoints"; 172 case 28: return "OutputLineStrip"; 173 case 29: return "OutputTriangleStrip"; 174 case 30: return "VecTypeHint"; 175 case 31: return "ContractionOff"; 176 case 32: return "Bad"; 177 178 case 4446: return "PostDepthCoverage"; 179 case ExecutionModeCeiling: 180 default: return "Bad"; 181 } 182 } 183 184 const int StorageClassCeiling = 13; 185 186 const char* StorageClassString(int StorageClass) 187 { 188 switch (StorageClass) { 189 case 0: return "UniformConstant"; 190 case 1: return "Input"; 191 case 2: return "Uniform"; 192 case 3: return "Output"; 193 case 4: return "Workgroup"; 194 case 5: return "CrossWorkgroup"; 195 case 6: return "Private"; 196 case 7: return "Function"; 197 case 8: return "Generic"; 198 case 9: return "PushConstant"; 199 case 10: return "AtomicCounter"; 200 case 11: return "Image"; 201 case 12: return "StorageBuffer"; 202 203 case StorageClassCeiling: 204 default: return "Bad"; 205 } 206 } 207 208 const int DecorationCeiling = 45; 209 210 const char* DecorationString(int decoration) 211 { 212 switch (decoration) { 213 case 0: return "RelaxedPrecision"; 214 case 1: return "SpecId"; 215 case 2: return "Block"; 216 case 3: return "BufferBlock"; 217 case 4: return "RowMajor"; 218 case 5: return "ColMajor"; 219 case 6: return "ArrayStride"; 220 case 7: return "MatrixStride"; 221 case 8: return "GLSLShared"; 222 case 9: return "GLSLPacked"; 223 case 10: return "CPacked"; 224 case 11: return "BuiltIn"; 225 case 12: return "Bad"; 226 case 13: return "NoPerspective"; 227 case 14: return "Flat"; 228 case 15: return "Patch"; 229 case 16: return "Centroid"; 230 case 17: return "Sample"; 231 case 18: return "Invariant"; 232 case 19: return "Restrict"; 233 case 20: return "Aliased"; 234 case 21: return "Volatile"; 235 case 22: return "Constant"; 236 case 23: return "Coherent"; 237 case 24: return "NonWritable"; 238 case 25: return "NonReadable"; 239 case 26: return "Uniform"; 240 case 27: return "Bad"; 241 case 28: return "SaturatedConversion"; 242 case 29: return "Stream"; 243 case 30: return "Location"; 244 case 31: return "Component"; 245 case 32: return "Index"; 246 case 33: return "Binding"; 247 case 34: return "DescriptorSet"; 248 case 35: return "Offset"; 249 case 36: return "XfbBuffer"; 250 case 37: return "XfbStride"; 251 case 38: return "FuncParamAttr"; 252 case 39: return "FP Rounding Mode"; 253 case 40: return "FP Fast Math Mode"; 254 case 41: return "Linkage Attributes"; 255 case 42: return "NoContraction"; 256 case 43: return "InputAttachmentIndex"; 257 case 44: return "Alignment"; 258 259 case DecorationCeiling: 260 default: return "Bad"; 261 262 #ifdef AMD_EXTENSIONS 263 case 4999: return "ExplicitInterpAMD"; 264 #endif 265 #ifdef NV_EXTENSIONS 266 case 5248: return "OverrideCoverageNV"; 267 case 5250: return "PassthroughNV"; 268 case 5252: return "ViewportRelativeNV"; 269 case 5256: return "SecondaryViewportRelativeNV"; 270 #endif 271 } 272 } 273 274 const int BuiltInCeiling = 44; 275 276 const char* BuiltInString(int builtIn) 277 { 278 switch (builtIn) { 279 case 0: return "Position"; 280 case 1: return "PointSize"; 281 case 2: return "Bad"; 282 case 3: return "ClipDistance"; 283 case 4: return "CullDistance"; 284 case 5: return "VertexId"; 285 case 6: return "InstanceId"; 286 case 7: return "PrimitiveId"; 287 case 8: return "InvocationId"; 288 case 9: return "Layer"; 289 case 10: return "ViewportIndex"; 290 case 11: return "TessLevelOuter"; 291 case 12: return "TessLevelInner"; 292 case 13: return "TessCoord"; 293 case 14: return "PatchVertices"; 294 case 15: return "FragCoord"; 295 case 16: return "PointCoord"; 296 case 17: return "FrontFacing"; 297 case 18: return "SampleId"; 298 case 19: return "SamplePosition"; 299 case 20: return "SampleMask"; 300 case 21: return "Bad"; 301 case 22: return "FragDepth"; 302 case 23: return "HelperInvocation"; 303 case 24: return "NumWorkgroups"; 304 case 25: return "WorkgroupSize"; 305 case 26: return "WorkgroupId"; 306 case 27: return "LocalInvocationId"; 307 case 28: return "GlobalInvocationId"; 308 case 29: return "LocalInvocationIndex"; 309 case 30: return "WorkDim"; 310 case 31: return "GlobalSize"; 311 case 32: return "EnqueuedWorkgroupSize"; 312 case 33: return "GlobalOffset"; 313 case 34: return "GlobalLinearId"; 314 case 35: return "Bad"; 315 case 36: return "SubgroupSize"; 316 case 37: return "SubgroupMaxSize"; 317 case 38: return "NumSubgroups"; 318 case 39: return "NumEnqueuedSubgroups"; 319 case 40: return "SubgroupId"; 320 case 41: return "SubgroupLocalInvocationId"; 321 case 42: return "VertexIndex"; // TBD: put next to VertexId? 322 case 43: return "InstanceIndex"; // TBD: put next to InstanceId? 323 324 case 4416: return "SubgroupEqMaskKHR"; 325 case 4417: return "SubgroupGeMaskKHR"; 326 case 4418: return "SubgroupGtMaskKHR"; 327 case 4419: return "SubgroupLeMaskKHR"; 328 case 4420: return "SubgroupLtMaskKHR"; 329 case 4438: return "DeviceIndex"; 330 case 4440: return "ViewIndex"; 331 case 4424: return "BaseVertex"; 332 case 4425: return "BaseInstance"; 333 case 4426: return "DrawIndex"; 334 case 5014: return "FragStencilRefEXT"; 335 336 #ifdef AMD_EXTENSIONS 337 case 4992: return "BaryCoordNoPerspAMD"; 338 case 4993: return "BaryCoordNoPerspCentroidAMD"; 339 case 4994: return "BaryCoordNoPerspSampleAMD"; 340 case 4995: return "BaryCoordSmoothAMD"; 341 case 4996: return "BaryCoordSmoothCentroidAMD"; 342 case 4997: return "BaryCoordSmoothSampleAMD"; 343 case 4998: return "BaryCoordPullModelAMD"; 344 #endif 345 346 #ifdef NV_EXTENSIONS 347 case 5253: return "ViewportMaskNV"; 348 case 5257: return "SecondaryPositionNV"; 349 case 5258: return "SecondaryViewportMaskNV"; 350 case 5261: return "PositionPerViewNV"; 351 case 5262: return "ViewportMaskPerViewNV"; 352 #endif 353 354 case BuiltInCeiling: 355 default: return "Bad"; 356 } 357 } 358 359 const int DimensionCeiling = 7; 360 361 const char* DimensionString(int dim) 362 { 363 switch (dim) { 364 case 0: return "1D"; 365 case 1: return "2D"; 366 case 2: return "3D"; 367 case 3: return "Cube"; 368 case 4: return "Rect"; 369 case 5: return "Buffer"; 370 case 6: return "SubpassData"; 371 372 case DimensionCeiling: 373 default: return "Bad"; 374 } 375 } 376 377 const int SamplerAddressingModeCeiling = 5; 378 379 const char* SamplerAddressingModeString(int mode) 380 { 381 switch (mode) { 382 case 0: return "None"; 383 case 1: return "ClampToEdge"; 384 case 2: return "Clamp"; 385 case 3: return "Repeat"; 386 case 4: return "RepeatMirrored"; 387 388 case SamplerAddressingModeCeiling: 389 default: return "Bad"; 390 } 391 } 392 393 const int SamplerFilterModeCeiling = 2; 394 395 const char* SamplerFilterModeString(int mode) 396 { 397 switch (mode) { 398 case 0: return "Nearest"; 399 case 1: return "Linear"; 400 401 case SamplerFilterModeCeiling: 402 default: return "Bad"; 403 } 404 } 405 406 const int ImageFormatCeiling = 40; 407 408 const char* ImageFormatString(int format) 409 { 410 switch (format) { 411 case 0: return "Unknown"; 412 413 // ES/Desktop float 414 case 1: return "Rgba32f"; 415 case 2: return "Rgba16f"; 416 case 3: return "R32f"; 417 case 4: return "Rgba8"; 418 case 5: return "Rgba8Snorm"; 419 420 // Desktop float 421 case 6: return "Rg32f"; 422 case 7: return "Rg16f"; 423 case 8: return "R11fG11fB10f"; 424 case 9: return "R16f"; 425 case 10: return "Rgba16"; 426 case 11: return "Rgb10A2"; 427 case 12: return "Rg16"; 428 case 13: return "Rg8"; 429 case 14: return "R16"; 430 case 15: return "R8"; 431 case 16: return "Rgba16Snorm"; 432 case 17: return "Rg16Snorm"; 433 case 18: return "Rg8Snorm"; 434 case 19: return "R16Snorm"; 435 case 20: return "R8Snorm"; 436 437 // ES/Desktop int 438 case 21: return "Rgba32i"; 439 case 22: return "Rgba16i"; 440 case 23: return "Rgba8i"; 441 case 24: return "R32i"; 442 443 // Desktop int 444 case 25: return "Rg32i"; 445 case 26: return "Rg16i"; 446 case 27: return "Rg8i"; 447 case 28: return "R16i"; 448 case 29: return "R8i"; 449 450 // ES/Desktop uint 451 case 30: return "Rgba32ui"; 452 case 31: return "Rgba16ui"; 453 case 32: return "Rgba8ui"; 454 case 33: return "R32ui"; 455 456 // Desktop uint 457 case 34: return "Rgb10a2ui"; 458 case 35: return "Rg32ui"; 459 case 36: return "Rg16ui"; 460 case 37: return "Rg8ui"; 461 case 38: return "R16ui"; 462 case 39: return "R8ui"; 463 464 case ImageFormatCeiling: 465 default: 466 return "Bad"; 467 } 468 } 469 470 const int ImageChannelOrderCeiling = 19; 471 472 const char* ImageChannelOrderString(int format) 473 { 474 switch (format) { 475 case 0: return "R"; 476 case 1: return "A"; 477 case 2: return "RG"; 478 case 3: return "RA"; 479 case 4: return "RGB"; 480 case 5: return "RGBA"; 481 case 6: return "BGRA"; 482 case 7: return "ARGB"; 483 case 8: return "Intensity"; 484 case 9: return "Luminance"; 485 case 10: return "Rx"; 486 case 11: return "RGx"; 487 case 12: return "RGBx"; 488 case 13: return "Depth"; 489 case 14: return "DepthStencil"; 490 case 15: return "sRGB"; 491 case 16: return "sRGBx"; 492 case 17: return "sRGBA"; 493 case 18: return "sBGRA"; 494 495 case ImageChannelOrderCeiling: 496 default: 497 return "Bad"; 498 } 499 } 500 501 const int ImageChannelDataTypeCeiling = 17; 502 503 const char* ImageChannelDataTypeString(int type) 504 { 505 switch (type) 506 { 507 case 0: return "SnormInt8"; 508 case 1: return "SnormInt16"; 509 case 2: return "UnormInt8"; 510 case 3: return "UnormInt16"; 511 case 4: return "UnormShort565"; 512 case 5: return "UnormShort555"; 513 case 6: return "UnormInt101010"; 514 case 7: return "SignedInt8"; 515 case 8: return "SignedInt16"; 516 case 9: return "SignedInt32"; 517 case 10: return "UnsignedInt8"; 518 case 11: return "UnsignedInt16"; 519 case 12: return "UnsignedInt32"; 520 case 13: return "HalfFloat"; 521 case 14: return "Float"; 522 case 15: return "UnormInt24"; 523 case 16: return "UnormInt101010_2"; 524 525 case ImageChannelDataTypeCeiling: 526 default: 527 return "Bad"; 528 } 529 } 530 531 const int ImageOperandsCeiling = 8; 532 533 const char* ImageOperandsString(int format) 534 { 535 switch (format) { 536 case 0: return "Bias"; 537 case 1: return "Lod"; 538 case 2: return "Grad"; 539 case 3: return "ConstOffset"; 540 case 4: return "Offset"; 541 case 5: return "ConstOffsets"; 542 case 6: return "Sample"; 543 case 7: return "MinLod"; 544 545 case ImageOperandsCeiling: 546 default: 547 return "Bad"; 548 } 549 } 550 551 const int FPFastMathCeiling = 5; 552 553 const char* FPFastMathString(int mode) 554 { 555 switch (mode) { 556 case 0: return "NotNaN"; 557 case 1: return "NotInf"; 558 case 2: return "NSZ"; 559 case 3: return "AllowRecip"; 560 case 4: return "Fast"; 561 562 case FPFastMathCeiling: 563 default: return "Bad"; 564 } 565 } 566 567 const int FPRoundingModeCeiling = 4; 568 569 const char* FPRoundingModeString(int mode) 570 { 571 switch (mode) { 572 case 0: return "RTE"; 573 case 1: return "RTZ"; 574 case 2: return "RTP"; 575 case 3: return "RTN"; 576 577 case FPRoundingModeCeiling: 578 default: return "Bad"; 579 } 580 } 581 582 const int LinkageTypeCeiling = 2; 583 584 const char* LinkageTypeString(int type) 585 { 586 switch (type) { 587 case 0: return "Export"; 588 case 1: return "Import"; 589 590 case LinkageTypeCeiling: 591 default: return "Bad"; 592 } 593 } 594 595 const int FuncParamAttrCeiling = 8; 596 597 const char* FuncParamAttrString(int attr) 598 { 599 switch (attr) { 600 case 0: return "Zext"; 601 case 1: return "Sext"; 602 case 2: return "ByVal"; 603 case 3: return "Sret"; 604 case 4: return "NoAlias"; 605 case 5: return "NoCapture"; 606 case 6: return "NoWrite"; 607 case 7: return "NoReadWrite"; 608 609 case FuncParamAttrCeiling: 610 default: return "Bad"; 611 } 612 } 613 614 const int AccessQualifierCeiling = 3; 615 616 const char* AccessQualifierString(int attr) 617 { 618 switch (attr) { 619 case 0: return "ReadOnly"; 620 case 1: return "WriteOnly"; 621 case 2: return "ReadWrite"; 622 623 case AccessQualifierCeiling: 624 default: return "Bad"; 625 } 626 } 627 628 const int SelectControlCeiling = 2; 629 630 const char* SelectControlString(int cont) 631 { 632 switch (cont) { 633 case 0: return "Flatten"; 634 case 1: return "DontFlatten"; 635 636 case SelectControlCeiling: 637 default: return "Bad"; 638 } 639 } 640 641 const int LoopControlCeiling = 4; 642 643 const char* LoopControlString(int cont) 644 { 645 switch (cont) { 646 case 0: return "Unroll"; 647 case 1: return "DontUnroll"; 648 case 2: return "DependencyInfinite"; 649 case 3: return "DependencyLength"; 650 651 case LoopControlCeiling: 652 default: return "Bad"; 653 } 654 } 655 656 const int FunctionControlCeiling = 4; 657 658 const char* FunctionControlString(int cont) 659 { 660 switch (cont) { 661 case 0: return "Inline"; 662 case 1: return "DontInline"; 663 case 2: return "Pure"; 664 case 3: return "Const"; 665 666 case FunctionControlCeiling: 667 default: return "Bad"; 668 } 669 } 670 671 const int MemorySemanticsCeiling = 12; 672 673 const char* MemorySemanticsString(int mem) 674 { 675 // Note: No bits set (None) means "Relaxed" 676 switch (mem) { 677 case 0: return "Bad"; // Note: this is a placeholder for 'Consume' 678 case 1: return "Acquire"; 679 case 2: return "Release"; 680 case 3: return "AcquireRelease"; 681 case 4: return "SequentiallyConsistent"; 682 case 5: return "Bad"; // Note: reserved for future expansion 683 case 6: return "UniformMemory"; 684 case 7: return "SubgroupMemory"; 685 case 8: return "WorkgroupMemory"; 686 case 9: return "CrossWorkgroupMemory"; 687 case 10: return "AtomicCounterMemory"; 688 case 11: return "ImageMemory"; 689 690 case MemorySemanticsCeiling: 691 default: return "Bad"; 692 } 693 } 694 695 const int MemoryAccessCeiling = 3; 696 697 const char* MemoryAccessString(int mem) 698 { 699 switch (mem) { 700 case 0: return "Volatile"; 701 case 1: return "Aligned"; 702 case 2: return "Nontemporal"; 703 704 case MemoryAccessCeiling: 705 default: return "Bad"; 706 } 707 } 708 709 const int ScopeCeiling = 5; 710 711 const char* ScopeString(int mem) 712 { 713 switch (mem) { 714 case 0: return "CrossDevice"; 715 case 1: return "Device"; 716 case 2: return "Workgroup"; 717 case 3: return "Subgroup"; 718 case 4: return "Invocation"; 719 720 case ScopeCeiling: 721 default: return "Bad"; 722 } 723 } 724 725 const int GroupOperationCeiling = 3; 726 727 const char* GroupOperationString(int gop) 728 { 729 730 switch (gop) 731 { 732 case 0: return "Reduce"; 733 case 1: return "InclusiveScan"; 734 case 2: return "ExclusiveScan"; 735 736 case GroupOperationCeiling: 737 default: return "Bad"; 738 } 739 } 740 741 const int KernelEnqueueFlagsCeiling = 3; 742 743 const char* KernelEnqueueFlagsString(int flag) 744 { 745 switch (flag) 746 { 747 case 0: return "NoWait"; 748 case 1: return "WaitKernel"; 749 case 2: return "WaitWorkGroup"; 750 751 case KernelEnqueueFlagsCeiling: 752 default: return "Bad"; 753 } 754 } 755 756 const int KernelProfilingInfoCeiling = 1; 757 758 const char* KernelProfilingInfoString(int info) 759 { 760 switch (info) 761 { 762 case 0: return "CmdExecTime"; 763 764 case KernelProfilingInfoCeiling: 765 default: return "Bad"; 766 } 767 } 768 769 const int CapabilityCeiling = 58; 770 771 const char* CapabilityString(int info) 772 { 773 switch (info) 774 { 775 case 0: return "Matrix"; 776 case 1: return "Shader"; 777 case 2: return "Geometry"; 778 case 3: return "Tessellation"; 779 case 4: return "Addresses"; 780 case 5: return "Linkage"; 781 case 6: return "Kernel"; 782 case 7: return "Vector16"; 783 case 8: return "Float16Buffer"; 784 case 9: return "Float16"; 785 case 10: return "Float64"; 786 case 11: return "Int64"; 787 case 12: return "Int64Atomics"; 788 case 13: return "ImageBasic"; 789 case 14: return "ImageReadWrite"; 790 case 15: return "ImageMipmap"; 791 case 16: return "Bad"; 792 case 17: return "Pipes"; 793 case 18: return "Groups"; 794 case 19: return "DeviceEnqueue"; 795 case 20: return "LiteralSampler"; 796 case 21: return "AtomicStorage"; 797 case 22: return "Int16"; 798 case 23: return "TessellationPointSize"; 799 case 24: return "GeometryPointSize"; 800 case 25: return "ImageGatherExtended"; 801 case 26: return "Bad"; 802 case 27: return "StorageImageMultisample"; 803 case 28: return "UniformBufferArrayDynamicIndexing"; 804 case 29: return "SampledImageArrayDynamicIndexing"; 805 case 30: return "StorageBufferArrayDynamicIndexing"; 806 case 31: return "StorageImageArrayDynamicIndexing"; 807 case 32: return "ClipDistance"; 808 case 33: return "CullDistance"; 809 case 34: return "ImageCubeArray"; 810 case 35: return "SampleRateShading"; 811 case 36: return "ImageRect"; 812 case 37: return "SampledRect"; 813 case 38: return "GenericPointer"; 814 case 39: return "Int8"; 815 case 40: return "InputAttachment"; 816 case 41: return "SparseResidency"; 817 case 42: return "MinLod"; 818 case 43: return "Sampled1D"; 819 case 44: return "Image1D"; 820 case 45: return "SampledCubeArray"; 821 case 46: return "SampledBuffer"; 822 case 47: return "ImageBuffer"; 823 case 48: return "ImageMSArray"; 824 case 49: return "StorageImageExtendedFormats"; 825 case 50: return "ImageQuery"; 826 case 51: return "DerivativeControl"; 827 case 52: return "InterpolationFunction"; 828 case 53: return "TransformFeedback"; 829 case 54: return "GeometryStreams"; 830 case 55: return "StorageImageReadWithoutFormat"; 831 case 56: return "StorageImageWriteWithoutFormat"; 832 case 57: return "MultiViewport"; 833 834 case 4423: return "SubgroupBallotKHR"; 835 case 4427: return "DrawParameters"; 836 case 4431: return "SubgroupVoteKHR"; 837 838 case 4433: return "StorageUniformBufferBlock16"; 839 case 4434: return "StorageUniform16"; 840 case 4435: return "StoragePushConstant16"; 841 case 4436: return "StorageInputOutput16"; 842 843 case 4437: return "DeviceGroup"; 844 case 4439: return "MultiView"; 845 846 case 5013: return "StencilExportEXT"; 847 848 #ifdef AMD_EXTENSIONS 849 case 5009: return "ImageGatherBiasLodAMD"; 850 case 5015: return "ImageReadWriteLodAMD"; 851 #endif 852 853 case 4445: return "AtomicStorageOps"; 854 855 case 4447: return "SampleMaskPostDepthCoverage"; 856 #ifdef NV_EXTENSIONS 857 case 5251: return "GeometryShaderPassthroughNV"; 858 case 5254: return "ShaderViewportIndexLayerNV"; 859 case 5255: return "ShaderViewportMaskNV"; 860 case 5259: return "ShaderStereoViewNV"; 861 case 5260: return "PerViewAttributesNV"; 862 #endif 863 864 case CapabilityCeiling: 865 default: return "Bad"; 866 } 867 } 868 869 const char* OpcodeString(int op) 870 { 871 switch (op) { 872 case 0: return "OpNop"; 873 case 1: return "OpUndef"; 874 case 2: return "OpSourceContinued"; 875 case 3: return "OpSource"; 876 case 4: return "OpSourceExtension"; 877 case 5: return "OpName"; 878 case 6: return "OpMemberName"; 879 case 7: return "OpString"; 880 case 8: return "OpLine"; 881 case 9: return "Bad"; 882 case 10: return "OpExtension"; 883 case 11: return "OpExtInstImport"; 884 case 12: return "OpExtInst"; 885 case 13: return "Bad"; 886 case 14: return "OpMemoryModel"; 887 case 15: return "OpEntryPoint"; 888 case 16: return "OpExecutionMode"; 889 case 17: return "OpCapability"; 890 case 18: return "Bad"; 891 case 19: return "OpTypeVoid"; 892 case 20: return "OpTypeBool"; 893 case 21: return "OpTypeInt"; 894 case 22: return "OpTypeFloat"; 895 case 23: return "OpTypeVector"; 896 case 24: return "OpTypeMatrix"; 897 case 25: return "OpTypeImage"; 898 case 26: return "OpTypeSampler"; 899 case 27: return "OpTypeSampledImage"; 900 case 28: return "OpTypeArray"; 901 case 29: return "OpTypeRuntimeArray"; 902 case 30: return "OpTypeStruct"; 903 case 31: return "OpTypeOpaque"; 904 case 32: return "OpTypePointer"; 905 case 33: return "OpTypeFunction"; 906 case 34: return "OpTypeEvent"; 907 case 35: return "OpTypeDeviceEvent"; 908 case 36: return "OpTypeReserveId"; 909 case 37: return "OpTypeQueue"; 910 case 38: return "OpTypePipe"; 911 case 39: return "OpTypeForwardPointer"; 912 case 40: return "Bad"; 913 case 41: return "OpConstantTrue"; 914 case 42: return "OpConstantFalse"; 915 case 43: return "OpConstant"; 916 case 44: return "OpConstantComposite"; 917 case 45: return "OpConstantSampler"; 918 case 46: return "OpConstantNull"; 919 case 47: return "Bad"; 920 case 48: return "OpSpecConstantTrue"; 921 case 49: return "OpSpecConstantFalse"; 922 case 50: return "OpSpecConstant"; 923 case 51: return "OpSpecConstantComposite"; 924 case 52: return "OpSpecConstantOp"; 925 case 53: return "Bad"; 926 case 54: return "OpFunction"; 927 case 55: return "OpFunctionParameter"; 928 case 56: return "OpFunctionEnd"; 929 case 57: return "OpFunctionCall"; 930 case 58: return "Bad"; 931 case 59: return "OpVariable"; 932 case 60: return "OpImageTexelPointer"; 933 case 61: return "OpLoad"; 934 case 62: return "OpStore"; 935 case 63: return "OpCopyMemory"; 936 case 64: return "OpCopyMemorySized"; 937 case 65: return "OpAccessChain"; 938 case 66: return "OpInBoundsAccessChain"; 939 case 67: return "OpPtrAccessChain"; 940 case 68: return "OpArrayLength"; 941 case 69: return "OpGenericPtrMemSemantics"; 942 case 70: return "OpInBoundsPtrAccessChain"; 943 case 71: return "OpDecorate"; 944 case 72: return "OpMemberDecorate"; 945 case 73: return "OpDecorationGroup"; 946 case 74: return "OpGroupDecorate"; 947 case 75: return "OpGroupMemberDecorate"; 948 case 76: return "Bad"; 949 case 77: return "OpVectorExtractDynamic"; 950 case 78: return "OpVectorInsertDynamic"; 951 case 79: return "OpVectorShuffle"; 952 case 80: return "OpCompositeConstruct"; 953 case 81: return "OpCompositeExtract"; 954 case 82: return "OpCompositeInsert"; 955 case 83: return "OpCopyObject"; 956 case 84: return "OpTranspose"; 957 case 85: return "Bad"; 958 case 86: return "OpSampledImage"; 959 case 87: return "OpImageSampleImplicitLod"; 960 case 88: return "OpImageSampleExplicitLod"; 961 case 89: return "OpImageSampleDrefImplicitLod"; 962 case 90: return "OpImageSampleDrefExplicitLod"; 963 case 91: return "OpImageSampleProjImplicitLod"; 964 case 92: return "OpImageSampleProjExplicitLod"; 965 case 93: return "OpImageSampleProjDrefImplicitLod"; 966 case 94: return "OpImageSampleProjDrefExplicitLod"; 967 case 95: return "OpImageFetch"; 968 case 96: return "OpImageGather"; 969 case 97: return "OpImageDrefGather"; 970 case 98: return "OpImageRead"; 971 case 99: return "OpImageWrite"; 972 case 100: return "OpImage"; 973 case 101: return "OpImageQueryFormat"; 974 case 102: return "OpImageQueryOrder"; 975 case 103: return "OpImageQuerySizeLod"; 976 case 104: return "OpImageQuerySize"; 977 case 105: return "OpImageQueryLod"; 978 case 106: return "OpImageQueryLevels"; 979 case 107: return "OpImageQuerySamples"; 980 case 108: return "Bad"; 981 case 109: return "OpConvertFToU"; 982 case 110: return "OpConvertFToS"; 983 case 111: return "OpConvertSToF"; 984 case 112: return "OpConvertUToF"; 985 case 113: return "OpUConvert"; 986 case 114: return "OpSConvert"; 987 case 115: return "OpFConvert"; 988 case 116: return "OpQuantizeToF16"; 989 case 117: return "OpConvertPtrToU"; 990 case 118: return "OpSatConvertSToU"; 991 case 119: return "OpSatConvertUToS"; 992 case 120: return "OpConvertUToPtr"; 993 case 121: return "OpPtrCastToGeneric"; 994 case 122: return "OpGenericCastToPtr"; 995 case 123: return "OpGenericCastToPtrExplicit"; 996 case 124: return "OpBitcast"; 997 case 125: return "Bad"; 998 case 126: return "OpSNegate"; 999 case 127: return "OpFNegate"; 1000 case 128: return "OpIAdd"; 1001 case 129: return "OpFAdd"; 1002 case 130: return "OpISub"; 1003 case 131: return "OpFSub"; 1004 case 132: return "OpIMul"; 1005 case 133: return "OpFMul"; 1006 case 134: return "OpUDiv"; 1007 case 135: return "OpSDiv"; 1008 case 136: return "OpFDiv"; 1009 case 137: return "OpUMod"; 1010 case 138: return "OpSRem"; 1011 case 139: return "OpSMod"; 1012 case 140: return "OpFRem"; 1013 case 141: return "OpFMod"; 1014 case 142: return "OpVectorTimesScalar"; 1015 case 143: return "OpMatrixTimesScalar"; 1016 case 144: return "OpVectorTimesMatrix"; 1017 case 145: return "OpMatrixTimesVector"; 1018 case 146: return "OpMatrixTimesMatrix"; 1019 case 147: return "OpOuterProduct"; 1020 case 148: return "OpDot"; 1021 case 149: return "OpIAddCarry"; 1022 case 150: return "OpISubBorrow"; 1023 case 151: return "OpUMulExtended"; 1024 case 152: return "OpSMulExtended"; 1025 case 153: return "Bad"; 1026 case 154: return "OpAny"; 1027 case 155: return "OpAll"; 1028 case 156: return "OpIsNan"; 1029 case 157: return "OpIsInf"; 1030 case 158: return "OpIsFinite"; 1031 case 159: return "OpIsNormal"; 1032 case 160: return "OpSignBitSet"; 1033 case 161: return "OpLessOrGreater"; 1034 case 162: return "OpOrdered"; 1035 case 163: return "OpUnordered"; 1036 case 164: return "OpLogicalEqual"; 1037 case 165: return "OpLogicalNotEqual"; 1038 case 166: return "OpLogicalOr"; 1039 case 167: return "OpLogicalAnd"; 1040 case 168: return "OpLogicalNot"; 1041 case 169: return "OpSelect"; 1042 case 170: return "OpIEqual"; 1043 case 171: return "OpINotEqual"; 1044 case 172: return "OpUGreaterThan"; 1045 case 173: return "OpSGreaterThan"; 1046 case 174: return "OpUGreaterThanEqual"; 1047 case 175: return "OpSGreaterThanEqual"; 1048 case 176: return "OpULessThan"; 1049 case 177: return "OpSLessThan"; 1050 case 178: return "OpULessThanEqual"; 1051 case 179: return "OpSLessThanEqual"; 1052 case 180: return "OpFOrdEqual"; 1053 case 181: return "OpFUnordEqual"; 1054 case 182: return "OpFOrdNotEqual"; 1055 case 183: return "OpFUnordNotEqual"; 1056 case 184: return "OpFOrdLessThan"; 1057 case 185: return "OpFUnordLessThan"; 1058 case 186: return "OpFOrdGreaterThan"; 1059 case 187: return "OpFUnordGreaterThan"; 1060 case 188: return "OpFOrdLessThanEqual"; 1061 case 189: return "OpFUnordLessThanEqual"; 1062 case 190: return "OpFOrdGreaterThanEqual"; 1063 case 191: return "OpFUnordGreaterThanEqual"; 1064 case 192: return "Bad"; 1065 case 193: return "Bad"; 1066 case 194: return "OpShiftRightLogical"; 1067 case 195: return "OpShiftRightArithmetic"; 1068 case 196: return "OpShiftLeftLogical"; 1069 case 197: return "OpBitwiseOr"; 1070 case 198: return "OpBitwiseXor"; 1071 case 199: return "OpBitwiseAnd"; 1072 case 200: return "OpNot"; 1073 case 201: return "OpBitFieldInsert"; 1074 case 202: return "OpBitFieldSExtract"; 1075 case 203: return "OpBitFieldUExtract"; 1076 case 204: return "OpBitReverse"; 1077 case 205: return "OpBitCount"; 1078 case 206: return "Bad"; 1079 case 207: return "OpDPdx"; 1080 case 208: return "OpDPdy"; 1081 case 209: return "OpFwidth"; 1082 case 210: return "OpDPdxFine"; 1083 case 211: return "OpDPdyFine"; 1084 case 212: return "OpFwidthFine"; 1085 case 213: return "OpDPdxCoarse"; 1086 case 214: return "OpDPdyCoarse"; 1087 case 215: return "OpFwidthCoarse"; 1088 case 216: return "Bad"; 1089 case 217: return "Bad"; 1090 case 218: return "OpEmitVertex"; 1091 case 219: return "OpEndPrimitive"; 1092 case 220: return "OpEmitStreamVertex"; 1093 case 221: return "OpEndStreamPrimitive"; 1094 case 222: return "Bad"; 1095 case 223: return "Bad"; 1096 case 224: return "OpControlBarrier"; 1097 case 225: return "OpMemoryBarrier"; 1098 case 226: return "Bad"; 1099 case 227: return "OpAtomicLoad"; 1100 case 228: return "OpAtomicStore"; 1101 case 229: return "OpAtomicExchange"; 1102 case 230: return "OpAtomicCompareExchange"; 1103 case 231: return "OpAtomicCompareExchangeWeak"; 1104 case 232: return "OpAtomicIIncrement"; 1105 case 233: return "OpAtomicIDecrement"; 1106 case 234: return "OpAtomicIAdd"; 1107 case 235: return "OpAtomicISub"; 1108 case 236: return "OpAtomicSMin"; 1109 case 237: return "OpAtomicUMin"; 1110 case 238: return "OpAtomicSMax"; 1111 case 239: return "OpAtomicUMax"; 1112 case 240: return "OpAtomicAnd"; 1113 case 241: return "OpAtomicOr"; 1114 case 242: return "OpAtomicXor"; 1115 case 243: return "Bad"; 1116 case 244: return "Bad"; 1117 case 245: return "OpPhi"; 1118 case 246: return "OpLoopMerge"; 1119 case 247: return "OpSelectionMerge"; 1120 case 248: return "OpLabel"; 1121 case 249: return "OpBranch"; 1122 case 250: return "OpBranchConditional"; 1123 case 251: return "OpSwitch"; 1124 case 252: return "OpKill"; 1125 case 253: return "OpReturn"; 1126 case 254: return "OpReturnValue"; 1127 case 255: return "OpUnreachable"; 1128 case 256: return "OpLifetimeStart"; 1129 case 257: return "OpLifetimeStop"; 1130 case 258: return "Bad"; 1131 case 259: return "OpGroupAsyncCopy"; 1132 case 260: return "OpGroupWaitEvents"; 1133 case 261: return "OpGroupAll"; 1134 case 262: return "OpGroupAny"; 1135 case 263: return "OpGroupBroadcast"; 1136 case 264: return "OpGroupIAdd"; 1137 case 265: return "OpGroupFAdd"; 1138 case 266: return "OpGroupFMin"; 1139 case 267: return "OpGroupUMin"; 1140 case 268: return "OpGroupSMin"; 1141 case 269: return "OpGroupFMax"; 1142 case 270: return "OpGroupUMax"; 1143 case 271: return "OpGroupSMax"; 1144 case 272: return "Bad"; 1145 case 273: return "Bad"; 1146 case 274: return "OpReadPipe"; 1147 case 275: return "OpWritePipe"; 1148 case 276: return "OpReservedReadPipe"; 1149 case 277: return "OpReservedWritePipe"; 1150 case 278: return "OpReserveReadPipePackets"; 1151 case 279: return "OpReserveWritePipePackets"; 1152 case 280: return "OpCommitReadPipe"; 1153 case 281: return "OpCommitWritePipe"; 1154 case 282: return "OpIsValidReserveId"; 1155 case 283: return "OpGetNumPipePackets"; 1156 case 284: return "OpGetMaxPipePackets"; 1157 case 285: return "OpGroupReserveReadPipePackets"; 1158 case 286: return "OpGroupReserveWritePipePackets"; 1159 case 287: return "OpGroupCommitReadPipe"; 1160 case 288: return "OpGroupCommitWritePipe"; 1161 case 289: return "Bad"; 1162 case 290: return "Bad"; 1163 case 291: return "OpEnqueueMarker"; 1164 case 292: return "OpEnqueueKernel"; 1165 case 293: return "OpGetKernelNDrangeSubGroupCount"; 1166 case 294: return "OpGetKernelNDrangeMaxSubGroupSize"; 1167 case 295: return "OpGetKernelWorkGroupSize"; 1168 case 296: return "OpGetKernelPreferredWorkGroupSizeMultiple"; 1169 case 297: return "OpRetainEvent"; 1170 case 298: return "OpReleaseEvent"; 1171 case 299: return "OpCreateUserEvent"; 1172 case 300: return "OpIsValidEvent"; 1173 case 301: return "OpSetUserEventStatus"; 1174 case 302: return "OpCaptureEventProfilingInfo"; 1175 case 303: return "OpGetDefaultQueue"; 1176 case 304: return "OpBuildNDRange"; 1177 case 305: return "OpImageSparseSampleImplicitLod"; 1178 case 306: return "OpImageSparseSampleExplicitLod"; 1179 case 307: return "OpImageSparseSampleDrefImplicitLod"; 1180 case 308: return "OpImageSparseSampleDrefExplicitLod"; 1181 case 309: return "OpImageSparseSampleProjImplicitLod"; 1182 case 310: return "OpImageSparseSampleProjExplicitLod"; 1183 case 311: return "OpImageSparseSampleProjDrefImplicitLod"; 1184 case 312: return "OpImageSparseSampleProjDrefExplicitLod"; 1185 case 313: return "OpImageSparseFetch"; 1186 case 314: return "OpImageSparseGather"; 1187 case 315: return "OpImageSparseDrefGather"; 1188 case 316: return "OpImageSparseTexelsResident"; 1189 case 317: return "OpNoLine"; 1190 case 318: return "OpAtomicFlagTestAndSet"; 1191 case 319: return "OpAtomicFlagClear"; 1192 case 320: return "OpImageSparseRead"; 1193 1194 case 4421: return "OpSubgroupBallotKHR"; 1195 case 4422: return "OpSubgroupFirstInvocationKHR"; 1196 case 4428: return "OpSubgroupAllKHR"; 1197 case 4429: return "OpSubgroupAnyKHR"; 1198 case 4430: return "OpSubgroupAllEqualKHR"; 1199 case 4432: return "OpSubgroupReadInvocationKHR"; 1200 1201 #ifdef AMD_EXTENSIONS 1202 case 5000: return "OpGroupIAddNonUniformAMD"; 1203 case 5001: return "OpGroupFAddNonUniformAMD"; 1204 case 5002: return "OpGroupFMinNonUniformAMD"; 1205 case 5003: return "OpGroupUMinNonUniformAMD"; 1206 case 5004: return "OpGroupSMinNonUniformAMD"; 1207 case 5005: return "OpGroupFMaxNonUniformAMD"; 1208 case 5006: return "OpGroupUMaxNonUniformAMD"; 1209 case 5007: return "OpGroupSMaxNonUniformAMD"; 1210 #endif 1211 1212 case OpcodeCeiling: 1213 default: 1214 return "Bad"; 1215 } 1216 } 1217 1218 // The set of objects that hold all the instruction/operand 1219 // parameterization information. 1220 InstructionParameters InstructionDesc[OpCodeMask + 1]; 1221 OperandParameters ExecutionModeOperands[ExecutionModeCeiling]; 1222 OperandParameters DecorationOperands[DecorationCeiling]; 1223 1224 EnumDefinition OperandClassParams[OperandCount]; 1225 EnumParameters ExecutionModelParams[ExecutionModelCeiling]; 1226 EnumParameters AddressingParams[AddressingModelCeiling]; 1227 EnumParameters MemoryParams[MemoryModelCeiling]; 1228 EnumParameters ExecutionModeParams[ExecutionModeCeiling]; 1229 EnumParameters StorageParams[StorageClassCeiling]; 1230 EnumParameters SamplerAddressingModeParams[SamplerAddressingModeCeiling]; 1231 EnumParameters SamplerFilterModeParams[SamplerFilterModeCeiling]; 1232 EnumParameters ImageFormatParams[ImageFormatCeiling]; 1233 EnumParameters ImageChannelOrderParams[ImageChannelOrderCeiling]; 1234 EnumParameters ImageChannelDataTypeParams[ImageChannelDataTypeCeiling]; 1235 EnumParameters ImageOperandsParams[ImageOperandsCeiling]; 1236 EnumParameters FPFastMathParams[FPFastMathCeiling]; 1237 EnumParameters FPRoundingModeParams[FPRoundingModeCeiling]; 1238 EnumParameters LinkageTypeParams[LinkageTypeCeiling]; 1239 EnumParameters DecorationParams[DecorationCeiling]; 1240 EnumParameters BuiltInParams[BuiltInCeiling]; 1241 EnumParameters DimensionalityParams[DimensionCeiling]; 1242 EnumParameters FuncParamAttrParams[FuncParamAttrCeiling]; 1243 EnumParameters AccessQualifierParams[AccessQualifierCeiling]; 1244 EnumParameters GroupOperationParams[GroupOperationCeiling]; 1245 EnumParameters LoopControlParams[FunctionControlCeiling]; 1246 EnumParameters SelectionControlParams[SelectControlCeiling]; 1247 EnumParameters FunctionControlParams[FunctionControlCeiling]; 1248 EnumParameters MemorySemanticsParams[MemorySemanticsCeiling]; 1249 EnumParameters MemoryAccessParams[MemoryAccessCeiling]; 1250 EnumParameters ScopeParams[ScopeCeiling]; 1251 EnumParameters KernelEnqueueFlagsParams[KernelEnqueueFlagsCeiling]; 1252 EnumParameters KernelProfilingInfoParams[KernelProfilingInfoCeiling]; 1253 EnumParameters CapabilityParams[CapabilityCeiling]; 1254 1255 // Set up all the parameterizing descriptions of the opcodes, operands, etc. 1256 void Parameterize() 1257 { 1258 // only do this once. 1259 static bool initialized = false; 1260 if (initialized) 1261 return; 1262 initialized = true; 1263 1264 // Exceptions to having a result <id> and a resulting type <id>. 1265 // (Everything is initialized to have both). 1266 1267 InstructionDesc[OpNop].setResultAndType(false, false); 1268 InstructionDesc[OpSource].setResultAndType(false, false); 1269 InstructionDesc[OpSourceContinued].setResultAndType(false, false); 1270 InstructionDesc[OpSourceExtension].setResultAndType(false, false); 1271 InstructionDesc[OpExtension].setResultAndType(false, false); 1272 InstructionDesc[OpExtInstImport].setResultAndType(true, false); 1273 InstructionDesc[OpCapability].setResultAndType(false, false); 1274 InstructionDesc[OpMemoryModel].setResultAndType(false, false); 1275 InstructionDesc[OpEntryPoint].setResultAndType(false, false); 1276 InstructionDesc[OpExecutionMode].setResultAndType(false, false); 1277 InstructionDesc[OpTypeVoid].setResultAndType(true, false); 1278 InstructionDesc[OpTypeBool].setResultAndType(true, false); 1279 InstructionDesc[OpTypeInt].setResultAndType(true, false); 1280 InstructionDesc[OpTypeFloat].setResultAndType(true, false); 1281 InstructionDesc[OpTypeVector].setResultAndType(true, false); 1282 InstructionDesc[OpTypeMatrix].setResultAndType(true, false); 1283 InstructionDesc[OpTypeImage].setResultAndType(true, false); 1284 InstructionDesc[OpTypeSampler].setResultAndType(true, false); 1285 InstructionDesc[OpTypeSampledImage].setResultAndType(true, false); 1286 InstructionDesc[OpTypeArray].setResultAndType(true, false); 1287 InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false); 1288 InstructionDesc[OpTypeStruct].setResultAndType(true, false); 1289 InstructionDesc[OpTypeOpaque].setResultAndType(true, false); 1290 InstructionDesc[OpTypePointer].setResultAndType(true, false); 1291 InstructionDesc[OpTypeForwardPointer].setResultAndType(false, false); 1292 InstructionDesc[OpTypeFunction].setResultAndType(true, false); 1293 InstructionDesc[OpTypeEvent].setResultAndType(true, false); 1294 InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false); 1295 InstructionDesc[OpTypeReserveId].setResultAndType(true, false); 1296 InstructionDesc[OpTypeQueue].setResultAndType(true, false); 1297 InstructionDesc[OpTypePipe].setResultAndType(true, false); 1298 InstructionDesc[OpFunctionEnd].setResultAndType(false, false); 1299 InstructionDesc[OpStore].setResultAndType(false, false); 1300 InstructionDesc[OpImageWrite].setResultAndType(false, false); 1301 InstructionDesc[OpDecorationGroup].setResultAndType(true, false); 1302 InstructionDesc[OpDecorate].setResultAndType(false, false); 1303 InstructionDesc[OpMemberDecorate].setResultAndType(false, false); 1304 InstructionDesc[OpGroupDecorate].setResultAndType(false, false); 1305 InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false); 1306 InstructionDesc[OpName].setResultAndType(false, false); 1307 InstructionDesc[OpMemberName].setResultAndType(false, false); 1308 InstructionDesc[OpString].setResultAndType(true, false); 1309 InstructionDesc[OpLine].setResultAndType(false, false); 1310 InstructionDesc[OpNoLine].setResultAndType(false, false); 1311 InstructionDesc[OpCopyMemory].setResultAndType(false, false); 1312 InstructionDesc[OpCopyMemorySized].setResultAndType(false, false); 1313 InstructionDesc[OpEmitVertex].setResultAndType(false, false); 1314 InstructionDesc[OpEndPrimitive].setResultAndType(false, false); 1315 InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false); 1316 InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false); 1317 InstructionDesc[OpControlBarrier].setResultAndType(false, false); 1318 InstructionDesc[OpMemoryBarrier].setResultAndType(false, false); 1319 InstructionDesc[OpAtomicStore].setResultAndType(false, false); 1320 InstructionDesc[OpLoopMerge].setResultAndType(false, false); 1321 InstructionDesc[OpSelectionMerge].setResultAndType(false, false); 1322 InstructionDesc[OpLabel].setResultAndType(true, false); 1323 InstructionDesc[OpBranch].setResultAndType(false, false); 1324 InstructionDesc[OpBranchConditional].setResultAndType(false, false); 1325 InstructionDesc[OpSwitch].setResultAndType(false, false); 1326 InstructionDesc[OpKill].setResultAndType(false, false); 1327 InstructionDesc[OpReturn].setResultAndType(false, false); 1328 InstructionDesc[OpReturnValue].setResultAndType(false, false); 1329 InstructionDesc[OpUnreachable].setResultAndType(false, false); 1330 InstructionDesc[OpLifetimeStart].setResultAndType(false, false); 1331 InstructionDesc[OpLifetimeStop].setResultAndType(false, false); 1332 InstructionDesc[OpCommitReadPipe].setResultAndType(false, false); 1333 InstructionDesc[OpCommitWritePipe].setResultAndType(false, false); 1334 InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false); 1335 InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false); 1336 InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false); 1337 InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false); 1338 InstructionDesc[OpRetainEvent].setResultAndType(false, false); 1339 InstructionDesc[OpReleaseEvent].setResultAndType(false, false); 1340 InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false); 1341 InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false); 1342 1343 // Specific additional context-dependent operands 1344 1345 ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'"); 1346 1347 ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'"); 1348 ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'"); 1349 ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'"); 1350 1351 ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'"); 1352 ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'"); 1353 ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'"); 1354 1355 ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'"); 1356 ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'"); 1357 1358 DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'"); 1359 DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'"); 1360 DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'"); 1361 DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'"); 1362 DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'"); 1363 DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'"); 1364 DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'"); 1365 DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'"); 1366 DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'"); 1367 DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'"); 1368 DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'"); 1369 DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>"); 1370 DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'"); 1371 DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'"); 1372 DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'"); 1373 DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'"); 1374 DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'"); 1375 DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'"); 1376 DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'"); 1377 DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'"); 1378 1379 OperandClassParams[OperandSource].set(SourceLanguageCeiling, SourceString, 0); 1380 OperandClassParams[OperandExecutionModel].set(ExecutionModelCeiling, ExecutionModelString, ExecutionModelParams); 1381 OperandClassParams[OperandAddressing].set(AddressingModelCeiling, AddressingString, AddressingParams); 1382 OperandClassParams[OperandMemory].set(MemoryModelCeiling, MemoryString, MemoryParams); 1383 OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams); 1384 OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands); 1385 OperandClassParams[OperandStorage].set(StorageClassCeiling, StorageClassString, StorageParams); 1386 OperandClassParams[OperandDimensionality].set(DimensionCeiling, DimensionString, DimensionalityParams); 1387 OperandClassParams[OperandSamplerAddressingMode].set(SamplerAddressingModeCeiling, SamplerAddressingModeString, SamplerAddressingModeParams); 1388 OperandClassParams[OperandSamplerFilterMode].set(SamplerFilterModeCeiling, SamplerFilterModeString, SamplerFilterModeParams); 1389 OperandClassParams[OperandSamplerImageFormat].set(ImageFormatCeiling, ImageFormatString, ImageFormatParams); 1390 OperandClassParams[OperandImageChannelOrder].set(ImageChannelOrderCeiling, ImageChannelOrderString, ImageChannelOrderParams); 1391 OperandClassParams[OperandImageChannelDataType].set(ImageChannelDataTypeCeiling, ImageChannelDataTypeString, ImageChannelDataTypeParams); 1392 OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true); 1393 OperandClassParams[OperandFPFastMath].set(FPFastMathCeiling, FPFastMathString, FPFastMathParams, true); 1394 OperandClassParams[OperandFPRoundingMode].set(FPRoundingModeCeiling, FPRoundingModeString, FPRoundingModeParams); 1395 OperandClassParams[OperandLinkageType].set(LinkageTypeCeiling, LinkageTypeString, LinkageTypeParams); 1396 OperandClassParams[OperandFuncParamAttr].set(FuncParamAttrCeiling, FuncParamAttrString, FuncParamAttrParams); 1397 OperandClassParams[OperandAccessQualifier].set(AccessQualifierCeiling, AccessQualifierString, AccessQualifierParams); 1398 OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams); 1399 OperandClassParams[OperandDecoration].setOperands(DecorationOperands); 1400 OperandClassParams[OperandBuiltIn].set(BuiltInCeiling, BuiltInString, BuiltInParams); 1401 OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true); 1402 OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true); 1403 OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true); 1404 OperandClassParams[OperandMemorySemantics].set(MemorySemanticsCeiling, MemorySemanticsString, MemorySemanticsParams, true); 1405 OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true); 1406 OperandClassParams[OperandScope].set(ScopeCeiling, ScopeString, ScopeParams); 1407 OperandClassParams[OperandGroupOperation].set(GroupOperationCeiling, GroupOperationString, GroupOperationParams); 1408 OperandClassParams[OperandKernelEnqueueFlags].set(KernelEnqueueFlagsCeiling, KernelEnqueueFlagsString, KernelEnqueueFlagsParams); 1409 OperandClassParams[OperandKernelProfilingInfo].set(KernelProfilingInfoCeiling, KernelProfilingInfoString, KernelProfilingInfoParams, true); 1410 OperandClassParams[OperandCapability].set(CapabilityCeiling, CapabilityString, CapabilityParams); 1411 OperandClassParams[OperandOpcode].set(OpcodeCeiling, OpcodeString, 0); 1412 1413 CapabilityParams[CapabilityShader].caps.push_back(CapabilityMatrix); 1414 CapabilityParams[CapabilityGeometry].caps.push_back(CapabilityShader); 1415 CapabilityParams[CapabilityTessellation].caps.push_back(CapabilityShader); 1416 CapabilityParams[CapabilityVector16].caps.push_back(CapabilityKernel); 1417 CapabilityParams[CapabilityFloat16Buffer].caps.push_back(CapabilityKernel); 1418 CapabilityParams[CapabilityInt64Atomics].caps.push_back(CapabilityInt64); 1419 CapabilityParams[CapabilityImageBasic].caps.push_back(CapabilityKernel); 1420 CapabilityParams[CapabilityImageReadWrite].caps.push_back(CapabilityImageBasic); 1421 CapabilityParams[CapabilityImageMipmap].caps.push_back(CapabilityImageBasic); 1422 CapabilityParams[CapabilityPipes].caps.push_back(CapabilityKernel); 1423 CapabilityParams[CapabilityDeviceEnqueue].caps.push_back(CapabilityKernel); 1424 CapabilityParams[CapabilityLiteralSampler].caps.push_back(CapabilityKernel); 1425 CapabilityParams[CapabilityAtomicStorage].caps.push_back(CapabilityShader); 1426 CapabilityParams[CapabilitySampleRateShading].caps.push_back(CapabilityShader); 1427 CapabilityParams[CapabilityTessellationPointSize].caps.push_back(CapabilityTessellation); 1428 CapabilityParams[CapabilityGeometryPointSize].caps.push_back(CapabilityGeometry); 1429 CapabilityParams[CapabilityImageGatherExtended].caps.push_back(CapabilityShader); 1430 CapabilityParams[CapabilityStorageImageExtendedFormats].caps.push_back(CapabilityShader); 1431 CapabilityParams[CapabilityStorageImageMultisample].caps.push_back(CapabilityShader); 1432 CapabilityParams[CapabilityUniformBufferArrayDynamicIndexing].caps.push_back(CapabilityShader); 1433 CapabilityParams[CapabilitySampledImageArrayDynamicIndexing].caps.push_back(CapabilityShader); 1434 CapabilityParams[CapabilityStorageBufferArrayDynamicIndexing].caps.push_back(CapabilityShader); 1435 CapabilityParams[CapabilityStorageImageArrayDynamicIndexing].caps.push_back(CapabilityShader); 1436 CapabilityParams[CapabilityClipDistance].caps.push_back(CapabilityShader); 1437 CapabilityParams[CapabilityCullDistance].caps.push_back(CapabilityShader); 1438 CapabilityParams[CapabilityGenericPointer].caps.push_back(CapabilityAddresses); 1439 CapabilityParams[CapabilityInt8].caps.push_back(CapabilityKernel); 1440 CapabilityParams[CapabilityInputAttachment].caps.push_back(CapabilityShader); 1441 CapabilityParams[CapabilityMinLod].caps.push_back(CapabilityShader); 1442 CapabilityParams[CapabilitySparseResidency].caps.push_back(CapabilityShader); 1443 CapabilityParams[CapabilitySampled1D].caps.push_back(CapabilityShader); 1444 CapabilityParams[CapabilitySampledRect].caps.push_back(CapabilityShader); 1445 CapabilityParams[CapabilitySampledBuffer].caps.push_back(CapabilityShader); 1446 CapabilityParams[CapabilitySampledCubeArray].caps.push_back(CapabilityShader); 1447 CapabilityParams[CapabilityImageMSArray].caps.push_back(CapabilityShader); 1448 CapabilityParams[CapabilityImage1D].caps.push_back(CapabilitySampled1D); 1449 CapabilityParams[CapabilityImageRect].caps.push_back(CapabilitySampledRect); 1450 CapabilityParams[CapabilityImageBuffer].caps.push_back(CapabilitySampledBuffer); 1451 CapabilityParams[CapabilityImageCubeArray].caps.push_back(CapabilitySampledCubeArray); 1452 CapabilityParams[CapabilityImageQuery].caps.push_back(CapabilityShader); 1453 CapabilityParams[CapabilityDerivativeControl].caps.push_back(CapabilityShader); 1454 CapabilityParams[CapabilityInterpolationFunction].caps.push_back(CapabilityShader); 1455 CapabilityParams[CapabilityTransformFeedback].caps.push_back(CapabilityShader); 1456 CapabilityParams[CapabilityGeometryStreams].caps.push_back(CapabilityGeometry); 1457 CapabilityParams[CapabilityStorageImageReadWithoutFormat].caps.push_back(CapabilityShader); 1458 CapabilityParams[CapabilityStorageImageWriteWithoutFormat].caps.push_back(CapabilityShader); 1459 CapabilityParams[CapabilityMultiViewport].caps.push_back(CapabilityGeometry); 1460 1461 AddressingParams[AddressingModelPhysical32].caps.push_back(CapabilityAddresses); 1462 AddressingParams[AddressingModelPhysical64].caps.push_back(CapabilityAddresses); 1463 1464 MemoryParams[MemoryModelSimple].caps.push_back(CapabilityShader); 1465 MemoryParams[MemoryModelGLSL450].caps.push_back(CapabilityShader); 1466 MemoryParams[MemoryModelOpenCL].caps.push_back(CapabilityKernel); 1467 1468 MemorySemanticsParams[MemorySemanticsUniformMemoryShift].caps.push_back(CapabilityShader); 1469 MemorySemanticsParams[MemorySemanticsAtomicCounterMemoryShift].caps.push_back(CapabilityAtomicStorage); 1470 1471 ExecutionModelParams[ExecutionModelVertex].caps.push_back(CapabilityShader); 1472 ExecutionModelParams[ExecutionModelTessellationControl].caps.push_back(CapabilityTessellation); 1473 ExecutionModelParams[ExecutionModelTessellationEvaluation].caps.push_back(CapabilityTessellation); 1474 ExecutionModelParams[ExecutionModelGeometry].caps.push_back(CapabilityGeometry); 1475 ExecutionModelParams[ExecutionModelFragment].caps.push_back(CapabilityShader); 1476 ExecutionModelParams[ExecutionModelGLCompute].caps.push_back(CapabilityShader); 1477 ExecutionModelParams[ExecutionModelKernel].caps.push_back(CapabilityKernel); 1478 1479 // Storage capabilites 1480 StorageParams[StorageClassInput].caps.push_back(CapabilityShader); 1481 StorageParams[StorageClassUniform].caps.push_back(CapabilityShader); 1482 StorageParams[StorageClassOutput].caps.push_back(CapabilityShader); 1483 StorageParams[StorageClassPrivate].caps.push_back(CapabilityShader); 1484 StorageParams[StorageClassGeneric].caps.push_back(CapabilityKernel); 1485 StorageParams[StorageClassAtomicCounter].caps.push_back(CapabilityAtomicStorage); 1486 StorageParams[StorageClassPushConstant].caps.push_back(CapabilityShader); 1487 1488 // Sampler Filter & Addressing mode capabilities 1489 SamplerAddressingModeParams[SamplerAddressingModeNone].caps.push_back(CapabilityKernel); 1490 SamplerAddressingModeParams[SamplerAddressingModeClampToEdge].caps.push_back(CapabilityKernel); 1491 SamplerAddressingModeParams[SamplerAddressingModeClamp].caps.push_back(CapabilityKernel); 1492 SamplerAddressingModeParams[SamplerAddressingModeRepeat].caps.push_back(CapabilityKernel); 1493 SamplerAddressingModeParams[SamplerAddressingModeRepeatMirrored].caps.push_back(CapabilityKernel); 1494 1495 SamplerFilterModeParams[SamplerFilterModeNearest].caps.push_back(CapabilityKernel); 1496 SamplerFilterModeParams[SamplerFilterModeLinear].caps.push_back(CapabilityKernel); 1497 1498 // image format capabilities 1499 1500 // ES/Desktop float 1501 ImageFormatParams[ImageFormatRgba32f].caps.push_back(CapabilityShader); 1502 ImageFormatParams[ImageFormatRgba16f].caps.push_back(CapabilityShader); 1503 ImageFormatParams[ImageFormatR32f].caps.push_back(CapabilityShader); 1504 ImageFormatParams[ImageFormatRgba8].caps.push_back(CapabilityShader); 1505 ImageFormatParams[ImageFormatRgba8Snorm].caps.push_back(CapabilityShader); 1506 1507 // Desktop float 1508 ImageFormatParams[ImageFormatRg32f].caps.push_back(CapabilityStorageImageExtendedFormats); 1509 ImageFormatParams[ImageFormatRg16f].caps.push_back(CapabilityStorageImageExtendedFormats); 1510 ImageFormatParams[ImageFormatR11fG11fB10f].caps.push_back(CapabilityStorageImageExtendedFormats); 1511 ImageFormatParams[ImageFormatR16f].caps.push_back(CapabilityStorageImageExtendedFormats); 1512 ImageFormatParams[ImageFormatRgba16].caps.push_back(CapabilityStorageImageExtendedFormats); 1513 ImageFormatParams[ImageFormatRgb10A2].caps.push_back(CapabilityStorageImageExtendedFormats); 1514 ImageFormatParams[ImageFormatRg16].caps.push_back(CapabilityStorageImageExtendedFormats); 1515 ImageFormatParams[ImageFormatRg8].caps.push_back(CapabilityStorageImageExtendedFormats); 1516 ImageFormatParams[ImageFormatR16].caps.push_back(CapabilityStorageImageExtendedFormats); 1517 ImageFormatParams[ImageFormatR8].caps.push_back(CapabilityStorageImageExtendedFormats); 1518 ImageFormatParams[ImageFormatRgba16Snorm].caps.push_back(CapabilityStorageImageExtendedFormats); 1519 ImageFormatParams[ImageFormatRg16Snorm].caps.push_back(CapabilityStorageImageExtendedFormats); 1520 ImageFormatParams[ImageFormatRg8Snorm].caps.push_back(CapabilityStorageImageExtendedFormats); 1521 ImageFormatParams[ImageFormatR16Snorm].caps.push_back(CapabilityStorageImageExtendedFormats); 1522 ImageFormatParams[ImageFormatR8Snorm].caps.push_back(CapabilityStorageImageExtendedFormats); 1523 1524 // ES/Desktop int 1525 ImageFormatParams[ImageFormatRgba32i].caps.push_back(CapabilityShader); 1526 ImageFormatParams[ImageFormatRgba16i].caps.push_back(CapabilityShader); 1527 ImageFormatParams[ImageFormatRgba8i].caps.push_back(CapabilityShader); 1528 ImageFormatParams[ImageFormatR32i].caps.push_back(CapabilityShader); 1529 1530 // Desktop int 1531 ImageFormatParams[ImageFormatRg32i].caps.push_back(CapabilityStorageImageExtendedFormats); 1532 ImageFormatParams[ImageFormatRg16i].caps.push_back(CapabilityStorageImageExtendedFormats); 1533 ImageFormatParams[ImageFormatRg8i].caps.push_back(CapabilityStorageImageExtendedFormats); 1534 ImageFormatParams[ImageFormatR16i].caps.push_back(CapabilityStorageImageExtendedFormats); 1535 ImageFormatParams[ImageFormatR8i].caps.push_back(CapabilityStorageImageExtendedFormats); 1536 1537 // ES/Desktop uint 1538 ImageFormatParams[ImageFormatRgba32ui].caps.push_back(CapabilityShader); 1539 ImageFormatParams[ImageFormatRgba16ui].caps.push_back(CapabilityShader); 1540 ImageFormatParams[ImageFormatRgba8ui].caps.push_back(CapabilityShader); 1541 ImageFormatParams[ImageFormatR32ui].caps.push_back(CapabilityShader); 1542 1543 // Desktop uint 1544 ImageFormatParams[ImageFormatRgb10a2ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1545 ImageFormatParams[ImageFormatRg32ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1546 ImageFormatParams[ImageFormatRg16ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1547 ImageFormatParams[ImageFormatRg8ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1548 ImageFormatParams[ImageFormatR16ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1549 ImageFormatParams[ImageFormatR8ui].caps.push_back(CapabilityStorageImageExtendedFormats); 1550 1551 // image channel order capabilities 1552 for (int i = 0; i < ImageChannelOrderCeiling; ++i) { 1553 ImageChannelOrderParams[i].caps.push_back(CapabilityKernel); 1554 } 1555 1556 // image channel type capabilities 1557 for (int i = 0; i < ImageChannelDataTypeCeiling; ++i) { 1558 ImageChannelDataTypeParams[i].caps.push_back(CapabilityKernel); 1559 } 1560 1561 // image lookup operands 1562 ImageOperandsParams[ImageOperandsBiasShift].caps.push_back(CapabilityShader); 1563 ImageOperandsParams[ImageOperandsOffsetShift].caps.push_back(CapabilityImageGatherExtended); 1564 ImageOperandsParams[ImageOperandsMinLodShift].caps.push_back(CapabilityMinLod); 1565 1566 // fast math flags capabilities 1567 for (int i = 0; i < FPFastMathCeiling; ++i) { 1568 FPFastMathParams[i].caps.push_back(CapabilityKernel); 1569 } 1570 1571 // fp rounding mode capabilities 1572 for (int i = 0; i < FPRoundingModeCeiling; ++i) { 1573 FPRoundingModeParams[i].caps.push_back(CapabilityKernel); 1574 } 1575 1576 // linkage types 1577 for (int i = 0; i < LinkageTypeCeiling; ++i) { 1578 LinkageTypeParams[i].caps.push_back(CapabilityLinkage); 1579 } 1580 1581 // function argument types 1582 for (int i = 0; i < FuncParamAttrCeiling; ++i) { 1583 FuncParamAttrParams[i].caps.push_back(CapabilityKernel); 1584 } 1585 1586 // function argument types 1587 for (int i = 0; i < AccessQualifierCeiling; ++i) { 1588 AccessQualifierParams[i].caps.push_back(CapabilityKernel); 1589 } 1590 1591 ExecutionModeParams[ExecutionModeInvocations].caps.push_back(CapabilityGeometry); 1592 ExecutionModeParams[ExecutionModeSpacingEqual].caps.push_back(CapabilityTessellation); 1593 ExecutionModeParams[ExecutionModeSpacingFractionalEven].caps.push_back(CapabilityTessellation); 1594 ExecutionModeParams[ExecutionModeSpacingFractionalOdd].caps.push_back(CapabilityTessellation); 1595 ExecutionModeParams[ExecutionModeVertexOrderCw].caps.push_back(CapabilityTessellation); 1596 ExecutionModeParams[ExecutionModeVertexOrderCcw].caps.push_back(CapabilityTessellation); 1597 ExecutionModeParams[ExecutionModePixelCenterInteger].caps.push_back(CapabilityShader); 1598 ExecutionModeParams[ExecutionModeOriginUpperLeft].caps.push_back(CapabilityShader); 1599 ExecutionModeParams[ExecutionModeOriginLowerLeft].caps.push_back(CapabilityShader); 1600 ExecutionModeParams[ExecutionModeEarlyFragmentTests].caps.push_back(CapabilityShader); 1601 ExecutionModeParams[ExecutionModePointMode].caps.push_back(CapabilityTessellation); 1602 ExecutionModeParams[ExecutionModeXfb].caps.push_back(CapabilityTransformFeedback); 1603 ExecutionModeParams[ExecutionModeDepthReplacing].caps.push_back(CapabilityShader); 1604 ExecutionModeParams[ExecutionModeDepthGreater].caps.push_back(CapabilityShader); 1605 ExecutionModeParams[ExecutionModeDepthLess].caps.push_back(CapabilityShader); 1606 ExecutionModeParams[ExecutionModeDepthUnchanged].caps.push_back(CapabilityShader); 1607 ExecutionModeParams[ExecutionModeLocalSizeHint].caps.push_back(CapabilityKernel); 1608 ExecutionModeParams[ExecutionModeInputPoints].caps.push_back(CapabilityGeometry); 1609 ExecutionModeParams[ExecutionModeInputLines].caps.push_back(CapabilityGeometry); 1610 ExecutionModeParams[ExecutionModeInputLinesAdjacency].caps.push_back(CapabilityGeometry); 1611 ExecutionModeParams[ExecutionModeTriangles].caps.push_back(CapabilityGeometry); 1612 ExecutionModeParams[ExecutionModeTriangles].caps.push_back(CapabilityTessellation); 1613 ExecutionModeParams[ExecutionModeInputTrianglesAdjacency].caps.push_back(CapabilityGeometry); 1614 ExecutionModeParams[ExecutionModeQuads].caps.push_back(CapabilityTessellation); 1615 ExecutionModeParams[ExecutionModeIsolines].caps.push_back(CapabilityTessellation); 1616 ExecutionModeParams[ExecutionModeOutputVertices].caps.push_back(CapabilityGeometry); 1617 ExecutionModeParams[ExecutionModeOutputVertices].caps.push_back(CapabilityTessellation); 1618 ExecutionModeParams[ExecutionModeOutputPoints].caps.push_back(CapabilityGeometry); 1619 ExecutionModeParams[ExecutionModeOutputLineStrip].caps.push_back(CapabilityGeometry); 1620 ExecutionModeParams[ExecutionModeOutputTriangleStrip].caps.push_back(CapabilityGeometry); 1621 ExecutionModeParams[ExecutionModeVecTypeHint].caps.push_back(CapabilityKernel); 1622 ExecutionModeParams[ExecutionModeContractionOff].caps.push_back(CapabilityKernel); 1623 1624 DecorationParams[DecorationRelaxedPrecision].caps.push_back(CapabilityShader); 1625 DecorationParams[DecorationBlock].caps.push_back(CapabilityShader); 1626 DecorationParams[DecorationBufferBlock].caps.push_back(CapabilityShader); 1627 DecorationParams[DecorationRowMajor].caps.push_back(CapabilityMatrix); 1628 DecorationParams[DecorationColMajor].caps.push_back(CapabilityMatrix); 1629 DecorationParams[DecorationGLSLShared].caps.push_back(CapabilityShader); 1630 DecorationParams[DecorationGLSLPacked].caps.push_back(CapabilityShader); 1631 DecorationParams[DecorationNoPerspective].caps.push_back(CapabilityShader); 1632 DecorationParams[DecorationFlat].caps.push_back(CapabilityShader); 1633 DecorationParams[DecorationPatch].caps.push_back(CapabilityTessellation); 1634 DecorationParams[DecorationCentroid].caps.push_back(CapabilityShader); 1635 DecorationParams[DecorationSample].caps.push_back(CapabilitySampleRateShading); 1636 DecorationParams[DecorationInvariant].caps.push_back(CapabilityShader); 1637 DecorationParams[DecorationConstant].caps.push_back(CapabilityKernel); 1638 DecorationParams[DecorationUniform].caps.push_back(CapabilityShader); 1639 DecorationParams[DecorationCPacked].caps.push_back(CapabilityKernel); 1640 DecorationParams[DecorationSaturatedConversion].caps.push_back(CapabilityKernel); 1641 DecorationParams[DecorationStream].caps.push_back(CapabilityGeometryStreams); 1642 DecorationParams[DecorationLocation].caps.push_back(CapabilityShader); 1643 DecorationParams[DecorationComponent].caps.push_back(CapabilityShader); 1644 DecorationParams[DecorationOffset].caps.push_back(CapabilityShader); 1645 DecorationParams[DecorationIndex].caps.push_back(CapabilityShader); 1646 DecorationParams[DecorationBinding].caps.push_back(CapabilityShader); 1647 DecorationParams[DecorationDescriptorSet].caps.push_back(CapabilityShader); 1648 DecorationParams[DecorationXfbBuffer].caps.push_back(CapabilityTransformFeedback); 1649 DecorationParams[DecorationXfbStride].caps.push_back(CapabilityTransformFeedback); 1650 DecorationParams[DecorationArrayStride].caps.push_back(CapabilityShader); 1651 DecorationParams[DecorationMatrixStride].caps.push_back(CapabilityMatrix); 1652 DecorationParams[DecorationFuncParamAttr].caps.push_back(CapabilityKernel); 1653 DecorationParams[DecorationFPRoundingMode].caps.push_back(CapabilityKernel); 1654 DecorationParams[DecorationFPFastMathMode].caps.push_back(CapabilityKernel); 1655 DecorationParams[DecorationLinkageAttributes].caps.push_back(CapabilityLinkage); 1656 DecorationParams[DecorationSpecId].caps.push_back(CapabilityShader); 1657 DecorationParams[DecorationNoContraction].caps.push_back(CapabilityShader); 1658 DecorationParams[DecorationInputAttachmentIndex].caps.push_back(CapabilityInputAttachment); 1659 DecorationParams[DecorationAlignment].caps.push_back(CapabilityKernel); 1660 1661 BuiltInParams[BuiltInPosition].caps.push_back(CapabilityShader); 1662 BuiltInParams[BuiltInPointSize].caps.push_back(CapabilityShader); 1663 BuiltInParams[BuiltInClipDistance].caps.push_back(CapabilityClipDistance); 1664 BuiltInParams[BuiltInCullDistance].caps.push_back(CapabilityCullDistance); 1665 1666 BuiltInParams[BuiltInVertexId].caps.push_back(CapabilityShader); 1667 BuiltInParams[BuiltInVertexId].desc = "Vertex ID, which takes on values 0, 1, 2, . . . ."; 1668 1669 BuiltInParams[BuiltInInstanceId].caps.push_back(CapabilityShader); 1670 BuiltInParams[BuiltInInstanceId].desc = "Instance ID, which takes on values 0, 1, 2, . . . ."; 1671 1672 BuiltInParams[BuiltInVertexIndex].caps.push_back(CapabilityShader); 1673 BuiltInParams[BuiltInVertexIndex].desc = "Vertex index, which takes on values base, base+1, base+2, . . . ."; 1674 1675 BuiltInParams[BuiltInInstanceIndex].caps.push_back(CapabilityShader); 1676 BuiltInParams[BuiltInInstanceIndex].desc = "Instance index, which takes on values base, base+1, base+2, . . . ."; 1677 1678 BuiltInParams[BuiltInPrimitiveId].caps.push_back(CapabilityGeometry); 1679 BuiltInParams[BuiltInPrimitiveId].caps.push_back(CapabilityTessellation); 1680 BuiltInParams[BuiltInInvocationId].caps.push_back(CapabilityGeometry); 1681 BuiltInParams[BuiltInInvocationId].caps.push_back(CapabilityTessellation); 1682 BuiltInParams[BuiltInLayer].caps.push_back(CapabilityGeometry); 1683 BuiltInParams[BuiltInViewportIndex].caps.push_back(CapabilityMultiViewport); 1684 BuiltInParams[BuiltInTessLevelOuter].caps.push_back(CapabilityTessellation); 1685 BuiltInParams[BuiltInTessLevelInner].caps.push_back(CapabilityTessellation); 1686 BuiltInParams[BuiltInTessCoord].caps.push_back(CapabilityTessellation); 1687 BuiltInParams[BuiltInPatchVertices].caps.push_back(CapabilityTessellation); 1688 BuiltInParams[BuiltInFragCoord].caps.push_back(CapabilityShader); 1689 BuiltInParams[BuiltInPointCoord].caps.push_back(CapabilityShader); 1690 BuiltInParams[BuiltInFrontFacing].caps.push_back(CapabilityShader); 1691 BuiltInParams[BuiltInSampleId].caps.push_back(CapabilitySampleRateShading); 1692 BuiltInParams[BuiltInSamplePosition].caps.push_back(CapabilitySampleRateShading); 1693 BuiltInParams[BuiltInSampleMask].caps.push_back(CapabilitySampleRateShading); 1694 BuiltInParams[BuiltInFragDepth].caps.push_back(CapabilityShader); 1695 BuiltInParams[BuiltInHelperInvocation].caps.push_back(CapabilityShader); 1696 BuiltInParams[BuiltInWorkDim].caps.push_back(CapabilityKernel); 1697 BuiltInParams[BuiltInGlobalSize].caps.push_back(CapabilityKernel); 1698 BuiltInParams[BuiltInEnqueuedWorkgroupSize].caps.push_back(CapabilityKernel); 1699 BuiltInParams[BuiltInGlobalOffset].caps.push_back(CapabilityKernel); 1700 BuiltInParams[BuiltInGlobalLinearId].caps.push_back(CapabilityKernel); 1701 1702 BuiltInParams[BuiltInSubgroupSize].caps.push_back(CapabilityKernel); 1703 BuiltInParams[BuiltInSubgroupMaxSize].caps.push_back(CapabilityKernel); 1704 BuiltInParams[BuiltInNumSubgroups].caps.push_back(CapabilityKernel); 1705 BuiltInParams[BuiltInNumEnqueuedSubgroups].caps.push_back(CapabilityKernel); 1706 BuiltInParams[BuiltInSubgroupId].caps.push_back(CapabilityKernel); 1707 BuiltInParams[BuiltInSubgroupLocalInvocationId].caps.push_back(CapabilityKernel); 1708 1709 DimensionalityParams[Dim1D].caps.push_back(CapabilitySampled1D); 1710 DimensionalityParams[DimCube].caps.push_back(CapabilityShader); 1711 DimensionalityParams[DimRect].caps.push_back(CapabilitySampledRect); 1712 DimensionalityParams[DimBuffer].caps.push_back(CapabilitySampledBuffer); 1713 DimensionalityParams[DimSubpassData].caps.push_back(CapabilityInputAttachment); 1714 1715 // Group Operations 1716 for (int i = 0; i < GroupOperationCeiling; ++i) { 1717 GroupOperationParams[i].caps.push_back(CapabilityKernel); 1718 } 1719 1720 // Enqueue flags 1721 for (int i = 0; i < KernelEnqueueFlagsCeiling; ++i) { 1722 KernelEnqueueFlagsParams[i].caps.push_back(CapabilityKernel); 1723 } 1724 1725 // Profiling info 1726 KernelProfilingInfoParams[0].caps.push_back(CapabilityKernel); 1727 1728 // set name of operator, an initial set of <id> style operands, and the description 1729 1730 InstructionDesc[OpSource].operands.push(OperandSource, ""); 1731 InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'"); 1732 InstructionDesc[OpSource].operands.push(OperandId, "'File'", true); 1733 InstructionDesc[OpSource].operands.push(OperandLiteralString, "'Source'", true); 1734 1735 InstructionDesc[OpSourceContinued].operands.push(OperandLiteralString, "'Continued Source'"); 1736 1737 InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'"); 1738 1739 InstructionDesc[OpName].operands.push(OperandId, "'Target'"); 1740 InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'"); 1741 1742 InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'"); 1743 InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'"); 1744 InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'"); 1745 1746 InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'"); 1747 1748 InstructionDesc[OpLine].operands.push(OperandId, "'File'"); 1749 InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'"); 1750 InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'"); 1751 1752 InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'"); 1753 1754 InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'"); 1755 1756 InstructionDesc[OpCapability].operands.push(OperandCapability, "'Capability'"); 1757 1758 InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, ""); 1759 InstructionDesc[OpMemoryModel].operands.push(OperandMemory, ""); 1760 1761 InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, ""); 1762 InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'"); 1763 InstructionDesc[OpEntryPoint].operands.push(OperandLiteralString, "'Name'"); 1764 InstructionDesc[OpEntryPoint].operands.push(OperandVariableIds, "'Interface'"); 1765 1766 InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'"); 1767 InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'"); 1768 InstructionDesc[OpExecutionMode].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>"); 1769 1770 InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'"); 1771 InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'"); 1772 1773 InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'"); 1774 1775 InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component Type'"); 1776 InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component Count'"); 1777 1778 InstructionDesc[OpTypeMatrix].capabilities.push_back(CapabilityMatrix); 1779 InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column Type'"); 1780 InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column Count'"); 1781 1782 InstructionDesc[OpTypeImage].operands.push(OperandId, "'Sampled Type'"); 1783 InstructionDesc[OpTypeImage].operands.push(OperandDimensionality, ""); 1784 InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Depth'"); 1785 InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Arrayed'"); 1786 InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'MS'"); 1787 InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Sampled'"); 1788 InstructionDesc[OpTypeImage].operands.push(OperandSamplerImageFormat, ""); 1789 InstructionDesc[OpTypeImage].operands.push(OperandAccessQualifier, "", true); 1790 1791 InstructionDesc[OpTypeSampledImage].operands.push(OperandId, "'Image Type'"); 1792 1793 InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element Type'"); 1794 InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'"); 1795 1796 InstructionDesc[OpTypeRuntimeArray].capabilities.push_back(CapabilityShader); 1797 InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element Type'"); 1798 1799 InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n..."); 1800 1801 InstructionDesc[OpTypeOpaque].capabilities.push_back(CapabilityKernel); 1802 InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type."); 1803 1804 InstructionDesc[OpTypePointer].operands.push(OperandStorage, ""); 1805 InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'"); 1806 1807 InstructionDesc[OpTypeForwardPointer].capabilities.push_back(CapabilityAddresses); 1808 InstructionDesc[OpTypeForwardPointer].operands.push(OperandId, "'Pointer Type'"); 1809 InstructionDesc[OpTypeForwardPointer].operands.push(OperandStorage, ""); 1810 1811 InstructionDesc[OpTypeEvent].capabilities.push_back(CapabilityKernel); 1812 1813 InstructionDesc[OpTypeDeviceEvent].capabilities.push_back(CapabilityDeviceEnqueue); 1814 1815 InstructionDesc[OpTypeReserveId].capabilities.push_back(CapabilityPipes); 1816 1817 InstructionDesc[OpTypeQueue].capabilities.push_back(CapabilityDeviceEnqueue); 1818 1819 InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'"); 1820 InstructionDesc[OpTypePipe].capabilities.push_back(CapabilityPipes); 1821 1822 InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'"); 1823 InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n..."); 1824 1825 InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'"); 1826 1827 InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'"); 1828 1829 InstructionDesc[OpConstantSampler].capabilities.push_back(CapabilityLiteralSampler); 1830 InstructionDesc[OpConstantSampler].operands.push(OperandSamplerAddressingMode, ""); 1831 InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'"); 1832 InstructionDesc[OpConstantSampler].operands.push(OperandSamplerFilterMode, ""); 1833 1834 InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'"); 1835 1836 InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'"); 1837 1838 InstructionDesc[OpSpecConstantOp].operands.push(OperandLiteralNumber, "'Opcode'"); 1839 InstructionDesc[OpSpecConstantOp].operands.push(OperandVariableIds, "'Operands'"); 1840 1841 InstructionDesc[OpVariable].operands.push(OperandStorage, ""); 1842 InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true); 1843 1844 InstructionDesc[OpFunction].operands.push(OperandFunction, ""); 1845 InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'"); 1846 1847 InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'"); 1848 InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n..."); 1849 1850 InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'"); 1851 InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'"); 1852 InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n..."); 1853 1854 InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'"); 1855 InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true); 1856 1857 InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'"); 1858 InstructionDesc[OpStore].operands.push(OperandId, "'Object'"); 1859 InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true); 1860 1861 InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'"); 1862 1863 InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'"); 1864 InstructionDesc[OpDecorate].operands.push(OperandDecoration, ""); 1865 InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>."); 1866 1867 InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure Type'"); 1868 InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'"); 1869 InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, ""); 1870 InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>."); 1871 1872 InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration Group'"); 1873 InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Targets'"); 1874 1875 InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration Group'"); 1876 InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIdLiteral, "'Targets'"); 1877 1878 InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'"); 1879 InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'"); 1880 1881 InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'"); 1882 InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'"); 1883 InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'"); 1884 1885 InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'"); 1886 InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'"); 1887 InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'"); 1888 1889 InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'"); 1890 1891 InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'"); 1892 InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'"); 1893 1894 InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'"); 1895 InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'"); 1896 InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'"); 1897 1898 InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'"); 1899 1900 InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'"); 1901 InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'"); 1902 InstructionDesc[OpCopyMemory].operands.push(OperandMemoryAccess, "", true); 1903 1904 InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'"); 1905 InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'"); 1906 InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'"); 1907 InstructionDesc[OpCopyMemorySized].operands.push(OperandMemoryAccess, "", true); 1908 1909 InstructionDesc[OpCopyMemorySized].capabilities.push_back(CapabilityAddresses); 1910 1911 InstructionDesc[OpSampledImage].operands.push(OperandId, "'Image'"); 1912 InstructionDesc[OpSampledImage].operands.push(OperandId, "'Sampler'"); 1913 1914 InstructionDesc[OpImage].operands.push(OperandId, "'Sampled Image'"); 1915 1916 InstructionDesc[OpImageRead].operands.push(OperandId, "'Image'"); 1917 InstructionDesc[OpImageRead].operands.push(OperandId, "'Coordinate'"); 1918 InstructionDesc[OpImageRead].operands.push(OperandImageOperands, "", true); 1919 InstructionDesc[OpImageRead].operands.push(OperandVariableIds, "", true); 1920 1921 InstructionDesc[OpImageWrite].operands.push(OperandId, "'Image'"); 1922 InstructionDesc[OpImageWrite].operands.push(OperandId, "'Coordinate'"); 1923 InstructionDesc[OpImageWrite].operands.push(OperandId, "'Texel'"); 1924 InstructionDesc[OpImageWrite].operands.push(OperandImageOperands, "", true); 1925 InstructionDesc[OpImageWrite].operands.push(OperandVariableIds, "", true); 1926 1927 InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Sampled Image'"); 1928 InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Coordinate'"); 1929 InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandImageOperands, "", true); 1930 InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandVariableIds, "", true); 1931 InstructionDesc[OpImageSampleImplicitLod].capabilities.push_back(CapabilityShader); 1932 1933 InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Sampled Image'"); 1934 InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Coordinate'"); 1935 InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandImageOperands, "", true); 1936 InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandVariableIds, "", true); 1937 1938 InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'"); 1939 InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'"); 1940 InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'"); 1941 InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true); 1942 InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true); 1943 InstructionDesc[OpImageSampleDrefImplicitLod].capabilities.push_back(CapabilityShader); 1944 1945 InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'"); 1946 InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'"); 1947 InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'"); 1948 InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true); 1949 InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true); 1950 InstructionDesc[OpImageSampleDrefExplicitLod].capabilities.push_back(CapabilityShader); 1951 1952 InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'"); 1953 InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'"); 1954 InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandImageOperands, "", true); 1955 InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandVariableIds, "", true); 1956 InstructionDesc[OpImageSampleProjImplicitLod].capabilities.push_back(CapabilityShader); 1957 1958 InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'"); 1959 InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'"); 1960 InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandImageOperands, "", true); 1961 InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandVariableIds, "", true); 1962 InstructionDesc[OpImageSampleProjExplicitLod].capabilities.push_back(CapabilityShader); 1963 1964 InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'"); 1965 InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'"); 1966 InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'"); 1967 InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true); 1968 InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true); 1969 InstructionDesc[OpImageSampleProjDrefImplicitLod].capabilities.push_back(CapabilityShader); 1970 1971 InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'"); 1972 InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'"); 1973 InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'"); 1974 InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true); 1975 InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true); 1976 InstructionDesc[OpImageSampleProjDrefExplicitLod].capabilities.push_back(CapabilityShader); 1977 1978 InstructionDesc[OpImageFetch].operands.push(OperandId, "'Image'"); 1979 InstructionDesc[OpImageFetch].operands.push(OperandId, "'Coordinate'"); 1980 InstructionDesc[OpImageFetch].operands.push(OperandImageOperands, "", true); 1981 InstructionDesc[OpImageFetch].operands.push(OperandVariableIds, "", true); 1982 1983 InstructionDesc[OpImageGather].operands.push(OperandId, "'Sampled Image'"); 1984 InstructionDesc[OpImageGather].operands.push(OperandId, "'Coordinate'"); 1985 InstructionDesc[OpImageGather].operands.push(OperandId, "'Component'"); 1986 InstructionDesc[OpImageGather].operands.push(OperandImageOperands, "", true); 1987 InstructionDesc[OpImageGather].operands.push(OperandVariableIds, "", true); 1988 InstructionDesc[OpImageGather].capabilities.push_back(CapabilityShader); 1989 1990 InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Sampled Image'"); 1991 InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Coordinate'"); 1992 InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'D~ref~'"); 1993 InstructionDesc[OpImageDrefGather].operands.push(OperandImageOperands, "", true); 1994 InstructionDesc[OpImageDrefGather].operands.push(OperandVariableIds, "", true); 1995 InstructionDesc[OpImageDrefGather].capabilities.push_back(CapabilityShader); 1996 1997 InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Sampled Image'"); 1998 InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Coordinate'"); 1999 InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandImageOperands, "", true); 2000 InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandVariableIds, "", true); 2001 InstructionDesc[OpImageSparseSampleImplicitLod].capabilities.push_back(CapabilitySparseResidency); 2002 2003 InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Sampled Image'"); 2004 InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Coordinate'"); 2005 InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandImageOperands, "", true); 2006 InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandVariableIds, "", true); 2007 InstructionDesc[OpImageSparseSampleExplicitLod].capabilities.push_back(CapabilitySparseResidency); 2008 2009 InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'"); 2010 InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'"); 2011 InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'"); 2012 InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true); 2013 InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true); 2014 InstructionDesc[OpImageSparseSampleDrefImplicitLod].capabilities.push_back(CapabilitySparseResidency); 2015 2016 InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'"); 2017 InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'"); 2018 InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'"); 2019 InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true); 2020 InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true); 2021 InstructionDesc[OpImageSparseSampleDrefExplicitLod].capabilities.push_back(CapabilitySparseResidency); 2022 2023 InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'"); 2024 InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'"); 2025 InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandImageOperands, "", true); 2026 InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandVariableIds, "", true); 2027 InstructionDesc[OpImageSparseSampleProjImplicitLod].capabilities.push_back(CapabilitySparseResidency); 2028 2029 InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'"); 2030 InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'"); 2031 InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandImageOperands, "", true); 2032 InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandVariableIds, "", true); 2033 InstructionDesc[OpImageSparseSampleProjExplicitLod].capabilities.push_back(CapabilitySparseResidency); 2034 2035 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'"); 2036 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'"); 2037 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'"); 2038 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true); 2039 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true); 2040 InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].capabilities.push_back(CapabilitySparseResidency); 2041 2042 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'"); 2043 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'"); 2044 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'"); 2045 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true); 2046 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true); 2047 InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].capabilities.push_back(CapabilitySparseResidency); 2048 2049 InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Image'"); 2050 InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Coordinate'"); 2051 InstructionDesc[OpImageSparseFetch].operands.push(OperandImageOperands, "", true); 2052 InstructionDesc[OpImageSparseFetch].operands.push(OperandVariableIds, "", true); 2053 InstructionDesc[OpImageSparseFetch].capabilities.push_back(CapabilitySparseResidency); 2054 2055 InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Sampled Image'"); 2056 InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Coordinate'"); 2057 InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Component'"); 2058 InstructionDesc[OpImageSparseGather].operands.push(OperandImageOperands, "", true); 2059 InstructionDesc[OpImageSparseGather].operands.push(OperandVariableIds, "", true); 2060 InstructionDesc[OpImageSparseGather].capabilities.push_back(CapabilitySparseResidency); 2061 2062 InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Sampled Image'"); 2063 InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Coordinate'"); 2064 InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'D~ref~'"); 2065 InstructionDesc[OpImageSparseDrefGather].operands.push(OperandImageOperands, "", true); 2066 InstructionDesc[OpImageSparseDrefGather].operands.push(OperandVariableIds, "", true); 2067 InstructionDesc[OpImageSparseDrefGather].capabilities.push_back(CapabilitySparseResidency); 2068 2069 InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Image'"); 2070 InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Coordinate'"); 2071 InstructionDesc[OpImageSparseRead].operands.push(OperandImageOperands, "", true); 2072 InstructionDesc[OpImageSparseRead].operands.push(OperandVariableIds, "", true); 2073 InstructionDesc[OpImageSparseRead].capabilities.push_back(CapabilitySparseResidency); 2074 2075 InstructionDesc[OpImageSparseTexelsResident].operands.push(OperandId, "'Resident Code'"); 2076 InstructionDesc[OpImageSparseTexelsResident].capabilities.push_back(CapabilitySparseResidency); 2077 2078 InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Image'"); 2079 InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Level of Detail'"); 2080 InstructionDesc[OpImageQuerySizeLod].capabilities.push_back(CapabilityKernel); 2081 InstructionDesc[OpImageQuerySizeLod].capabilities.push_back(CapabilityImageQuery); 2082 2083 InstructionDesc[OpImageQuerySize].operands.push(OperandId, "'Image'"); 2084 InstructionDesc[OpImageQuerySize].capabilities.push_back(CapabilityKernel); 2085 InstructionDesc[OpImageQuerySize].capabilities.push_back(CapabilityImageQuery); 2086 2087 InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Image'"); 2088 InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Coordinate'"); 2089 InstructionDesc[OpImageQueryLod].capabilities.push_back(CapabilityImageQuery); 2090 2091 InstructionDesc[OpImageQueryLevels].operands.push(OperandId, "'Image'"); 2092 InstructionDesc[OpImageQueryLevels].capabilities.push_back(CapabilityKernel); 2093 InstructionDesc[OpImageQueryLevels].capabilities.push_back(CapabilityImageQuery); 2094 2095 InstructionDesc[OpImageQuerySamples].operands.push(OperandId, "'Image'"); 2096 InstructionDesc[OpImageQuerySamples].capabilities.push_back(CapabilityKernel); 2097 InstructionDesc[OpImageQuerySamples].capabilities.push_back(CapabilityImageQuery); 2098 2099 InstructionDesc[OpImageQueryFormat].operands.push(OperandId, "'Image'"); 2100 InstructionDesc[OpImageQueryFormat].capabilities.push_back(CapabilityKernel); 2101 2102 InstructionDesc[OpImageQueryOrder].operands.push(OperandId, "'Image'"); 2103 InstructionDesc[OpImageQueryOrder].capabilities.push_back(CapabilityKernel); 2104 2105 InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'"); 2106 InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'"); 2107 2108 InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'"); 2109 InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'"); 2110 2111 InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Base'"); 2112 InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Element'"); 2113 InstructionDesc[OpPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'"); 2114 InstructionDesc[OpPtrAccessChain].capabilities.push_back(CapabilityAddresses); 2115 2116 InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Base'"); 2117 InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Element'"); 2118 InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'"); 2119 InstructionDesc[OpInBoundsPtrAccessChain].capabilities.push_back(CapabilityAddresses); 2120 2121 InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'"); 2122 2123 InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'"); 2124 2125 InstructionDesc[OpNot].operands.push(OperandId, "'Operand'"); 2126 2127 InstructionDesc[OpAny].operands.push(OperandId, "'Vector'"); 2128 2129 InstructionDesc[OpAll].operands.push(OperandId, "'Vector'"); 2130 2131 InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'"); 2132 2133 InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'"); 2134 2135 InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'"); 2136 2137 InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned Value'"); 2138 2139 InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned Value'"); 2140 2141 InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'"); 2142 2143 InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'"); 2144 2145 InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'"); 2146 InstructionDesc[OpSatConvertSToU].capabilities.push_back(CapabilityKernel); 2147 2148 InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'"); 2149 InstructionDesc[OpSatConvertUToS].capabilities.push_back(CapabilityKernel); 2150 2151 InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'"); 2152 InstructionDesc[OpConvertPtrToU].capabilities.push_back(CapabilityAddresses); 2153 2154 InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer Value'"); 2155 InstructionDesc[OpConvertUToPtr].capabilities.push_back(CapabilityAddresses); 2156 2157 InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Pointer'"); 2158 InstructionDesc[OpPtrCastToGeneric].capabilities.push_back(CapabilityKernel); 2159 2160 InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Pointer'"); 2161 InstructionDesc[OpGenericCastToPtr].capabilities.push_back(CapabilityKernel); 2162 2163 InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Pointer'"); 2164 InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'Storage'"); 2165 InstructionDesc[OpGenericCastToPtrExplicit].capabilities.push_back(CapabilityKernel); 2166 2167 InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'Pointer'"); 2168 InstructionDesc[OpGenericPtrMemSemantics].capabilities.push_back(CapabilityKernel); 2169 2170 InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'"); 2171 2172 InstructionDesc[OpQuantizeToF16].operands.push(OperandId, "'Value'"); 2173 2174 InstructionDesc[OpTranspose].capabilities.push_back(CapabilityMatrix); 2175 InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'"); 2176 2177 InstructionDesc[OpIsNan].operands.push(OperandId, "'x'"); 2178 2179 InstructionDesc[OpIsInf].operands.push(OperandId, "'x'"); 2180 2181 InstructionDesc[OpIsFinite].capabilities.push_back(CapabilityKernel); 2182 InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'"); 2183 2184 InstructionDesc[OpIsNormal].capabilities.push_back(CapabilityKernel); 2185 InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'"); 2186 2187 InstructionDesc[OpSignBitSet].capabilities.push_back(CapabilityKernel); 2188 InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'"); 2189 2190 InstructionDesc[OpLessOrGreater].capabilities.push_back(CapabilityKernel); 2191 InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'"); 2192 InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'"); 2193 2194 InstructionDesc[OpOrdered].capabilities.push_back(CapabilityKernel); 2195 InstructionDesc[OpOrdered].operands.push(OperandId, "'x'"); 2196 InstructionDesc[OpOrdered].operands.push(OperandId, "'y'"); 2197 2198 InstructionDesc[OpUnordered].capabilities.push_back(CapabilityKernel); 2199 InstructionDesc[OpUnordered].operands.push(OperandId, "'x'"); 2200 InstructionDesc[OpUnordered].operands.push(OperandId, "'y'"); 2201 2202 InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'"); 2203 InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'"); 2204 InstructionDesc[OpArrayLength].capabilities.push_back(CapabilityShader); 2205 2206 InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'"); 2207 InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'"); 2208 2209 InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'"); 2210 InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'"); 2211 2212 InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'"); 2213 InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'"); 2214 2215 InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'"); 2216 InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'"); 2217 2218 InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'"); 2219 InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'"); 2220 2221 InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'"); 2222 InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'"); 2223 2224 InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'"); 2225 InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'"); 2226 2227 InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'"); 2228 InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'"); 2229 2230 InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'"); 2231 InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'"); 2232 2233 InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'"); 2234 InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'"); 2235 2236 InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'"); 2237 InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'"); 2238 2239 InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'"); 2240 InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'"); 2241 2242 InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'"); 2243 InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'"); 2244 2245 InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'"); 2246 InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'"); 2247 2248 InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'"); 2249 InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'"); 2250 2251 InstructionDesc[OpMatrixTimesScalar].capabilities.push_back(CapabilityMatrix); 2252 InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'"); 2253 InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'"); 2254 2255 InstructionDesc[OpVectorTimesMatrix].capabilities.push_back(CapabilityMatrix); 2256 InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'"); 2257 InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'"); 2258 2259 InstructionDesc[OpMatrixTimesVector].capabilities.push_back(CapabilityMatrix); 2260 InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'"); 2261 InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'"); 2262 2263 InstructionDesc[OpMatrixTimesMatrix].capabilities.push_back(CapabilityMatrix); 2264 InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'"); 2265 InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'"); 2266 2267 InstructionDesc[OpOuterProduct].capabilities.push_back(CapabilityMatrix); 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].capabilities.push_back(CapabilityShader); 2319 InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Base'"); 2320 InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Insert'"); 2321 InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Offset'"); 2322 InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Count'"); 2323 2324 InstructionDesc[OpBitFieldSExtract].capabilities.push_back(CapabilityShader); 2325 InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'"); 2326 InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'"); 2327 InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'"); 2328 2329 InstructionDesc[OpBitFieldUExtract].capabilities.push_back(CapabilityShader); 2330 InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'"); 2331 InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'"); 2332 InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'"); 2333 2334 InstructionDesc[OpBitReverse].capabilities.push_back(CapabilityShader); 2335 InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'"); 2336 2337 InstructionDesc[OpBitCount].operands.push(OperandId, "'Base'"); 2338 2339 InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'"); 2340 InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'"); 2341 InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'"); 2342 2343 InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'"); 2344 InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'"); 2345 2346 InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'"); 2347 InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'"); 2348 2349 InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'"); 2350 InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'"); 2351 2352 InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'"); 2353 InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'"); 2354 2355 InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'"); 2356 InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'"); 2357 2358 InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'"); 2359 InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'"); 2360 2361 InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'"); 2362 InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'"); 2363 2364 InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'"); 2365 InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'"); 2366 2367 InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'"); 2368 InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'"); 2369 2370 InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'"); 2371 InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'"); 2372 2373 InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'"); 2374 InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'"); 2375 2376 InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'"); 2377 InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'"); 2378 2379 InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'"); 2380 InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'"); 2381 2382 InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'"); 2383 InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'"); 2384 2385 InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'"); 2386 InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'"); 2387 2388 InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'"); 2389 InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'"); 2390 2391 InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'"); 2392 InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'"); 2393 2394 InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'"); 2395 InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'"); 2396 2397 InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); 2398 InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); 2399 2400 InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); 2401 InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); 2402 2403 InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); 2404 InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); 2405 2406 InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); 2407 InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); 2408 2409 InstructionDesc[OpDPdx].capabilities.push_back(CapabilityShader); 2410 InstructionDesc[OpDPdx].operands.push(OperandId, "'P'"); 2411 2412 InstructionDesc[OpDPdy].capabilities.push_back(CapabilityShader); 2413 InstructionDesc[OpDPdy].operands.push(OperandId, "'P'"); 2414 2415 InstructionDesc[OpFwidth].capabilities.push_back(CapabilityShader); 2416 InstructionDesc[OpFwidth].operands.push(OperandId, "'P'"); 2417 2418 InstructionDesc[OpDPdxFine].capabilities.push_back(CapabilityDerivativeControl); 2419 InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'"); 2420 2421 InstructionDesc[OpDPdyFine].capabilities.push_back(CapabilityDerivativeControl); 2422 InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'"); 2423 2424 InstructionDesc[OpFwidthFine].capabilities.push_back(CapabilityDerivativeControl); 2425 InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'"); 2426 2427 InstructionDesc[OpDPdxCoarse].capabilities.push_back(CapabilityDerivativeControl); 2428 InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'"); 2429 2430 InstructionDesc[OpDPdyCoarse].capabilities.push_back(CapabilityDerivativeControl); 2431 InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'"); 2432 2433 InstructionDesc[OpFwidthCoarse].capabilities.push_back(CapabilityDerivativeControl); 2434 InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'"); 2435 2436 InstructionDesc[OpEmitVertex].capabilities.push_back(CapabilityGeometry); 2437 2438 InstructionDesc[OpEndPrimitive].capabilities.push_back(CapabilityGeometry); 2439 2440 InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'"); 2441 InstructionDesc[OpEmitStreamVertex].capabilities.push_back(CapabilityGeometryStreams); 2442 2443 InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'"); 2444 InstructionDesc[OpEndStreamPrimitive].capabilities.push_back(CapabilityGeometryStreams); 2445 2446 InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Execution'"); 2447 InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Memory'"); 2448 InstructionDesc[OpControlBarrier].operands.push(OperandMemorySemantics, "'Semantics'"); 2449 2450 InstructionDesc[OpMemoryBarrier].operands.push(OperandScope, "'Memory'"); 2451 InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'"); 2452 2453 InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Image'"); 2454 InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Coordinate'"); 2455 InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Sample'"); 2456 2457 InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'"); 2458 InstructionDesc[OpAtomicLoad].operands.push(OperandScope, "'Scope'"); 2459 InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'"); 2460 2461 InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'"); 2462 InstructionDesc[OpAtomicStore].operands.push(OperandScope, "'Scope'"); 2463 InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'"); 2464 InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'"); 2465 2466 InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'"); 2467 InstructionDesc[OpAtomicExchange].operands.push(OperandScope, "'Scope'"); 2468 InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'"); 2469 InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'"); 2470 2471 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'"); 2472 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandScope, "'Scope'"); 2473 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Equal'"); 2474 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Unequal'"); 2475 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'"); 2476 InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'"); 2477 2478 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'"); 2479 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandScope, "'Scope'"); 2480 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Equal'"); 2481 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Unequal'"); 2482 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'"); 2483 InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'"); 2484 InstructionDesc[OpAtomicCompareExchangeWeak].capabilities.push_back(CapabilityKernel); 2485 2486 InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'"); 2487 InstructionDesc[OpAtomicIIncrement].operands.push(OperandScope, "'Scope'"); 2488 InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'"); 2489 2490 InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'"); 2491 InstructionDesc[OpAtomicIDecrement].operands.push(OperandScope, "'Scope'"); 2492 InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'"); 2493 2494 InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'"); 2495 InstructionDesc[OpAtomicIAdd].operands.push(OperandScope, "'Scope'"); 2496 InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'"); 2497 InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'"); 2498 2499 InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'"); 2500 InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'"); 2501 InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'"); 2502 InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'"); 2503 2504 InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'"); 2505 InstructionDesc[OpAtomicUMin].operands.push(OperandScope, "'Scope'"); 2506 InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'"); 2507 InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'"); 2508 2509 InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'"); 2510 InstructionDesc[OpAtomicUMax].operands.push(OperandScope, "'Scope'"); 2511 InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'"); 2512 InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'"); 2513 2514 InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Pointer'"); 2515 InstructionDesc[OpAtomicSMin].operands.push(OperandScope, "'Scope'"); 2516 InstructionDesc[OpAtomicSMin].operands.push(OperandMemorySemantics, "'Semantics'"); 2517 InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Value'"); 2518 2519 InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Pointer'"); 2520 InstructionDesc[OpAtomicSMax].operands.push(OperandScope, "'Scope'"); 2521 InstructionDesc[OpAtomicSMax].operands.push(OperandMemorySemantics, "'Semantics'"); 2522 InstructionDesc[OpAtomicSMax].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 InstructionDesc[OpAtomicFlagTestAndSet].capabilities.push_back(CapabilityKernel); 2543 2544 InstructionDesc[OpAtomicFlagClear].operands.push(OperandId, "'Pointer'"); 2545 InstructionDesc[OpAtomicFlagClear].operands.push(OperandScope, "'Scope'"); 2546 InstructionDesc[OpAtomicFlagClear].operands.push(OperandMemorySemantics, "'Semantics'"); 2547 InstructionDesc[OpAtomicFlagClear].capabilities.push_back(CapabilityKernel); 2548 2549 InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Merge Block'"); 2550 InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Continue Target'"); 2551 InstructionDesc[OpLoopMerge].operands.push(OperandLoop, ""); 2552 2553 InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Merge Block'"); 2554 InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, ""); 2555 2556 InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'"); 2557 2558 InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'"); 2559 InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'"); 2560 InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'"); 2561 InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'"); 2562 2563 InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'"); 2564 InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'"); 2565 InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'"); 2566 2567 InstructionDesc[OpKill].capabilities.push_back(CapabilityShader); 2568 2569 InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'"); 2570 2571 InstructionDesc[OpLifetimeStart].operands.push(OperandId, "'Pointer'"); 2572 InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, "'Size'"); 2573 InstructionDesc[OpLifetimeStart].capabilities.push_back(CapabilityKernel); 2574 2575 InstructionDesc[OpLifetimeStop].operands.push(OperandId, "'Pointer'"); 2576 InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, "'Size'"); 2577 InstructionDesc[OpLifetimeStop].capabilities.push_back(CapabilityKernel); 2578 2579 InstructionDesc[OpGroupAsyncCopy].capabilities.push_back(CapabilityKernel); 2580 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandScope, "'Execution'"); 2581 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Destination'"); 2582 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Source'"); 2583 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Num Elements'"); 2584 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Stride'"); 2585 InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Event'"); 2586 2587 InstructionDesc[OpGroupWaitEvents].capabilities.push_back(CapabilityKernel); 2588 InstructionDesc[OpGroupWaitEvents].operands.push(OperandScope, "'Execution'"); 2589 InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Num Events'"); 2590 InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Events List'"); 2591 2592 InstructionDesc[OpGroupAll].capabilities.push_back(CapabilityGroups); 2593 InstructionDesc[OpGroupAll].operands.push(OperandScope, "'Execution'"); 2594 InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'"); 2595 2596 InstructionDesc[OpGroupAny].capabilities.push_back(CapabilityGroups); 2597 InstructionDesc[OpGroupAny].operands.push(OperandScope, "'Execution'"); 2598 InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'"); 2599 2600 InstructionDesc[OpGroupBroadcast].capabilities.push_back(CapabilityGroups); 2601 InstructionDesc[OpGroupBroadcast].operands.push(OperandScope, "'Execution'"); 2602 InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'"); 2603 InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'"); 2604 2605 InstructionDesc[OpGroupIAdd].capabilities.push_back(CapabilityGroups); 2606 InstructionDesc[OpGroupIAdd].operands.push(OperandScope, "'Execution'"); 2607 InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'"); 2608 InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'"); 2609 2610 InstructionDesc[OpGroupFAdd].capabilities.push_back(CapabilityGroups); 2611 InstructionDesc[OpGroupFAdd].operands.push(OperandScope, "'Execution'"); 2612 InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'"); 2613 InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'"); 2614 2615 InstructionDesc[OpGroupUMin].capabilities.push_back(CapabilityGroups); 2616 InstructionDesc[OpGroupUMin].operands.push(OperandScope, "'Execution'"); 2617 InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'"); 2618 InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'"); 2619 2620 InstructionDesc[OpGroupSMin].capabilities.push_back(CapabilityGroups); 2621 InstructionDesc[OpGroupSMin].operands.push(OperandScope, "'Execution'"); 2622 InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'"); 2623 InstructionDesc[OpGroupSMin].operands.push(OperandId, "X"); 2624 2625 InstructionDesc[OpGroupFMin].capabilities.push_back(CapabilityGroups); 2626 InstructionDesc[OpGroupFMin].operands.push(OperandScope, "'Execution'"); 2627 InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'"); 2628 InstructionDesc[OpGroupFMin].operands.push(OperandId, "X"); 2629 2630 InstructionDesc[OpGroupUMax].capabilities.push_back(CapabilityGroups); 2631 InstructionDesc[OpGroupUMax].operands.push(OperandScope, "'Execution'"); 2632 InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'"); 2633 InstructionDesc[OpGroupUMax].operands.push(OperandId, "X"); 2634 2635 InstructionDesc[OpGroupSMax].capabilities.push_back(CapabilityGroups); 2636 InstructionDesc[OpGroupSMax].operands.push(OperandScope, "'Execution'"); 2637 InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'"); 2638 InstructionDesc[OpGroupSMax].operands.push(OperandId, "X"); 2639 2640 InstructionDesc[OpGroupFMax].capabilities.push_back(CapabilityGroups); 2641 InstructionDesc[OpGroupFMax].operands.push(OperandScope, "'Execution'"); 2642 InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'"); 2643 InstructionDesc[OpGroupFMax].operands.push(OperandId, "X"); 2644 2645 InstructionDesc[OpReadPipe].capabilities.push_back(CapabilityPipes); 2646 InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pipe'"); 2647 InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pointer'"); 2648 InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Size'"); 2649 InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Alignment'"); 2650 2651 InstructionDesc[OpWritePipe].capabilities.push_back(CapabilityPipes); 2652 InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pipe'"); 2653 InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pointer'"); 2654 InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Size'"); 2655 InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Alignment'"); 2656 2657 InstructionDesc[OpReservedReadPipe].capabilities.push_back(CapabilityPipes); 2658 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pipe'"); 2659 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Reserve Id'"); 2660 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Index'"); 2661 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pointer'"); 2662 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Size'"); 2663 InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Alignment'"); 2664 2665 InstructionDesc[OpReservedWritePipe].capabilities.push_back(CapabilityPipes); 2666 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pipe'"); 2667 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Reserve Id'"); 2668 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Index'"); 2669 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pointer'"); 2670 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Size'"); 2671 InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Alignment'"); 2672 2673 InstructionDesc[OpReserveReadPipePackets].capabilities.push_back(CapabilityPipes); 2674 InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Pipe'"); 2675 InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Num Packets'"); 2676 InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Size'"); 2677 InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'"); 2678 2679 InstructionDesc[OpReserveWritePipePackets].capabilities.push_back(CapabilityPipes); 2680 InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Pipe'"); 2681 InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Num Packets'"); 2682 InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Size'"); 2683 InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'"); 2684 2685 InstructionDesc[OpCommitReadPipe].capabilities.push_back(CapabilityPipes); 2686 InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Pipe'"); 2687 InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Reserve Id'"); 2688 InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Size'"); 2689 InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Alignment'"); 2690 2691 InstructionDesc[OpCommitWritePipe].capabilities.push_back(CapabilityPipes); 2692 InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Pipe'"); 2693 InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Reserve Id'"); 2694 InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Size'"); 2695 InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Alignment'"); 2696 2697 InstructionDesc[OpIsValidReserveId].capabilities.push_back(CapabilityPipes); 2698 InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'Reserve Id'"); 2699 2700 InstructionDesc[OpGetNumPipePackets].capabilities.push_back(CapabilityPipes); 2701 InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Pipe'"); 2702 InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Size'"); 2703 InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Alignment'"); 2704 2705 InstructionDesc[OpGetMaxPipePackets].capabilities.push_back(CapabilityPipes); 2706 InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Pipe'"); 2707 InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Size'"); 2708 InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Alignment'"); 2709 2710 InstructionDesc[OpGroupReserveReadPipePackets].capabilities.push_back(CapabilityPipes); 2711 InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandScope, "'Execution'"); 2712 InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Pipe'"); 2713 InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Num Packets'"); 2714 InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Size'"); 2715 InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'"); 2716 2717 InstructionDesc[OpGroupReserveWritePipePackets].capabilities.push_back(CapabilityPipes); 2718 InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandScope, "'Execution'"); 2719 InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Pipe'"); 2720 InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Num Packets'"); 2721 InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Size'"); 2722 InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'"); 2723 2724 InstructionDesc[OpGroupCommitReadPipe].capabilities.push_back(CapabilityPipes); 2725 InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandScope, "'Execution'"); 2726 InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Pipe'"); 2727 InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Reserve Id'"); 2728 InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Size'"); 2729 InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Alignment'"); 2730 2731 InstructionDesc[OpGroupCommitWritePipe].capabilities.push_back(CapabilityPipes); 2732 InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandScope, "'Execution'"); 2733 InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Pipe'"); 2734 InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Reserve Id'"); 2735 InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Size'"); 2736 InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Alignment'"); 2737 2738 InstructionDesc[OpBuildNDRange].capabilities.push_back(CapabilityDeviceEnqueue); 2739 InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'"); 2740 InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'"); 2741 InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'"); 2742 2743 InstructionDesc[OpGetDefaultQueue].capabilities.push_back(CapabilityDeviceEnqueue); 2744 2745 InstructionDesc[OpCaptureEventProfilingInfo].capabilities.push_back(CapabilityDeviceEnqueue); 2746 2747 InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Event'"); 2748 InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Profiling Info'"); 2749 InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Value'"); 2750 2751 InstructionDesc[OpSetUserEventStatus].capabilities.push_back(CapabilityDeviceEnqueue); 2752 2753 InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Event'"); 2754 InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Status'"); 2755 2756 InstructionDesc[OpIsValidEvent].capabilities.push_back(CapabilityDeviceEnqueue); 2757 InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'Event'"); 2758 2759 InstructionDesc[OpCreateUserEvent].capabilities.push_back(CapabilityDeviceEnqueue); 2760 2761 InstructionDesc[OpRetainEvent].capabilities.push_back(CapabilityDeviceEnqueue); 2762 InstructionDesc[OpRetainEvent].operands.push(OperandId, "'Event'"); 2763 2764 InstructionDesc[OpReleaseEvent].capabilities.push_back(CapabilityDeviceEnqueue); 2765 InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'Event'"); 2766 2767 InstructionDesc[OpGetKernelWorkGroupSize].capabilities.push_back(CapabilityDeviceEnqueue); 2768 InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'"); 2769 InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param'"); 2770 InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Size'"); 2771 InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Align'"); 2772 2773 InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].capabilities.push_back(CapabilityDeviceEnqueue); 2774 InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'"); 2775 InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param'"); 2776 InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Size'"); 2777 InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Align'"); 2778 2779 InstructionDesc[OpGetKernelNDrangeSubGroupCount].capabilities.push_back(CapabilityDeviceEnqueue); 2780 InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'"); 2781 InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'"); 2782 InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param'"); 2783 InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Size'"); 2784 InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Align'"); 2785 2786 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].capabilities.push_back(CapabilityDeviceEnqueue); 2787 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'"); 2788 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'"); 2789 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param'"); 2790 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Size'"); 2791 InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Align'"); 2792 2793 InstructionDesc[OpEnqueueKernel].capabilities.push_back(CapabilityDeviceEnqueue); 2794 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Queue'"); 2795 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Flags'"); 2796 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'"); 2797 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'"); 2798 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'"); 2799 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'"); 2800 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'"); 2801 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'"); 2802 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'"); 2803 InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'"); 2804 InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'"); 2805 2806 InstructionDesc[OpEnqueueMarker].capabilities.push_back(CapabilityDeviceEnqueue); 2807 InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Queue'"); 2808 InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'"); 2809 InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'"); 2810 InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'"); 2811 2812 InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'"); 2813 2814 InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'"); 2815 2816 InstructionDesc[OpSubgroupAnyKHR].capabilities.push_back(CapabilitySubgroupVoteKHR); 2817 InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandScope, "'Execution'"); 2818 InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandId, "'Predicate'"); 2819 2820 InstructionDesc[OpSubgroupAllKHR].capabilities.push_back(CapabilitySubgroupVoteKHR); 2821 InstructionDesc[OpSubgroupAllKHR].operands.push(OperandScope, "'Execution'"); 2822 InstructionDesc[OpSubgroupAllKHR].operands.push(OperandId, "'Predicate'"); 2823 2824 InstructionDesc[OpSubgroupAllEqualKHR].capabilities.push_back(CapabilitySubgroupVoteKHR); 2825 InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'"); 2826 InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'"); 2827 2828 InstructionDesc[OpSubgroupReadInvocationKHR].capabilities.push_back(CapabilityGroups); 2829 InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'"); 2830 InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'"); 2831 2832 #ifdef AMD_EXTENSIONS 2833 InstructionDesc[OpGroupIAddNonUniformAMD].capabilities.push_back(CapabilityGroups); 2834 InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2835 InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2836 InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'"); 2837 2838 InstructionDesc[OpGroupFAddNonUniformAMD].capabilities.push_back(CapabilityGroups); 2839 InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2840 InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2841 InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandId, "'X'"); 2842 2843 InstructionDesc[OpGroupUMinNonUniformAMD].capabilities.push_back(CapabilityGroups); 2844 InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2845 InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2846 InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandId, "'X'"); 2847 2848 InstructionDesc[OpGroupSMinNonUniformAMD].capabilities.push_back(CapabilityGroups); 2849 InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2850 InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2851 InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandId, "X"); 2852 2853 InstructionDesc[OpGroupFMinNonUniformAMD].capabilities.push_back(CapabilityGroups); 2854 InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2855 InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2856 InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandId, "X"); 2857 2858 InstructionDesc[OpGroupUMaxNonUniformAMD].capabilities.push_back(CapabilityGroups); 2859 InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2860 InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2861 InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandId, "X"); 2862 2863 InstructionDesc[OpGroupSMaxNonUniformAMD].capabilities.push_back(CapabilityGroups); 2864 InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2865 InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2866 InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandId, "X"); 2867 2868 InstructionDesc[OpGroupFMaxNonUniformAMD].capabilities.push_back(CapabilityGroups); 2869 InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandScope, "'Execution'"); 2870 InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'"); 2871 InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandId, "X"); 2872 #endif 2873 } 2874 2875 }; // end spv namespace 2876
