| // |
| //Copyright (C) 2014 LunarG, Inc. |
| // |
| //All rights reserved. |
| // |
| //Redistribution and use in source and binary forms, with or without |
| //modification, are permitted provided that the following conditions |
| //are met: |
| // |
| // Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // |
| // Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following |
| // disclaimer in the documentation and/or other materials provided |
| // with the distribution. |
| // |
| // Neither the name of 3Dlabs Inc. Ltd. nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| //LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| //FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| //COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| //INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| //BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| //LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| //CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| //LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| //ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| //POSSIBILITY OF SUCH DAMAGE. |
| |
| // |
| // Author: John Kessenich, LunarG |
| // |
| |
| // |
| // 1) Programatically fill in instruction/operand information. |
| // This can be used for disassembly, printing documentation, etc. |
| // |
| // 2) Print documentation from this parameterization. |
| // |
| |
| #include "doc.h" |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <algorithm> |
| |
| namespace spv { |
| |
| // |
| // Whole set of functions that translate enumerants to their text strings for |
| // the specification (or their sanitized versions for auto-generating the |
| // spirv.h header. |
| // |
| // Also, the ceilings are declared next to these, to help keep them in sync. |
| // Ceilings should be |
| // - one more than the maximum value an enumerant takes on, for non-mask enumerants |
| // (for non-sparse enums, this is the number of enumurants) |
| // - the number of bits consumed by the set of masks |
| // (for non-sparse mask enums, this is the number of enumurants) |
| // |
| |
| const int SourceLanguageCeiling = 4; |
| |
| const char* SourceString(int source) |
| { |
| switch (source) { |
| case 0: return "Unknown"; |
| case 1: return "ESSL"; |
| case 2: return "GLSL"; |
| case 3: return "OpenCL"; |
| |
| case SourceLanguageCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int ExecutionModelCeiling = 7; |
| |
| const char* ExecutionModelString(int model) |
| { |
| switch (model) { |
| case 0: return "Vertex"; |
| case 1: return "TessellationControl"; |
| case 2: return "TessellationEvaluation"; |
| case 3: return "Geometry"; |
| case 4: return "Fragment"; |
| case 5: return "GLCompute"; |
| case 6: return "Kernel"; |
| |
| case ExecutionModelCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int AddressingModelCeiling = 3; |
| |
| const char* AddressingString(int addr) |
| { |
| switch (addr) { |
| case 0: return "Logical"; |
| case 1: return "Physical32"; |
| case 2: return "Physical64"; |
| |
| case AddressingModelCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int MemoryModelCeiling = 5; |
| |
| const char* MemoryString(int mem) |
| { |
| switch (mem) { |
| case 0: return "Simple"; |
| case 1: return "GLSL450"; |
| case 2: return "OpenCL1.2"; |
| case 3: return "OpenCL2.0"; |
| case 4: return "OpenCL2.1"; |
| |
| case MemoryModelCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int ExecutionModeCeiling = 31; |
| |
| const char* ExecutionModeString(int mode) |
| { |
| switch (mode) { |
| case 0: return "Invocations"; |
| case 1: return "SpacingEqual"; |
| case 2: return "SpacingFractionalEven"; |
| case 3: return "SpacingFractionalOdd"; |
| case 4: return "VertexOrderCw"; |
| case 5: return "VertexOrderCcw"; |
| case 6: return "PixelCenterInteger"; |
| case 7: return "OriginUpperLeft"; |
| case 8: return "EarlyFragmentTests"; |
| case 9: return "PointMode"; |
| case 10: return "Xfb"; |
| case 11: return "DepthReplacing"; |
| case 12: return "DepthAny"; |
| case 13: return "DepthGreater"; |
| case 14: return "DepthLess"; |
| case 15: return "DepthUnchanged"; |
| case 16: return "LocalSize"; |
| case 17: return "LocalSizeHint"; |
| case 18: return "InputPoints"; |
| case 19: return "InputLines"; |
| case 20: return "InputLinesAdjacency"; |
| case 21: return "InputTriangles"; |
| case 22: return "InputTrianglesAdjacency"; |
| case 23: return "InputQuads"; |
| case 24: return "InputIsolines"; |
| case 25: return "OutputVertices"; |
| case 26: return "OutputPoints"; |
| case 27: return "OutputLineStrip"; |
| case 28: return "OutputTriangleStrip"; |
| case 29: return "VecTypeHint"; |
| case 30: return "ContractionOff"; |
| |
| case ExecutionModeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int StorageClassCeiling = 11; |
| |
| const char* StorageClassString(int StorageClass) |
| { |
| switch (StorageClass) { |
| case 0: return "UniformConstant"; |
| case 1: return "Input"; |
| case 2: return "Uniform"; |
| case 3: return "Output"; |
| case 4: return "WorkgroupLocal"; |
| case 5: return "WorkgroupGlobal"; |
| case 6: return "PrivateGlobal"; |
| case 7: return "Function"; |
| case 8: return "Generic"; |
| case 9: return "Private"; |
| case 10: return "AtomicCounter"; |
| |
| case StorageClassCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int DecorationCeiling = 45; |
| |
| const char* DecorationString(int decoration) |
| { |
| switch (decoration) { |
| case 0: return "PrecisionLow"; |
| case 1: return "PrecisionMedium"; |
| case 2: return "PrecisionHigh"; |
| case 3: return "Block"; |
| case 4: return "BufferBlock"; |
| case 5: return "RowMajor"; |
| case 6: return "ColMajor"; |
| case 7: return "GLSLShared"; |
| case 8: return "GLSLStd140"; |
| case 9: return "GLSLStd430"; |
| case 10: return "GLSLPacked"; |
| case 11: return "Smooth"; |
| case 12: return "Noperspective"; |
| case 13: return "Flat"; |
| case 14: return "Patch"; |
| case 15: return "Centroid"; |
| case 16: return "Sample"; |
| case 17: return "Invariant"; |
| case 18: return "Restrict"; |
| case 19: return "Aliased"; |
| case 20: return "Volatile"; |
| case 21: return "Constant"; |
| case 22: return "Coherent"; |
| case 23: return "Nonwritable"; |
| case 24: return "Nonreadable"; |
| case 25: return "Uniform"; |
| case 26: return "NoStaticUse"; |
| case 27: return "CPacked"; |
| case 28: return "SaturatedConversion"; |
| case 29: return "Stream"; |
| case 30: return "Location"; |
| case 31: return "Component"; |
| case 32: return "Index"; |
| case 33: return "Binding"; |
| case 34: return "DescriptorSet"; |
| case 35: return "Offset"; |
| case 36: return "Alignment"; |
| case 37: return "XfbBuffer"; |
| case 38: return "Stride"; |
| case 39: return "BuiltIn"; |
| case 40: return "FuncParamAttr"; |
| case 41: return "FP Rounding Mode"; |
| case 42: return "FP Fast Math Mode"; |
| case 43: return "Linkage Attributes"; |
| case 44: return "SpecId"; |
| |
| case DecorationCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int BuiltInCeiling = 42; |
| |
| const char* BuiltInString(int builtIn) |
| { |
| switch (builtIn) { |
| case 0: return "Position"; |
| case 1: return "PointSize"; |
| case 2: return "ClipVertex"; |
| case 3: return "ClipDistance"; |
| case 4: return "CullDistance"; |
| case 5: return "VertexId"; |
| case 6: return "InstanceId"; |
| case 7: return "PrimitiveId"; |
| case 8: return "InvocationId"; |
| case 9: return "Layer"; |
| case 10: return "ViewportIndex"; |
| case 11: return "TessLevelOuter"; |
| case 12: return "TessLevelInner"; |
| case 13: return "TessCoord"; |
| case 14: return "PatchVertices"; |
| case 15: return "FragCoord"; |
| case 16: return "PointCoord"; |
| case 17: return "FrontFacing"; |
| case 18: return "SampleId"; |
| case 19: return "SamplePosition"; |
| case 20: return "SampleMask"; |
| case 21: return "FragColor"; |
| case 22: return "FragDepth"; |
| case 23: return "HelperInvocation"; |
| case 24: return "NumWorkgroups"; |
| case 25: return "WorkgroupSize"; |
| case 26: return "WorkgroupId"; |
| case 27: return "LocalInvocationId"; |
| case 28: return "GlobalInvocationId"; |
| case 29: return "LocalInvocationIndex"; |
| case 30: return "WorkDim"; |
| case 31: return "GlobalSize"; |
| case 32: return "EnqueuedWorkgroupSize"; |
| case 33: return "GlobalOffset"; |
| case 34: return "GlobalLinearId"; |
| case 35: return "WorkgroupLinearId"; |
| case 36: return "SubgroupSize"; |
| case 37: return "SubgroupMaxSize"; |
| case 38: return "NumSubgroups"; |
| case 39: return "NumEnqueuedSubgroups"; |
| case 40: return "SubgroupId"; |
| case 41: return "SubgroupLocalInvocationId"; |
| |
| case BuiltInCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int DimensionCeiling = 6; |
| |
| const char* DimensionString(int dim) |
| { |
| switch (dim) { |
| case 0: return "1D"; |
| case 1: return "2D"; |
| case 2: return "3D"; |
| case 3: return "Cube"; |
| case 4: return "Rect"; |
| case 5: return "Buffer"; |
| |
| case DimensionCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int SamplerAddressingModeCeiling = 5; |
| |
| const char* SamplerAddressingModeString(int mode) |
| { |
| switch (mode) { |
| case 0: return "None"; |
| case 1: return "ClampToEdge"; |
| case 2: return "Clamp"; |
| case 3: return "Repeat"; |
| case 4: return "RepeatMirrored"; |
| |
| case SamplerAddressingModeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int SamplerFilterModeCeiling = 2; |
| |
| const char* SamplerFilterModeString(int mode) |
| { |
| switch (mode) { |
| case 0: return "Nearest"; |
| case 1: return "Linear"; |
| |
| case SamplerFilterModeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int FPFastMathCeiling = 5; |
| |
| const char* FPFastMathString(int mode) |
| { |
| switch (mode) { |
| case 0: return "NotNaN"; |
| case 1: return "NotInf"; |
| case 2: return "NSZ"; |
| case 3: return "AllowRecip"; |
| case 4: return "Fast"; |
| |
| case FPFastMathCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int FPRoundingModeCeiling = 4; |
| |
| const char* FPRoundingModeString(int mode) |
| { |
| switch (mode) { |
| case 0: return "RTE"; |
| case 1: return "RTZ"; |
| case 2: return "RTP"; |
| case 3: return "RTN"; |
| |
| case FPRoundingModeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int LinkageTypeCeiling = 2; |
| |
| const char* LinkageTypeString(int type) |
| { |
| switch (type) { |
| case 0: return "Export"; |
| case 1: return "Import"; |
| |
| case LinkageTypeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int FuncParamAttrCeiling = 9; |
| |
| const char* FuncParamAttrString(int attr) |
| { |
| switch (attr) { |
| case 0: return "Zext"; |
| case 1: return "Sext"; |
| case 2: return "ByVal"; |
| case 3: return "Sret"; |
| case 4: return "NoAlias"; |
| case 5: return "NoCapture"; |
| case 6: return "SVM"; |
| case 7: return "NoWrite"; |
| case 8: return "NoReadWrite"; |
| |
| case FuncParamAttrCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int AccessQualifierCeiling = 3; |
| |
| const char* AccessQualifierString(int attr) |
| { |
| switch (attr) { |
| case 0: return "ReadOnly"; |
| case 1: return "WriteOnly"; |
| case 2: return "ReadWrite"; |
| |
| case AccessQualifierCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int SelectControlCeiling = 2; |
| |
| const char* SelectControlString(int cont) |
| { |
| switch (cont) { |
| case 0: return "Flatten"; |
| case 1: return "DontFlatten"; |
| |
| case SelectControlCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int LoopControlCeiling = 2; |
| |
| const char* LoopControlString(int cont) |
| { |
| switch (cont) { |
| case 0: return "Unroll"; |
| case 1: return "DontUnroll"; |
| |
| case LoopControlCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int FunctionControlCeiling = 4; |
| |
| const char* FunctionControlString(int cont) |
| { |
| switch (cont) { |
| case 0: return "Inline"; |
| case 1: return "DontInline"; |
| case 2: return "Pure"; |
| case 3: return "Const"; |
| |
| case FunctionControlCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int MemorySemanticsCeiling = 10; |
| |
| const char* MemorySemanticsString(int mem) |
| { |
| switch (mem) { |
| case 0: return "Relaxed"; |
| case 1: return "SequentiallyConsistent"; |
| case 2: return "Acquire"; |
| case 3: return "Release"; |
| |
| case 4: return "UniformMemory"; |
| case 5: return "SubgroupMemory"; |
| case 6: return "WorkgroupLocalMemory"; |
| case 7: return "WorkgroupGlobalMemory"; |
| case 8: return "AtomicCounterMemory"; |
| case 9: return "ImageMemory"; |
| |
| case MemorySemanticsCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int MemoryAccessCeiling = 2; |
| |
| const char* MemoryAccessString(int mem) |
| { |
| switch (mem) { |
| case 0: return "Volatile"; |
| case 1: return "Aligned"; |
| |
| case MemoryAccessCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int ExecutionScopeCeiling = 4; |
| |
| const char* ExecutionScopeString(int mem) |
| { |
| switch (mem) { |
| case 0: return "CrossDevice"; |
| case 1: return "Device"; |
| case 2: return "Workgroup"; |
| case 3: return "Subgroup"; |
| |
| case ExecutionScopeCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int GroupOperationCeiling = 3; |
| |
| const char* GroupOperationString(int gop) |
| { |
| |
| switch (gop) |
| { |
| case 0: return "Reduce"; |
| case 1: return "InclusiveScan"; |
| case 2: return "ExclusiveScan"; |
| |
| case GroupOperationCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int KernelEnqueueFlagsCeiling = 3; |
| |
| const char* KernelEnqueueFlagsString(int flag) |
| { |
| switch (flag) |
| { |
| case 0: return "NoWait"; |
| case 1: return "WaitKernel"; |
| case 2: return "WaitWorkGroup"; |
| |
| case KernelEnqueueFlagsCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const int KernelProfilingInfoCeiling = 1; |
| |
| const char* KernelProfilingInfoString(int info) |
| { |
| switch (info) |
| { |
| case 0: return "CmdExecTime"; |
| |
| case KernelProfilingInfoCeiling: |
| default: return "Bad"; |
| } |
| } |
| |
| const char* OpcodeString(int op) |
| { |
| switch (op) { |
| case 0: return "OpNop"; |
| case 1: return "OpSource"; |
| case 2: return "OpSourceExtension"; |
| case 3: return "OpExtension"; |
| case 4: return "OpExtInstImport"; |
| case 5: return "OpMemoryModel"; |
| case 6: return "OpEntryPoint"; |
| case 7: return "OpExecutionMode"; |
| case 8: return "OpTypeVoid"; |
| case 9: return "OpTypeBool"; |
| case 10: return "OpTypeInt"; |
| case 11: return "OpTypeFloat"; |
| case 12: return "OpTypeVector"; |
| case 13: return "OpTypeMatrix"; |
| case 14: return "OpTypeSampler"; |
| case 15: return "OpTypeFilter"; |
| case 16: return "OpTypeArray"; |
| case 17: return "OpTypeRuntimeArray"; |
| case 18: return "OpTypeStruct"; |
| case 19: return "OpTypeOpaque"; |
| case 20: return "OpTypePointer"; |
| case 21: return "OpTypeFunction"; |
| case 22: return "OpTypeEvent"; |
| case 23: return "OpTypeDeviceEvent"; |
| case 24: return "OpTypeReserveId"; |
| case 25: return "OpTypeQueue"; |
| case 26: return "OpTypePipe"; |
| case 27: return "OpConstantTrue"; |
| case 28: return "OpConstantFalse"; |
| case 29: return "OpConstant"; |
| case 30: return "OpConstantComposite"; |
| case 31: return "OpConstantSampler"; |
| case 32: return "OpConstantNullPointer"; |
| case 33: return "OpConstantNullObject"; |
| case 34: return "OpSpecConstantTrue"; |
| case 35: return "OpSpecConstantFalse"; |
| case 36: return "OpSpecConstant"; |
| case 37: return "OpSpecConstantComposite"; |
| case 38: return "OpVariable"; |
| case 39: return "OpVariableArray"; |
| case 40: return "OpFunction"; |
| case 41: return "OpFunctionParameter"; |
| case 42: return "OpFunctionEnd"; |
| case 43: return "OpFunctionCall"; |
| case 44: return "OpExtInst"; |
| case 45: return "OpUndef"; |
| case 46: return "OpLoad"; |
| case 47: return "OpStore"; |
| case 48: return "OpPhi"; |
| case 49: return "OpDecorationGroup"; |
| case 50: return "OpDecorate"; |
| case 51: return "OpMemberDecorate"; |
| case 52: return "OpGroupDecorate"; |
| case 53: return "OpGroupMemberDecorate"; |
| case 54: return "OpName"; |
| case 55: return "OpMemberName"; |
| case 56: return "OpString"; |
| case 57: return "OpLine"; |
| case 58: return "OpVectorExtractDynamic"; |
| case 59: return "OpVectorInsertDynamic"; |
| case 60: return "OpVectorShuffle"; |
| case 61: return "OpCompositeConstruct"; |
| case 62: return "OpCompositeExtract"; |
| case 63: return "OpCompositeInsert"; |
| case 64: return "OpCopyObject"; |
| case 65: return "OpCopyMemory"; |
| case 66: return "OpCopyMemorySized"; |
| case 67: return "OpSampler"; |
| case 68: return "OpTextureSample"; |
| case 69: return "OpTextureSampleDref"; |
| case 70: return "OpTextureSampleLod"; |
| case 71: return "OpTextureSampleProj"; |
| case 72: return "OpTextureSampleGrad"; |
| case 73: return "OpTextureSampleOffset"; |
| case 74: return "OpTextureSampleProjLod"; |
| case 75: return "OpTextureSampleProjGrad"; |
| case 76: return "OpTextureSampleLodOffset"; |
| case 77: return "OpTextureSampleProjOffset"; |
| case 78: return "OpTextureSampleGradOffset"; |
| case 79: return "OpTextureSampleProjLodOffset"; |
| case 80: return "OpTextureSampleProjGradOffset"; |
| case 81: return "OpTextureFetchTexelLod"; |
| case 82: return "OpTextureFetchTexelOffset"; |
| case 83: return "OpTextureFetchSample"; |
| case 84: return "OpTextureFetchTexel"; |
| case 85: return "OpTextureGather"; |
| case 86: return "OpTextureGatherOffset"; |
| case 87: return "OpTextureGatherOffsets"; |
| case 88: return "OpTextureQuerySizeLod"; |
| case 89: return "OpTextureQuerySize"; |
| case 90: return "OpTextureQueryLod"; |
| case 91: return "OpTextureQueryLevels"; |
| case 92: return "OpTextureQuerySamples"; |
| case 93: return "OpAccessChain"; |
| case 94: return "OpInBoundsAccessChain"; |
| case 95: return "OpSNegate"; |
| case 96: return "OpFNegate"; |
| case 97: return "OpNot"; |
| case 98: return "OpAny"; |
| case 99: return "OpAll"; |
| case 100: return "OpConvertFToU"; |
| case 101: return "OpConvertFToS"; |
| case 102: return "OpConvertSToF"; |
| case 103: return "OpConvertUToF"; |
| case 104: return "OpUConvert"; |
| case 105: return "OpSConvert"; |
| case 106: return "OpFConvert"; |
| case 107: return "OpConvertPtrToU"; |
| case 108: return "OpConvertUToPtr"; |
| case 109: return "OpPtrCastToGeneric"; |
| case 110: return "OpGenericCastToPtr"; |
| case 111: return "OpBitcast"; |
| case 112: return "OpTranspose"; |
| case 113: return "OpIsNan"; |
| case 114: return "OpIsInf"; |
| case 115: return "OpIsFinite"; |
| case 116: return "OpIsNormal"; |
| case 117: return "OpSignBitSet"; |
| case 118: return "OpLessOrGreater"; |
| case 119: return "OpOrdered"; |
| case 120: return "OpUnordered"; |
| case 121: return "OpArrayLength"; |
| case 122: return "OpIAdd"; |
| case 123: return "OpFAdd"; |
| case 124: return "OpISub"; |
| case 125: return "OpFSub"; |
| case 126: return "OpIMul"; |
| case 127: return "OpFMul"; |
| case 128: return "OpUDiv"; |
| case 129: return "OpSDiv"; |
| case 130: return "OpFDiv"; |
| case 131: return "OpUMod"; |
| case 132: return "OpSRem"; |
| case 133: return "OpSMod"; |
| case 134: return "OpFRem"; |
| case 135: return "OpFMod"; |
| case 136: return "OpVectorTimesScalar"; |
| case 137: return "OpMatrixTimesScalar"; |
| case 138: return "OpVectorTimesMatrix"; |
| case 139: return "OpMatrixTimesVector"; |
| case 140: return "OpMatrixTimesMatrix"; |
| case 141: return "OpOuterProduct"; |
| case 142: return "OpDot"; |
| case 143: return "OpShiftRightLogical"; |
| case 144: return "OpShiftRightArithmetic"; |
| case 145: return "OpShiftLeftLogical"; |
| case 146: return "OpLogicalOr"; |
| case 147: return "OpLogicalXor"; |
| case 148: return "OpLogicalAnd"; |
| case 149: return "OpBitwiseOr"; |
| case 150: return "OpBitwiseXor"; |
| case 151: return "OpBitwiseAnd"; |
| case 152: return "OpSelect"; |
| case 153: return "OpIEqual"; |
| case 154: return "OpFOrdEqual"; |
| case 155: return "OpFUnordEqual"; |
| case 156: return "OpINotEqual"; |
| case 157: return "OpFOrdNotEqual"; |
| case 158: return "OpFUnordNotEqual"; |
| case 159: return "OpULessThan"; |
| case 160: return "OpSLessThan"; |
| case 161: return "OpFOrdLessThan"; |
| case 162: return "OpFUnordLessThan"; |
| case 163: return "OpUGreaterThan"; |
| case 164: return "OpSGreaterThan"; |
| case 165: return "OpFOrdGreaterThan"; |
| case 166: return "OpFUnordGreaterThan"; |
| case 167: return "OpULessThanEqual"; |
| case 168: return "OpSLessThanEqual"; |
| case 169: return "OpFOrdLessThanEqual"; |
| case 170: return "OpFUnordLessThanEqual"; |
| case 171: return "OpUGreaterThanEqual"; |
| case 172: return "OpSGreaterThanEqual"; |
| case 173: return "OpFOrdGreaterThanEqual"; |
| case 174: return "OpFUnordGreaterThanEqual"; |
| case 175: return "OpDPdx"; |
| case 176: return "OpDPdy"; |
| case 177: return "OpFwidth"; |
| case 178: return "OpDPdxFine"; |
| case 179: return "OpDPdyFine"; |
| case 180: return "OpFwidthFine"; |
| case 181: return "OpDPdxCoarse"; |
| case 182: return "OpDPdyCoarse"; |
| case 183: return "OpFwidthCoarse"; |
| case 184: return "OpEmitVertex"; |
| case 185: return "OpEndPrimitive"; |
| case 186: return "OpEmitStreamVertex"; |
| case 187: return "OpEndStreamPrimitive"; |
| case 188: return "OpControlBarrier"; |
| case 189: return "OpMemoryBarrier"; |
| case 190: return "OpImagePointer"; |
| case 191: return "OpAtomicInit"; |
| case 192: return "OpAtomicLoad"; |
| case 193: return "OpAtomicStore"; |
| case 194: return "OpAtomicExchange"; |
| case 195: return "OpAtomicCompareExchange"; |
| case 196: return "OpAtomicCompareExchangeWeak"; |
| case 197: return "OpAtomicIIncrement"; |
| case 198: return "OpAtomicIDecrement"; |
| case 199: return "OpAtomicIAdd"; |
| case 200: return "OpAtomicISub"; |
| case 201: return "OpAtomicUMin"; |
| case 202: return "OpAtomicUMax"; |
| case 203: return "OpAtomicAnd"; |
| case 204: return "OpAtomicOr"; |
| case 205: return "OpAtomicXor"; |
| case 206: return "OpLoopMerge"; |
| case 207: return "OpSelectionMerge"; |
| case 208: return "OpLabel"; |
| case 209: return "OpBranch"; |
| case 210: return "OpBranchConditional"; |
| case 211: return "OpSwitch"; |
| case 212: return "OpKill"; |
| case 213: return "OpReturn"; |
| case 214: return "OpReturnValue"; |
| case 215: return "OpUnreachable"; |
| case 216: return "OpLifetimeStart"; |
| case 217: return "OpLifetimeStop"; |
| case 218: return "OpCompileFlag"; |
| case 219: return "OpAsyncGroupCopy"; |
| case 220: return "OpWaitGroupEvents"; |
| case 221: return "OpGroupAll"; |
| case 222: return "OpGroupAny"; |
| case 223: return "OpGroupBroadcast"; |
| case 224: return "OpGroupIAdd"; |
| case 225: return "OpGroupFAdd"; |
| case 226: return "OpGroupFMin"; |
| case 227: return "OpGroupUMin"; |
| case 228: return "OpGroupSMin"; |
| case 229: return "OpGroupFMax"; |
| case 230: return "OpGroupUMax"; |
| case 231: return "OpGroupSMax"; |
| case 232: return "OpGenericCastToPtrExplicit"; |
| case 233: return "OpGenericPtrMemSemantics"; |
| case 234: return "OpReadPipe"; |
| case 235: return "OpWritePipe"; |
| case 236: return "OpReservedReadPipe"; |
| case 237: return "OpReservedWritePipe"; |
| case 238: return "OpReserveReadPipePackets"; |
| case 239: return "OpReserveWritePipePackets"; |
| case 240: return "OpCommitReadPipe"; |
| case 241: return "OpCommitWritePipe"; |
| case 242: return "OpIsValidReserveId"; |
| case 243: return "OpGetNumPipePackets"; |
| case 244: return "OpGetMaxPipePackets"; |
| case 245: return "OpGroupReserveReadPipePackets"; |
| case 246: return "OpGroupReserveWritePipePackets"; |
| case 247: return "OpGroupCommitReadPipe"; |
| case 248: return "OpGroupCommitWritePipe"; |
| case 249: return "OpEnqueueMarker"; |
| case 250: return "OpEnqueueKernel"; |
| case 251: return "OpGetKernelNDrangeSubGroupCount"; |
| case 252: return "OpGetKernelNDrangeMaxSubGroupSize"; |
| case 253: return "OpGetKernelWorkGroupSize"; |
| case 254: return "OpGetKernelPreferredWorkGroupSizeMultiple"; |
| case 255: return "OpRetainEvent"; |
| case 256: return "OpReleaseEvent"; |
| case 257: return "OpCreateUserEvent"; |
| case 258: return "OpIsValidEvent"; |
| case 259: return "OpSetUserEventStatus"; |
| case 260: return "OpCaptureEventProfilingInfo"; |
| case 261: return "OpGetDefaultQueue"; |
| case 262: return "OpBuildNDRange"; |
| case 263: return "OpSatConvertSToU"; |
| case 264: return "OpSatConvertUToS"; |
| case 265: return "OpAtomicIMin"; |
| case 266: return "OpAtomicIMax"; |
| |
| case OpcodeCeiling: |
| default: |
| return "Bad"; |
| } |
| } |
| |
| // The set of objects that hold all the instruction/operand |
| // parameterization information. |
| InstructionParameters InstructionDesc[OpcodeCeiling]; |
| OperandParameters ExecutionModeOperands[ExecutionModeCeiling]; |
| OperandParameters DecorationOperands[DecorationCeiling]; |
| |
| EnumDefinition OperandClassParams[OperandCount]; |
| EnumParameters ExecutionModelParams[ExecutionModelCeiling]; |
| EnumParameters AddressingParams[AddressingModelCeiling]; |
| EnumParameters MemoryParams[MemoryModelCeiling]; |
| EnumParameters ExecutionModeParams[ExecutionModeCeiling]; |
| EnumParameters StorageParams[StorageClassCeiling]; |
| EnumParameters SamplerAddressingModeParams[SamplerAddressingModeCeiling]; |
| EnumParameters SamplerFilterModeParams[SamplerFilterModeCeiling]; |
| EnumParameters FPFastMathParams[FPFastMathCeiling]; |
| EnumParameters FPRoundingModeParams[FPRoundingModeCeiling]; |
| EnumParameters LinkageTypeParams[LinkageTypeCeiling]; |
| EnumParameters DecorationParams[DecorationCeiling]; |
| EnumParameters BuiltInParams[BuiltInCeiling]; |
| EnumParameters DimensionalityParams[DimensionCeiling]; |
| EnumParameters FuncParamAttrParams[FuncParamAttrCeiling]; |
| EnumParameters AccessQualifierParams[AccessQualifierCeiling]; |
| EnumParameters GroupOperationParams[GroupOperationCeiling]; |
| EnumParameters LoopControlParams[FunctionControlCeiling]; |
| EnumParameters SelectionControlParams[SelectControlCeiling]; |
| EnumParameters FunctionControlParams[FunctionControlCeiling]; |
| EnumParameters MemorySemanticsParams[MemorySemanticsCeiling]; |
| EnumParameters MemoryAccessParams[MemoryAccessCeiling]; |
| EnumParameters ExecutionScopeParams[ExecutionScopeCeiling]; |
| EnumParameters KernelEnqueueFlagsParams[KernelEnqueueFlagsCeiling]; |
| EnumParameters KernelProfilingInfoParams[KernelProfilingInfoCeiling]; |
| |
| // Set up all the parameterizing descriptions of the opcodes, operands, etc. |
| void Parameterize() |
| { |
| static bool initialized = false; |
| |
| // only do this once. |
| if (initialized) |
| return; |
| |
| initialized = true; |
| |
| // Exceptions to having a result <id> and a resulting type <id>. |
| // (Everything is initialized to have both). |
| |
| InstructionDesc[OpNop].setResultAndType(false, false); |
| InstructionDesc[OpSource].setResultAndType(false, false); |
| InstructionDesc[OpSourceExtension].setResultAndType(false, false); |
| InstructionDesc[OpExtension].setResultAndType(false, false); |
| InstructionDesc[OpExtInstImport].setResultAndType(true, false); |
| InstructionDesc[OpMemoryModel].setResultAndType(false, false); |
| InstructionDesc[OpEntryPoint].setResultAndType(false, false); |
| InstructionDesc[OpExecutionMode].setResultAndType(false, false); |
| InstructionDesc[OpTypeVoid].setResultAndType(true, false); |
| InstructionDesc[OpTypeBool].setResultAndType(true, false); |
| InstructionDesc[OpTypeInt].setResultAndType(true, false); |
| InstructionDesc[OpTypeFloat].setResultAndType(true, false); |
| InstructionDesc[OpTypeVector].setResultAndType(true, false); |
| InstructionDesc[OpTypeMatrix].setResultAndType(true, false); |
| InstructionDesc[OpTypeSampler].setResultAndType(true, false); |
| InstructionDesc[OpTypeFilter].setResultAndType(true, false); |
| InstructionDesc[OpTypeArray].setResultAndType(true, false); |
| InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false); |
| InstructionDesc[OpTypeStruct].setResultAndType(true, false); |
| InstructionDesc[OpTypeOpaque].setResultAndType(true, false); |
| InstructionDesc[OpTypePointer].setResultAndType(true, false); |
| InstructionDesc[OpTypeFunction].setResultAndType(true, false); |
| InstructionDesc[OpTypeEvent].setResultAndType(true, false); |
| InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false); |
| InstructionDesc[OpTypeReserveId].setResultAndType(true, false); |
| InstructionDesc[OpTypeQueue].setResultAndType(true, false); |
| InstructionDesc[OpTypePipe].setResultAndType(true, false); |
| InstructionDesc[OpFunctionEnd].setResultAndType(false, false); |
| InstructionDesc[OpStore].setResultAndType(false, false); |
| InstructionDesc[OpDecorationGroup].setResultAndType(true, false); |
| InstructionDesc[OpDecorate].setResultAndType(false, false); |
| InstructionDesc[OpMemberDecorate].setResultAndType(false, false); |
| InstructionDesc[OpGroupDecorate].setResultAndType(false, false); |
| InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false); |
| InstructionDesc[OpName].setResultAndType(false, false); |
| InstructionDesc[OpMemberName].setResultAndType(false, false); |
| InstructionDesc[OpString].setResultAndType(true, false); |
| InstructionDesc[OpLine].setResultAndType(false, false); |
| InstructionDesc[OpCopyMemory].setResultAndType(false, false); |
| InstructionDesc[OpCopyMemorySized].setResultAndType(false, false); |
| InstructionDesc[OpEmitVertex].setResultAndType(false, false); |
| InstructionDesc[OpEndPrimitive].setResultAndType(false, false); |
| InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false); |
| InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false); |
| InstructionDesc[OpControlBarrier].setResultAndType(false, false); |
| InstructionDesc[OpMemoryBarrier].setResultAndType(false, false); |
| InstructionDesc[OpAtomicInit].setResultAndType(false, false); |
| InstructionDesc[OpAtomicStore].setResultAndType(false, false); |
| InstructionDesc[OpLoopMerge].setResultAndType(false, false); |
| InstructionDesc[OpSelectionMerge].setResultAndType(false, false); |
| InstructionDesc[OpLabel].setResultAndType(true, false); |
| InstructionDesc[OpBranch].setResultAndType(false, false); |
| InstructionDesc[OpBranchConditional].setResultAndType(false, false); |
| InstructionDesc[OpSwitch].setResultAndType(false, false); |
| InstructionDesc[OpKill].setResultAndType(false, false); |
| InstructionDesc[OpReturn].setResultAndType(false, false); |
| InstructionDesc[OpReturnValue].setResultAndType(false, false); |
| InstructionDesc[OpUnreachable].setResultAndType(false, false); |
| InstructionDesc[OpLifetimeStart].setResultAndType(false, false); |
| InstructionDesc[OpLifetimeStop].setResultAndType(false, false); |
| InstructionDesc[OpCompileFlag].setResultAndType(false, false); |
| InstructionDesc[OpCommitReadPipe].setResultAndType(false, false); |
| InstructionDesc[OpCommitWritePipe].setResultAndType(false, false); |
| InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false); |
| InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false); |
| InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false); |
| InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false); |
| InstructionDesc[OpRetainEvent].setResultAndType(false, false); |
| InstructionDesc[OpReleaseEvent].setResultAndType(false, false); |
| |
| // Specific additional context-dependent operands |
| |
| ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "Number of invocations"); |
| |
| ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'"); |
| ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'"); |
| ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'"); |
| |
| ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'"); |
| ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'"); |
| ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'"); |
| |
| ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "Vertex count"); |
| ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandId, "Vector type"); |
| |
| DecorationOperands[DecorationStream].push(OperandLiteralNumber, "Stream number"); |
| DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "Location"); |
| DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "Component within a vector"); |
| DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "Index"); |
| DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "Binding point"); |
| DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "Descriptor set"); |
| DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "Byte offset"); |
| DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "Declared alignment"); |
| DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "XFB Buffer number"); |
| DecorationOperands[DecorationStride].push(OperandLiteralNumber, "Stride"); |
| DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>"); |
| DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "floating-point rounding mode"); |
| DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "fast-math mode"); |
| DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "name"); |
| DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "linkage type"); |
| DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "function parameter attribute"); |
| DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "Specialization Constant ID"); |
| |
| OperandClassParams[OperandSource].set(SourceLanguageCeiling, SourceString, 0); |
| OperandClassParams[OperandExecutionModel].set(ExecutionModelCeiling, ExecutionModelString, ExecutionModelParams); |
| OperandClassParams[OperandAddressing].set(AddressingModelCeiling, AddressingString, AddressingParams); |
| OperandClassParams[OperandMemory].set(MemoryModelCeiling, MemoryString, MemoryParams); |
| OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams); |
| OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands); |
| OperandClassParams[OperandStorage].set(StorageClassCeiling, StorageClassString, StorageParams); |
| OperandClassParams[OperandDimensionality].set(DimensionCeiling, DimensionString, DimensionalityParams); |
| OperandClassParams[OperandSamplerAddressingMode].set(SamplerAddressingModeCeiling, SamplerAddressingModeString, SamplerAddressingModeParams); |
| OperandClassParams[OperandSamplerFilterMode].set(SamplerFilterModeCeiling, SamplerFilterModeString, SamplerFilterModeParams); |
| OperandClassParams[OperandFPFastMath].set(FPFastMathCeiling, FPFastMathString, FPFastMathParams, true); |
| OperandClassParams[OperandFPRoundingMode].set(FPRoundingModeCeiling, FPRoundingModeString, FPRoundingModeParams); |
| OperandClassParams[OperandLinkageType].set(LinkageTypeCeiling, LinkageTypeString, LinkageTypeParams); |
| OperandClassParams[OperandFuncParamAttr].set(FuncParamAttrCeiling, FuncParamAttrString, FuncParamAttrParams); |
| OperandClassParams[OperandAccessQualifier].set(AccessQualifierCeiling, AccessQualifierString, AccessQualifierParams); |
| OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams); |
| OperandClassParams[OperandDecoration].setOperands(DecorationOperands); |
| OperandClassParams[OperandBuiltIn].set(BuiltInCeiling, BuiltInString, BuiltInParams); |
| OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true); |
| OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true); |
| OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true); |
| OperandClassParams[OperandMemorySemantics].set(MemorySemanticsCeiling, MemorySemanticsString, MemorySemanticsParams, true); |
| OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true); |
| OperandClassParams[OperandExecutionScope].set(ExecutionScopeCeiling, ExecutionScopeString, ExecutionScopeParams); |
| OperandClassParams[OperandGroupOperation].set(GroupOperationCeiling, GroupOperationString, GroupOperationParams); |
| OperandClassParams[OperandKernelEnqueueFlags].set(KernelEnqueueFlagsCeiling, KernelEnqueueFlagsString, KernelEnqueueFlagsParams); |
| OperandClassParams[OperandKernelProfilingInfo].set(KernelProfilingInfoCeiling, KernelProfilingInfoString, KernelProfilingInfoParams, true); |
| OperandClassParams[OperandOpcode].set(OpcodeCeiling, OpcodeString, 0); |
| |
| AddressingParams[AddressingModelPhysical32].caps.push_back(CapAddr); |
| AddressingParams[AddressingModelPhysical64].caps.push_back(CapAddr); |
| |
| MemoryParams[MemoryModelSimple].caps.push_back(CapShader); |
| MemoryParams[MemoryModelGLSL450].caps.push_back(CapShader); |
| MemoryParams[MemoryModelOpenCL12].caps.push_back(CapKernel); |
| MemoryParams[MemoryModelOpenCL20].caps.push_back(CapKernel); |
| MemoryParams[MemoryModelOpenCL21].caps.push_back(CapKernel); |
| |
| ExecutionModelParams[ExecutionModelVertex].caps.push_back(CapShader); |
| ExecutionModelParams[ExecutionModelTessellationControl].caps.push_back(CapTess); |
| ExecutionModelParams[ExecutionModelTessellationEvaluation].caps.push_back(CapTess); |
| ExecutionModelParams[ExecutionModelGeometry].caps.push_back(CapGeom); |
| ExecutionModelParams[ExecutionModelFragment].caps.push_back(CapShader); |
| ExecutionModelParams[ExecutionModelGLCompute].caps.push_back(CapShader); |
| ExecutionModelParams[ExecutionModelKernel].caps.push_back(CapKernel); |
| |
| // Storage capabilites |
| StorageParams[StorageClassInput].caps.push_back(CapShader); |
| StorageParams[StorageClassUniform].caps.push_back(CapShader); |
| StorageParams[StorageClassOutput].caps.push_back(CapShader); |
| StorageParams[StorageClassPrivateGlobal].caps.push_back(CapShader); |
| StorageParams[StorageClassFunction].caps.push_back(CapShader); |
| StorageParams[StorageClassGeneric].caps.push_back(CapKernel); |
| StorageParams[StorageClassPrivate].caps.push_back(CapKernel); |
| StorageParams[StorageClassAtomicCounter].caps.push_back(CapShader); |
| |
| // Sampler Filter & Addressing mode capabilities |
| SamplerAddressingModeParams[SamplerAddressingModeNone].caps.push_back(CapKernel); |
| SamplerAddressingModeParams[SamplerAddressingModeClampToEdge].caps.push_back(CapKernel); |
| SamplerAddressingModeParams[SamplerAddressingModeClamp].caps.push_back(CapKernel); |
| SamplerAddressingModeParams[SamplerAddressingModeRepeat].caps.push_back(CapKernel); |
| SamplerAddressingModeParams[SamplerAddressingModeRepeatMirrored].caps.push_back(CapKernel); |
| |
| SamplerFilterModeParams[SamplerFilterModeNearest].caps.push_back(CapKernel); |
| SamplerFilterModeParams[SamplerFilterModeLinear].caps.push_back(CapKernel); |
| |
| // fast math flags capabilities |
| for (int i = 0; i < FPFastMathCeiling; ++i) { |
| FPFastMathParams[i].caps.push_back(CapKernel); |
| } |
| |
| // fp rounding mode capabilities |
| for (int i = 0; i < FPRoundingModeCeiling; ++i) { |
| FPRoundingModeParams[i].caps.push_back(CapKernel); |
| } |
| |
| // linkage types |
| for (int i = 0; i < LinkageTypeCeiling; ++i) { |
| LinkageTypeParams[i].caps.push_back(CapLink); |
| } |
| |
| // function argument types |
| for (int i = 0; i < FuncParamAttrCeiling; ++i) { |
| FuncParamAttrParams[i].caps.push_back(CapKernel); |
| } |
| |
| // function argument types |
| for (int i = 0; i < AccessQualifierCeiling; ++i) { |
| AccessQualifierParams[i].caps.push_back(CapKernel); |
| } |
| |
| ExecutionModeParams[ExecutionModeInvocations].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeSpacingEqual].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeSpacingFractionalEven].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeSpacingFractionalOdd].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeVertexOrderCw].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeVertexOrderCcw].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModePixelCenterInteger].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeOriginUpperLeft].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeEarlyFragmentTests].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModePointMode].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeXfb].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeDepthReplacing].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeDepthAny].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeDepthGreater].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeDepthLess].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeDepthUnchanged].caps.push_back(CapShader); |
| ExecutionModeParams[ExecutionModeLocalSizeHint].caps.push_back(CapKernel); |
| ExecutionModeParams[ExecutionModeInputPoints].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeInputLines].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeInputLinesAdjacency].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeInputTriangles].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeInputTriangles].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeInputTrianglesAdjacency].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeInputQuads].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeInputIsolines].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeOutputVertices].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeOutputVertices].caps.push_back(CapTess); |
| ExecutionModeParams[ExecutionModeOutputPoints].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeOutputLineStrip].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeOutputTriangleStrip].caps.push_back(CapGeom); |
| ExecutionModeParams[ExecutionModeVecTypeHint].caps.push_back(CapKernel); |
| ExecutionModeParams[ExecutionModeContractionOff].caps.push_back(CapKernel); |
| |
| DecorationParams[DecorationPrecisionLow].caps.push_back(CapShader); |
| DecorationParams[DecorationPrecisionMedium].caps.push_back(CapShader); |
| DecorationParams[DecorationPrecisionHigh].caps.push_back(CapShader); |
| DecorationParams[DecorationBlock].caps.push_back(CapShader); |
| DecorationParams[DecorationBufferBlock].caps.push_back(CapShader); |
| DecorationParams[DecorationRowMajor].caps.push_back(CapMatrix); |
| DecorationParams[DecorationColMajor].caps.push_back(CapMatrix); |
| DecorationParams[DecorationGLSLShared].caps.push_back(CapShader); |
| DecorationParams[DecorationGLSLStd140].caps.push_back(CapShader); |
| DecorationParams[DecorationGLSLStd430].caps.push_back(CapShader); |
| DecorationParams[DecorationGLSLPacked].caps.push_back(CapShader); |
| DecorationParams[DecorationSmooth].caps.push_back(CapShader); |
| DecorationParams[DecorationNoperspective].caps.push_back(CapShader); |
| DecorationParams[DecorationFlat].caps.push_back(CapShader); |
| DecorationParams[DecorationPatch].caps.push_back(CapTess); |
| DecorationParams[DecorationCentroid].caps.push_back(CapShader); |
| DecorationParams[DecorationSample].caps.push_back(CapShader); |
| DecorationParams[DecorationInvariant].caps.push_back(CapShader); |
| DecorationParams[DecorationConstant].caps.push_back(CapKernel); |
| DecorationParams[DecorationUniform].caps.push_back(CapShader); |
| DecorationParams[DecorationCPacked].caps.push_back(CapKernel); |
| DecorationParams[DecorationSaturatedConversion].caps.push_back(CapKernel); |
| DecorationParams[DecorationStream].caps.push_back(CapGeom); |
| DecorationParams[DecorationLocation].caps.push_back(CapShader); |
| DecorationParams[DecorationComponent].caps.push_back(CapShader); |
| DecorationParams[DecorationIndex].caps.push_back(CapShader); |
| DecorationParams[DecorationBinding].caps.push_back(CapShader); |
| DecorationParams[DecorationDescriptorSet].caps.push_back(CapShader); |
| DecorationParams[DecorationXfbBuffer].caps.push_back(CapShader); |
| DecorationParams[DecorationStride].caps.push_back(CapShader); |
| DecorationParams[DecorationBuiltIn].caps.push_back(CapShader); |
| DecorationParams[DecorationFuncParamAttr].caps.push_back(CapKernel); |
| DecorationParams[DecorationFPRoundingMode].caps.push_back(CapKernel); |
| DecorationParams[DecorationFPFastMathMode].caps.push_back(CapKernel); |
| DecorationParams[DecorationLinkageAttributes].caps.push_back(CapLink); |
| DecorationParams[DecorationSpecId].caps.push_back(CapShader); |
| |
| BuiltInParams[BuiltInPosition].caps.push_back(CapShader); |
| BuiltInParams[BuiltInPointSize].caps.push_back(CapShader); |
| BuiltInParams[BuiltInClipVertex].caps.push_back(CapShader); |
| BuiltInParams[BuiltInClipDistance].caps.push_back(CapShader); |
| BuiltInParams[BuiltInCullDistance].caps.push_back(CapShader); |
| BuiltInParams[BuiltInVertexId].caps.push_back(CapShader); |
| BuiltInParams[BuiltInInstanceId].caps.push_back(CapShader); |
| BuiltInParams[BuiltInPrimitiveId].caps.push_back(CapGeom); |
| BuiltInParams[BuiltInPrimitiveId].caps.push_back(CapTess); |
| BuiltInParams[BuiltInInvocationId].caps.push_back(CapGeom); |
| BuiltInParams[BuiltInInvocationId].caps.push_back(CapTess); |
| BuiltInParams[BuiltInLayer].caps.push_back(CapGeom); |
| BuiltInParams[BuiltInViewportIndex].caps.push_back(CapGeom); |
| BuiltInParams[BuiltInTessLevelOuter].caps.push_back(CapTess); |
| BuiltInParams[BuiltInTessLevelInner].caps.push_back(CapTess); |
| BuiltInParams[BuiltInTessCoord].caps.push_back(CapTess); |
| BuiltInParams[BuiltInPatchVertices].caps.push_back(CapTess); |
| BuiltInParams[BuiltInFragCoord].caps.push_back(CapShader); |
| BuiltInParams[BuiltInPointCoord].caps.push_back(CapShader); |
| BuiltInParams[BuiltInFrontFacing].caps.push_back(CapShader); |
| BuiltInParams[BuiltInSampleId].caps.push_back(CapShader); |
| BuiltInParams[BuiltInSamplePosition].caps.push_back(CapShader); |
| BuiltInParams[BuiltInSampleMask].caps.push_back(CapShader); |
| BuiltInParams[BuiltInFragColor].caps.push_back(CapShader); |
| BuiltInParams[BuiltInFragDepth].caps.push_back(CapShader); |
| BuiltInParams[BuiltInHelperInvocation].caps.push_back(CapShader); |
| BuiltInParams[BuiltInLocalInvocationIndex].caps.push_back(CapShader); |
| BuiltInParams[BuiltInWorkDim].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInGlobalSize].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInEnqueuedWorkgroupSize].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInGlobalOffset].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInGlobalLinearId].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInWorkgroupLinearId].caps.push_back(CapKernel); |
| |
| BuiltInParams[BuiltInSubgroupSize].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInSubgroupMaxSize].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInNumSubgroups].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInNumEnqueuedSubgroups].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInSubgroupId].caps.push_back(CapKernel); |
| BuiltInParams[BuiltInSubgroupLocalInvocationId].caps.push_back(CapKernel); |
| |
| DimensionalityParams[DimCube].caps.push_back(CapShader); |
| DimensionalityParams[DimRect].caps.push_back(CapShader); |
| |
| // Group Operations |
| for (int i = 0; i < GroupOperationCeiling; ++i) { |
| GroupOperationParams[i].caps.push_back(CapKernel); |
| } |
| |
| // Enqueue flags |
| for (int i = 0; i < KernelEnqueueFlagsCeiling; ++i) { |
| KernelEnqueueFlagsParams[i].caps.push_back(CapKernel); |
| } |
| |
| // Profiling info |
| KernelProfilingInfoParams[0].caps.push_back(CapKernel); |
| |
| // set name of operator, an initial set of <id> style operands, and the description |
| |
| InstructionDesc[OpSource].operands.push(OperandSource, ""); |
| InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'"); |
| |
| InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'"); |
| |
| InstructionDesc[OpName].operands.push(OperandId, "'Target'"); |
| InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'"); |
| |
| InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'"); |
| InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'"); |
| InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'"); |
| |
| InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'"); |
| |
| InstructionDesc[OpLine].operands.push(OperandId, "'Target'"); |
| InstructionDesc[OpLine].operands.push(OperandId, "'File'"); |
| InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'"); |
| InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'"); |
| |
| InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'"); |
| |
| InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'"); |
| |
| InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, ""); |
| InstructionDesc[OpMemoryModel].operands.push(OperandMemory, ""); |
| |
| InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, ""); |
| InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'"); |
| |
| InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'"); |
| InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'"); |
| InstructionDesc[OpExecutionMode].operands.push(OperandVariableLiterals, "See <<Execution Mode,Execution Mode>>"); |
| |
| InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'"); |
| InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'"); |
| |
| InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'"); |
| |
| InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component type'"); |
| InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component count'"); |
| |
| InstructionDesc[OpTypeMatrix].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column type'"); |
| InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column count'"); |
| |
| InstructionDesc[OpTypeSampler].operands.push(OperandId, "'Sampled Type'"); |
| InstructionDesc[OpTypeSampler].operands.push(OperandDimensionality, ""); |
| InstructionDesc[OpTypeSampler].operands.push(OperandLiteralNumber, "'Content'"); |
| InstructionDesc[OpTypeSampler].operands.push(OperandLiteralNumber, "'Arrayed'"); |
| InstructionDesc[OpTypeSampler].operands.push(OperandLiteralNumber, "'Compare'"); |
| InstructionDesc[OpTypeSampler].operands.push(OperandLiteralNumber, "'MS'"); |
| InstructionDesc[OpTypeSampler].operands.push(OperandOptionalId, "'Qualifier'"); |
| |
| InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element type'"); |
| InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'"); |
| |
| InstructionDesc[OpTypeRuntimeArray].capabilities.push_back(CapShader); |
| InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element type'"); |
| |
| InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n..."); |
| |
| InstructionDesc[OpTypeOpaque].capabilities.push_back(CapKernel); |
| InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type."); |
| |
| InstructionDesc[OpTypePointer].operands.push(OperandStorage, ""); |
| InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'"); |
| |
| InstructionDesc[OpTypeEvent].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpTypeDeviceEvent].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpTypeReserveId].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpTypeQueue].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpTypePipe].operands.push(OperandId, "'Type'"); |
| InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'"); |
| InstructionDesc[OpTypePipe].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'"); |
| InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n..."); |
| |
| InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'"); |
| |
| InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'"); |
| |
| InstructionDesc[OpConstantNullPointer].capabilities.push_back(CapAddr); |
| |
| InstructionDesc[OpConstantNullObject].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpConstantSampler].capabilities.push_back(CapKernel); |
| InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Mode'"); |
| InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'"); |
| InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Filter'"); |
| |
| InstructionDesc[OpSpecConstantTrue].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpSpecConstantFalse].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'"); |
| InstructionDesc[OpSpecConstant].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'"); |
| InstructionDesc[OpSpecConstantComposite].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpVariable].operands.push(OperandStorage, ""); |
| InstructionDesc[OpVariable].operands.push(OperandOptionalId, "'Initializer'"); |
| |
| InstructionDesc[OpVariableArray].operands.push(OperandStorage, ""); |
| InstructionDesc[OpVariableArray].operands.push(OperandId, "'N'"); |
| InstructionDesc[OpVariableArray].capabilities.push_back(CapAddr); |
| |
| InstructionDesc[OpFunction].operands.push(OperandFunction, ""); |
| InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'"); |
| |
| InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'"); |
| InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n..."); |
| |
| InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'"); |
| InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'"); |
| InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n..."); |
| |
| InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpLoad].operands.push(OperandVariableLiterals, "'Memory Access'"); |
| |
| InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpStore].operands.push(OperandId, "'Object'"); |
| InstructionDesc[OpStore].operands.push(OperandVariableLiterals, "'Memory Access'"); |
| |
| InstructionDesc[OpPhi].operands.push(OperandVariableIds, ""); |
| |
| InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'"); |
| InstructionDesc[OpDecorate].operands.push(OperandDecoration, ""); |
| InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>."); |
| |
| InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure type'"); |
| InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'"); |
| InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, ""); |
| InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>."); |
| |
| InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration group'"); |
| InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Target', 'Target', ..."); |
| |
| InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration group'"); |
| InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIds, "'Target', 'Target', ..."); |
| |
| InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'"); |
| InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'"); |
| |
| InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'"); |
| InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'"); |
| InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'"); |
| |
| InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'"); |
| InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'"); |
| InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'"); |
| |
| InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'"); |
| |
| InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'"); |
| InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'"); |
| |
| InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'"); |
| InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'"); |
| InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'"); |
| |
| InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'"); |
| |
| InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'"); |
| InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'"); |
| InstructionDesc[OpCopyMemory].operands.push(OperandVariableLiterals, "'Memory Access'"); |
| |
| InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'"); |
| InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'"); |
| InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'"); |
| InstructionDesc[OpCopyMemorySized].operands.push(OperandVariableLiterals, "'Memory Access'"); |
| |
| InstructionDesc[OpCopyMemorySized].capabilities.push_back(CapAddr); |
| |
| InstructionDesc[OpSampler].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpSampler].operands.push(OperandId, "'Filter'"); |
| |
| InstructionDesc[OpTextureSample].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSample].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSample].operands.push(OperandOptionalId, "['Bias']"); |
| InstructionDesc[OpTextureSample].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleDref].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleDref].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleDref].operands.push(OperandId, "'D~ref~'"); |
| InstructionDesc[OpTextureSampleDref].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleLod].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleLod].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleLod].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureSampleLod].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProj].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProj].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProj].operands.push(OperandOptionalId, "['Bias']"); |
| InstructionDesc[OpTextureSampleProj].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleGrad].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleGrad].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleGrad].operands.push(OperandId, "'dx'"); |
| InstructionDesc[OpTextureSampleGrad].operands.push(OperandId, "'dy'"); |
| InstructionDesc[OpTextureSampleGrad].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleOffset].operands.push(OperandOptionalId, "['Bias']"); |
| InstructionDesc[OpTextureSampleOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProjLod].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProjLod].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProjLod].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureSampleProjLod].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProjGrad].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProjGrad].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProjGrad].operands.push(OperandId, "'dx'"); |
| InstructionDesc[OpTextureSampleProjGrad].operands.push(OperandId, "'dy'"); |
| InstructionDesc[OpTextureSampleProjGrad].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleLodOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleLodOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleLodOffset].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureSampleLodOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleLodOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProjOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProjOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProjOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleProjOffset].operands.push(OperandOptionalId, "['Bias']"); |
| InstructionDesc[OpTextureSampleProjOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleGradOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleGradOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleGradOffset].operands.push(OperandId, "'dx'"); |
| InstructionDesc[OpTextureSampleGradOffset].operands.push(OperandId, "'dy'"); |
| InstructionDesc[OpTextureSampleGradOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleGradOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProjLodOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProjLodOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProjLodOffset].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureSampleProjLodOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleProjLodOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureSampleProjGradOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureSampleProjGradOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureSampleProjGradOffset].operands.push(OperandId, "'dx'"); |
| InstructionDesc[OpTextureSampleProjGradOffset].operands.push(OperandId, "'dy'"); |
| InstructionDesc[OpTextureSampleProjGradOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureSampleProjGradOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureFetchTexelLod].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureFetchTexelLod].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureFetchTexelLod].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureFetchTexelLod].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureFetchTexelOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureFetchTexelOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureFetchTexelOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureFetchTexelOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureFetchSample].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureFetchSample].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureFetchSample].operands.push(OperandId, "'Sample'"); |
| InstructionDesc[OpTextureFetchSample].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureFetchTexel].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureFetchTexel].operands.push(OperandId, "'Element'"); |
| InstructionDesc[OpTextureFetchTexel].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureGather].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureGather].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureGather].operands.push(OperandId, "'Component'"); |
| InstructionDesc[OpTextureGather].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureGatherOffset].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureGatherOffset].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureGatherOffset].operands.push(OperandId, "'Component'"); |
| InstructionDesc[OpTextureGatherOffset].operands.push(OperandId, "'Offset'"); |
| InstructionDesc[OpTextureGatherOffset].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureGatherOffsets].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureGatherOffsets].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureGatherOffsets].operands.push(OperandId, "'Component'"); |
| InstructionDesc[OpTextureGatherOffsets].operands.push(OperandId, "'Offsets'"); |
| InstructionDesc[OpTextureGatherOffsets].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureQuerySizeLod].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureQuerySizeLod].operands.push(OperandId, "'Level of Detail'"); |
| InstructionDesc[OpTextureQuerySizeLod].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureQuerySize].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureQuerySize].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureQueryLod].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureQueryLod].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpTextureQueryLod].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureQueryLevels].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureQueryLevels].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpTextureQuerySamples].operands.push(OperandId, "'Sampler'"); |
| InstructionDesc[OpTextureQuerySamples].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'"); |
| InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'"); |
| |
| InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'"); |
| InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'"); |
| |
| InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'"); |
| |
| InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'"); |
| |
| InstructionDesc[OpNot].operands.push(OperandId, "'Operand'"); |
| |
| InstructionDesc[OpAny].operands.push(OperandId, "'Vector'"); |
| |
| InstructionDesc[OpAll].operands.push(OperandId, "'Vector'"); |
| |
| InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'"); |
| |
| InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'"); |
| |
| InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'"); |
| |
| InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned value'"); |
| |
| InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned value'"); |
| |
| InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'"); |
| |
| InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'"); |
| |
| InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'"); |
| InstructionDesc[OpSatConvertSToU].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'"); |
| InstructionDesc[OpSatConvertUToS].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpConvertPtrToU].capabilities.push_back(CapAddr); |
| |
| InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer value'"); |
| InstructionDesc[OpConvertUToPtr].capabilities.push_back(CapAddr); |
| |
| InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Source pointer'"); |
| InstructionDesc[OpPtrCastToGeneric].capabilities.push_back(CapKernel); |
| |
| |
| InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Source pointer'"); |
| InstructionDesc[OpGenericCastToPtr].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Source pointer'"); |
| InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'storage'"); |
| InstructionDesc[OpGenericCastToPtrExplicit].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'ptr'"); |
| InstructionDesc[OpGenericPtrMemSemantics].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'"); |
| |
| InstructionDesc[OpTranspose].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'"); |
| |
| InstructionDesc[OpIsNan].operands.push(OperandId, "'x'"); |
| |
| InstructionDesc[OpIsInf].operands.push(OperandId, "'x'"); |
| |
| InstructionDesc[OpIsFinite].capabilities.push_back(CapKernel); |
| InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'"); |
| |
| InstructionDesc[OpIsNormal].capabilities.push_back(CapKernel); |
| InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'"); |
| |
| InstructionDesc[OpSignBitSet].capabilities.push_back(CapKernel); |
| InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'"); |
| |
| InstructionDesc[OpLessOrGreater].capabilities.push_back(CapKernel); |
| InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'"); |
| InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'"); |
| |
| InstructionDesc[OpOrdered].capabilities.push_back(CapKernel); |
| InstructionDesc[OpOrdered].operands.push(OperandId, "'x'"); |
| InstructionDesc[OpOrdered].operands.push(OperandId, "'y'"); |
| |
| InstructionDesc[OpUnordered].capabilities.push_back(CapKernel); |
| InstructionDesc[OpUnordered].operands.push(OperandId, "'x'"); |
| InstructionDesc[OpUnordered].operands.push(OperandId, "'y'"); |
| |
| InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'"); |
| InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'"); |
| InstructionDesc[OpArrayLength].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'"); |
| InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'"); |
| |
| InstructionDesc[OpMatrixTimesScalar].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'"); |
| InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'"); |
| |
| InstructionDesc[OpVectorTimesMatrix].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'"); |
| InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'"); |
| |
| InstructionDesc[OpMatrixTimesVector].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'"); |
| InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'"); |
| |
| InstructionDesc[OpMatrixTimesMatrix].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'"); |
| InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'"); |
| |
| InstructionDesc[OpOuterProduct].capabilities.push_back(CapMatrix); |
| InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 1'"); |
| InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 2'"); |
| |
| InstructionDesc[OpDot].operands.push(OperandId, "'Vector 1'"); |
| InstructionDesc[OpDot].operands.push(OperandId, "'Vector 2'"); |
| |
| InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpLogicalXor].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpLogicalXor].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'"); |
| InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'"); |
| InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'"); |
| |
| InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'"); |
| InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'"); |
| |
| InstructionDesc[OpDPdx].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdx].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpDPdy].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdy].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpFwidth].capabilities.push_back(CapShader); |
| InstructionDesc[OpFwidth].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpDPdxFine].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpDPdyFine].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpFwidthFine].capabilities.push_back(CapShader); |
| InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpDPdxCoarse].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpDPdyCoarse].capabilities.push_back(CapShader); |
| InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpFwidthCoarse].capabilities.push_back(CapShader); |
| InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'"); |
| |
| InstructionDesc[OpEmitVertex].capabilities.push_back(CapGeom); |
| |
| InstructionDesc[OpEndPrimitive].capabilities.push_back(CapGeom); |
| |
| InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'"); |
| InstructionDesc[OpEmitStreamVertex].capabilities.push_back(CapGeom); |
| |
| InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'"); |
| InstructionDesc[OpEndStreamPrimitive].capabilities.push_back(CapGeom); |
| |
| InstructionDesc[OpControlBarrier].operands.push(OperandExecutionScope, "'Scope'"); |
| |
| InstructionDesc[OpMemoryBarrier].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'"); |
| |
| InstructionDesc[OpImagePointer].operands.push(OperandId, "'Image'"); |
| InstructionDesc[OpImagePointer].operands.push(OperandId, "'Coordinate'"); |
| InstructionDesc[OpImagePointer].operands.push(OperandId, "'Sample'"); |
| |
| InstructionDesc[OpAtomicInit].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicInit].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicLoad].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'"); |
| |
| InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicStore].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicExchange].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicCompareExchange].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'"); |
| InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'"); |
| |
| InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'"); |
| InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'"); |
| |
| InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicIIncrement].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'"); |
| |
| InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicIDecrement].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'"); |
| |
| InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicIAdd].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicISub].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicUMin].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicUMax].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicIMin].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicIMin].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicIMin].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicIMin].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicIMax].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicIMax].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicIMax].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicIMax].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicAnd].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicAnd].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicOr].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicOr].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Pointer'"); |
| InstructionDesc[OpAtomicXor].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAtomicXor].operands.push(OperandMemorySemantics, "'Semantics'"); |
| InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Label'"); |
| InstructionDesc[OpLoopMerge].operands.push(OperandLoop, ""); |
| |
| InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Label'"); |
| InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, ""); |
| |
| InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'"); |
| |
| InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'"); |
| InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'"); |
| InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'"); |
| InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'"); |
| |
| InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'"); |
| InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'"); |
| InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'"); |
| |
| InstructionDesc[OpKill].capabilities.push_back(CapShader); |
| |
| InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'"); |
| |
| InstructionDesc[OpUnreachable].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpLifetimeStart].operands.push(OperandId, ""); |
| InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, ""); |
| |
| InstructionDesc[OpLifetimeStop].operands.push(OperandId, ""); |
| InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, ""); |
| |
| InstructionDesc[OpCompileFlag].capabilities.push_back(CapKernel); |
| InstructionDesc[OpCompileFlag].operands.push(OperandLiteralString, "'Flag'"); |
| |
| InstructionDesc[OpAsyncGroupCopy].capabilities.push_back(CapKernel); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandId, "'Destination'"); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandId, "'Source'"); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandId, "'Num Elements'"); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandId, "'Stride'"); |
| InstructionDesc[OpAsyncGroupCopy].operands.push(OperandId, "'Event'"); |
| |
| InstructionDesc[OpWaitGroupEvents].capabilities.push_back(CapKernel); |
| InstructionDesc[OpWaitGroupEvents].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpWaitGroupEvents].operands.push(OperandId, "'Num Events'"); |
| InstructionDesc[OpWaitGroupEvents].operands.push(OperandId, "'Events List'"); |
| |
| InstructionDesc[OpGroupAll].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupAll].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'"); |
| |
| InstructionDesc[OpGroupAny].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupAny].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'"); |
| |
| InstructionDesc[OpGroupBroadcast].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupBroadcast].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'"); |
| InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'"); |
| |
| InstructionDesc[OpGroupIAdd].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupIAdd].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'"); |
| |
| InstructionDesc[OpGroupFAdd].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupFAdd].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'"); |
| |
| InstructionDesc[OpGroupUMin].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupUMin].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'"); |
| |
| InstructionDesc[OpGroupSMin].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupSMin].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupSMin].operands.push(OperandId, "X"); |
| |
| InstructionDesc[OpGroupFMin].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupFMin].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupFMin].operands.push(OperandId, "X"); |
| |
| InstructionDesc[OpGroupUMax].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupUMax].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupUMax].operands.push(OperandId, "X"); |
| |
| InstructionDesc[OpGroupSMax].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupSMax].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupSMax].operands.push(OperandId, "X"); |
| |
| InstructionDesc[OpGroupFMax].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupFMax].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'"); |
| InstructionDesc[OpGroupFMax].operands.push(OperandId, "X"); |
| |
| InstructionDesc[OpReadPipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReadPipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpReadPipe].operands.push(OperandId, "'ptr'"); |
| |
| InstructionDesc[OpWritePipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpWritePipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpWritePipe].operands.push(OperandId, "'ptr'"); |
| |
| InstructionDesc[OpReservedReadPipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'reserve_id'"); |
| InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'index'"); |
| InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'ptr'"); |
| |
| InstructionDesc[OpReservedWritePipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'reserve_id'"); |
| InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'index'"); |
| InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'ptr'"); |
| |
| InstructionDesc[OpReserveReadPipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'num_packets'"); |
| |
| InstructionDesc[OpReserveWritePipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'num_packets'"); |
| |
| InstructionDesc[OpCommitReadPipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'reserve_id'"); |
| |
| InstructionDesc[OpCommitWritePipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'reserve_id'"); |
| |
| InstructionDesc[OpIsValidReserveId].capabilities.push_back(CapKernel); |
| InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'reserve_id'"); |
| |
| InstructionDesc[OpGetNumPipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'p'"); |
| |
| InstructionDesc[OpGetMaxPipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'p'"); |
| |
| InstructionDesc[OpGroupReserveReadPipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'num_packets'"); |
| |
| InstructionDesc[OpGroupReserveWritePipePackets].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'num_packets'"); |
| |
| InstructionDesc[OpGroupCommitReadPipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'reserve_id'"); |
| |
| InstructionDesc[OpGroupCommitWritePipe].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandExecutionScope, "'Scope'"); |
| InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'p'"); |
| InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'reserve_id'"); |
| |
| InstructionDesc[OpBuildNDRange].capabilities.push_back(CapKernel); |
| InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'"); |
| InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'"); |
| InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'"); |
| |
| InstructionDesc[OpGetDefaultQueue].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpCaptureEventProfilingInfo].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'event'"); |
| InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandKernelProfilingInfo, "'info'"); |
| InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'value'"); |
| |
| InstructionDesc[OpSetUserEventStatus].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'event'"); |
| InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'status'"); |
| |
| InstructionDesc[OpIsValidEvent].capabilities.push_back(CapKernel); |
| InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'event'"); |
| |
| InstructionDesc[OpCreateUserEvent].capabilities.push_back(CapKernel); |
| |
| InstructionDesc[OpRetainEvent].capabilities.push_back(CapKernel); |
| InstructionDesc[OpRetainEvent].operands.push(OperandId, "'event'"); |
| |
| InstructionDesc[OpReleaseEvent].capabilities.push_back(CapKernel); |
| InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'event'"); |
| |
| InstructionDesc[OpGetKernelWorkGroupSize].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'"); |
| |
| InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'"); |
| |
| InstructionDesc[OpGetKernelNDrangeSubGroupCount].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'"); |
| InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'"); |
| |
| InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].capabilities.push_back(CapKernel); |
| InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'"); |
| InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'"); |
| |
| InstructionDesc[OpEnqueueKernel].capabilities.push_back(CapKernel); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'q'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandKernelEnqueueFlags, "'flags'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'"); |
| InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'"); |
| |
| InstructionDesc[OpEnqueueMarker].capabilities.push_back(CapKernel); |
| InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'q'"); |
| InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'"); |
| InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'"); |
| InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'"); |
| } |
| |
| }; // end spv namespace |
