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