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