• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  //===- SPIRVIsValidEnum.h - SPIR-V isValid enums ----------------*- C++ -*-===//
2  //
3  //                     The LLVM/SPIRV Translator
4  //
5  // This file is distributed under the University of Illinois Open Source
6  // License. See LICENSE.TXT for details.
7  //
8  // Copyright (c) 2014 Advanced Micro Devices, Inc. All rights reserved.
9  //
10  // Permission is hereby granted, free of charge, to any person obtaining a
11  // copy of this software and associated documentation files (the "Software"),
12  // to deal with the Software without restriction, including without limitation
13  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  // and/or sell copies of the Software, and to permit persons to whom the
15  // Software is furnished to do so, subject to the following conditions:
16  //
17  // Redistributions of source code must retain the above copyright notice,
18  // this list of conditions and the following disclaimers.
19  // Redistributions in binary form must reproduce the above copyright notice,
20  // this list of conditions and the following disclaimers in the documentation
21  // and/or other materials provided with the distribution.
22  // Neither the names of Advanced Micro Devices, Inc., nor the names of its
23  // contributors may be used to endorse or promote products derived from this
24  // Software without specific prior written permission.
25  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
26  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
27  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
28  // CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
29  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
30  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
31  // THE SOFTWARE.
32  //
33  //===----------------------------------------------------------------------===//
34  /// \file
35  ///
36  /// This file defines SPIR-V isValid enums.
37  ///
38  //===----------------------------------------------------------------------===//
39  // WARNING:
40  //
41  // This file has been generated using `tools/spirv-tool/gen_spirv.bash` and
42  // should not be modified manually. If the file needs to be updated, edit the
43  // script and any other source file instead, before re-generating this file.
44  //===----------------------------------------------------------------------===//
45  
46  #ifndef SPIRVISVALIDENUM_H_
47  #define SPIRVISVALIDENUM_H_
48  
49  #include "spirv.hpp"
50  #include "SPIRVEnum.h"
51  
52  using namespace spv;
53  
54  namespace SPIRV{
55  
56  inline bool
isValid(spv::SourceLanguage V)57  isValid(spv::SourceLanguage V) {
58    switch(V) {
59      case SourceLanguageUnknown:
60      case SourceLanguageESSL:
61      case SourceLanguageGLSL:
62      case SourceLanguageOpenCL_C:
63      case SourceLanguageOpenCL_CPP:
64        return true;
65      default:
66        return false;
67    }
68  }
69  
70  inline bool
isValid(spv::ExecutionModel V)71  isValid(spv::ExecutionModel V) {
72    switch(V) {
73      case ExecutionModelVertex:
74      case ExecutionModelTessellationControl:
75      case ExecutionModelTessellationEvaluation:
76      case ExecutionModelGeometry:
77      case ExecutionModelFragment:
78      case ExecutionModelGLCompute:
79      case ExecutionModelKernel:
80        return true;
81      default:
82        return false;
83    }
84  }
85  
86  inline bool
isValid(spv::AddressingModel V)87  isValid(spv::AddressingModel V) {
88    switch(V) {
89      case AddressingModelLogical:
90      case AddressingModelPhysical32:
91      case AddressingModelPhysical64:
92        return true;
93      default:
94        return false;
95    }
96  }
97  
98  inline bool
isValid(spv::MemoryModel V)99  isValid(spv::MemoryModel V) {
100    switch(V) {
101      case MemoryModelSimple:
102      case MemoryModelGLSL450:
103      case MemoryModelOpenCL:
104        return true;
105      default:
106        return false;
107    }
108  }
109  
110  inline bool
isValid(spv::ExecutionMode V)111  isValid(spv::ExecutionMode V) {
112    switch(V) {
113      case ExecutionModeInvocations:
114      case ExecutionModeSpacingEqual:
115      case ExecutionModeSpacingFractionalEven:
116      case ExecutionModeSpacingFractionalOdd:
117      case ExecutionModeVertexOrderCw:
118      case ExecutionModeVertexOrderCcw:
119      case ExecutionModePixelCenterInteger:
120      case ExecutionModeOriginUpperLeft:
121      case ExecutionModeOriginLowerLeft:
122      case ExecutionModeEarlyFragmentTests:
123      case ExecutionModePointMode:
124      case ExecutionModeXfb:
125      case ExecutionModeDepthReplacing:
126      case ExecutionModeDepthGreater:
127      case ExecutionModeDepthLess:
128      case ExecutionModeDepthUnchanged:
129      case ExecutionModeLocalSize:
130      case ExecutionModeLocalSizeHint:
131      case ExecutionModeInputPoints:
132      case ExecutionModeInputLines:
133      case ExecutionModeInputLinesAdjacency:
134      case ExecutionModeTriangles:
135      case ExecutionModeInputTrianglesAdjacency:
136      case ExecutionModeQuads:
137      case ExecutionModeIsolines:
138      case ExecutionModeOutputVertices:
139      case ExecutionModeOutputPoints:
140      case ExecutionModeOutputLineStrip:
141      case ExecutionModeOutputTriangleStrip:
142      case ExecutionModeVecTypeHint:
143      case ExecutionModeContractionOff:
144      case ExecutionModeInitializer:
145      case ExecutionModeFinalizer:
146      case ExecutionModeSubgroupSize:
147      case ExecutionModeSubgroupsPerWorkgroup:
148        return true;
149      default:
150        return false;
151    }
152  }
153  
154  inline bool
isValid(spv::StorageClass V)155  isValid(spv::StorageClass V) {
156    switch(V) {
157      case StorageClassUniformConstant:
158      case StorageClassInput:
159      case StorageClassUniform:
160      case StorageClassOutput:
161      case StorageClassWorkgroup:
162      case StorageClassCrossWorkgroup:
163      case StorageClassPrivate:
164      case StorageClassFunction:
165      case StorageClassGeneric:
166      case StorageClassPushConstant:
167      case StorageClassAtomicCounter:
168      case StorageClassImage:
169        return true;
170      default:
171        return false;
172    }
173  }
174  
175  inline bool
isValid(spv::Dim V)176  isValid(spv::Dim V) {
177    switch(V) {
178      case Dim1D:
179      case Dim2D:
180      case Dim3D:
181      case DimCube:
182      case DimRect:
183      case DimBuffer:
184      case DimSubpassData:
185        return true;
186      default:
187        return false;
188    }
189  }
190  
191  inline bool
isValid(spv::SamplerAddressingMode V)192  isValid(spv::SamplerAddressingMode V) {
193    switch(V) {
194      case SamplerAddressingModeNone:
195      case SamplerAddressingModeClampToEdge:
196      case SamplerAddressingModeClamp:
197      case SamplerAddressingModeRepeat:
198      case SamplerAddressingModeRepeatMirrored:
199        return true;
200      default:
201        return false;
202    }
203  }
204  
205  inline bool
isValid(spv::SamplerFilterMode V)206  isValid(spv::SamplerFilterMode V) {
207    switch(V) {
208      case SamplerFilterModeNearest:
209      case SamplerFilterModeLinear:
210        return true;
211      default:
212        return false;
213    }
214  }
215  
216  inline bool
isValid(spv::ImageFormat V)217  isValid(spv::ImageFormat V) {
218    switch(V) {
219      case ImageFormatUnknown:
220      case ImageFormatRgba32f:
221      case ImageFormatRgba16f:
222      case ImageFormatR32f:
223      case ImageFormatRgba8:
224      case ImageFormatRgba8Snorm:
225      case ImageFormatRg32f:
226      case ImageFormatRg16f:
227      case ImageFormatR11fG11fB10f:
228      case ImageFormatR16f:
229      case ImageFormatRgba16:
230      case ImageFormatRgb10A2:
231      case ImageFormatRg16:
232      case ImageFormatRg8:
233      case ImageFormatR16:
234      case ImageFormatR8:
235      case ImageFormatRgba16Snorm:
236      case ImageFormatRg16Snorm:
237      case ImageFormatRg8Snorm:
238      case ImageFormatR16Snorm:
239      case ImageFormatR8Snorm:
240      case ImageFormatRgba32i:
241      case ImageFormatRgba16i:
242      case ImageFormatRgba8i:
243      case ImageFormatR32i:
244      case ImageFormatRg32i:
245      case ImageFormatRg16i:
246      case ImageFormatRg8i:
247      case ImageFormatR16i:
248      case ImageFormatR8i:
249      case ImageFormatRgba32ui:
250      case ImageFormatRgba16ui:
251      case ImageFormatRgba8ui:
252      case ImageFormatR32ui:
253      case ImageFormatRgb10a2ui:
254      case ImageFormatRg32ui:
255      case ImageFormatRg16ui:
256      case ImageFormatRg8ui:
257      case ImageFormatR16ui:
258      case ImageFormatR8ui:
259        return true;
260      default:
261        return false;
262    }
263  }
264  
265  inline bool
isValid(spv::ImageChannelOrder V)266  isValid(spv::ImageChannelOrder V) {
267    switch(V) {
268      case ImageChannelOrderR:
269      case ImageChannelOrderA:
270      case ImageChannelOrderRG:
271      case ImageChannelOrderRA:
272      case ImageChannelOrderRGB:
273      case ImageChannelOrderRGBA:
274      case ImageChannelOrderBGRA:
275      case ImageChannelOrderARGB:
276      case ImageChannelOrderIntensity:
277      case ImageChannelOrderLuminance:
278      case ImageChannelOrderRx:
279      case ImageChannelOrderRGx:
280      case ImageChannelOrderRGBx:
281      case ImageChannelOrderDepth:
282      case ImageChannelOrderDepthStencil:
283      case ImageChannelOrderABGR:
284        return true;
285      default:
286        return false;
287    }
288  }
289  
290  inline bool
isValid(spv::ImageChannelDataType V)291  isValid(spv::ImageChannelDataType V) {
292    switch(V) {
293      case ImageChannelDataTypeSnormInt8:
294      case ImageChannelDataTypeSnormInt16:
295      case ImageChannelDataTypeUnormInt8:
296      case ImageChannelDataTypeUnormInt16:
297      case ImageChannelDataTypeUnormShort565:
298      case ImageChannelDataTypeUnormShort555:
299      case ImageChannelDataTypeUnormInt101010:
300      case ImageChannelDataTypeSignedInt8:
301      case ImageChannelDataTypeSignedInt16:
302      case ImageChannelDataTypeSignedInt32:
303      case ImageChannelDataTypeUnsignedInt8:
304      case ImageChannelDataTypeUnsignedInt16:
305      case ImageChannelDataTypeUnsignedInt32:
306      case ImageChannelDataTypeHalfFloat:
307      case ImageChannelDataTypeFloat:
308      case ImageChannelDataTypeUnormInt24:
309      case ImageChannelDataTypeUnormInt101010_2:
310        return true;
311      default:
312        return false;
313    }
314  }
315  
316  inline bool
isValid(spv::FPRoundingMode V)317  isValid(spv::FPRoundingMode V) {
318    switch(V) {
319      case FPRoundingModeRTE:
320      case FPRoundingModeRTZ:
321      case FPRoundingModeRTP:
322      case FPRoundingModeRTN:
323        return true;
324      default:
325        return false;
326    }
327  }
328  
329  inline bool
isValid(spv::LinkageType V)330  isValid(spv::LinkageType V) {
331    switch(V) {
332      case LinkageTypeExport:
333      case LinkageTypeImport:
334      case LinkageTypeInternal:
335        return true;
336      default:
337        return false;
338    }
339  }
340  
341  inline bool
isValid(spv::AccessQualifier V)342  isValid(spv::AccessQualifier V) {
343    switch(V) {
344      case AccessQualifierReadOnly:
345      case AccessQualifierWriteOnly:
346      case AccessQualifierReadWrite:
347        return true;
348      default:
349        return false;
350    }
351  }
352  
353  inline bool
isValid(spv::FunctionParameterAttribute V)354  isValid(spv::FunctionParameterAttribute V) {
355    switch(V) {
356      case FunctionParameterAttributeZext:
357      case FunctionParameterAttributeSext:
358      case FunctionParameterAttributeByVal:
359      case FunctionParameterAttributeSret:
360      case FunctionParameterAttributeNoAlias:
361      case FunctionParameterAttributeNoCapture:
362      case FunctionParameterAttributeNoWrite:
363      case FunctionParameterAttributeNoReadWrite:
364        return true;
365      default:
366        return false;
367    }
368  }
369  
370  inline bool
isValid(spv::Decoration V)371  isValid(spv::Decoration V) {
372    switch(V) {
373      case DecorationRelaxedPrecision:
374      case DecorationSpecId:
375      case DecorationBlock:
376      case DecorationBufferBlock:
377      case DecorationRowMajor:
378      case DecorationColMajor:
379      case DecorationArrayStride:
380      case DecorationMatrixStride:
381      case DecorationGLSLShared:
382      case DecorationGLSLPacked:
383      case DecorationCPacked:
384      case DecorationBuiltIn:
385      case DecorationNoPerspective:
386      case DecorationFlat:
387      case DecorationPatch:
388      case DecorationCentroid:
389      case DecorationSample:
390      case DecorationInvariant:
391      case DecorationRestrict:
392      case DecorationAliased:
393      case DecorationVolatile:
394      case DecorationConstant:
395      case DecorationCoherent:
396      case DecorationNonWritable:
397      case DecorationNonReadable:
398      case DecorationUniform:
399      case DecorationSaturatedConversion:
400      case DecorationStream:
401      case DecorationLocation:
402      case DecorationComponent:
403      case DecorationIndex:
404      case DecorationBinding:
405      case DecorationDescriptorSet:
406      case DecorationOffset:
407      case DecorationXfbBuffer:
408      case DecorationXfbStride:
409      case DecorationFuncParamAttr:
410      case DecorationFPRoundingMode:
411      case DecorationFPFastMathMode:
412      case DecorationLinkageAttributes:
413      case DecorationNoContraction:
414      case DecorationInputAttachmentIndex:
415      case DecorationAlignment:
416      case DecorationMaxByteOffset:
417        return true;
418      default:
419        return false;
420    }
421  }
422  
423  inline bool
isValid(spv::BuiltIn V)424  isValid(spv::BuiltIn V) {
425    switch(V) {
426      case BuiltInPosition:
427      case BuiltInPointSize:
428      case BuiltInClipDistance:
429      case BuiltInCullDistance:
430      case BuiltInVertexId:
431      case BuiltInInstanceId:
432      case BuiltInPrimitiveId:
433      case BuiltInInvocationId:
434      case BuiltInLayer:
435      case BuiltInViewportIndex:
436      case BuiltInTessLevelOuter:
437      case BuiltInTessLevelInner:
438      case BuiltInTessCoord:
439      case BuiltInPatchVertices:
440      case BuiltInFragCoord:
441      case BuiltInPointCoord:
442      case BuiltInFrontFacing:
443      case BuiltInSampleId:
444      case BuiltInSamplePosition:
445      case BuiltInSampleMask:
446      case BuiltInFragDepth:
447      case BuiltInHelperInvocation:
448      case BuiltInNumWorkgroups:
449      case BuiltInWorkgroupSize:
450      case BuiltInWorkgroupId:
451      case BuiltInLocalInvocationId:
452      case BuiltInGlobalInvocationId:
453      case BuiltInLocalInvocationIndex:
454      case BuiltInWorkDim:
455      case BuiltInGlobalSize:
456      case BuiltInEnqueuedWorkgroupSize:
457      case BuiltInGlobalOffset:
458      case BuiltInGlobalLinearId:
459      case BuiltInSubgroupSize:
460      case BuiltInSubgroupMaxSize:
461      case BuiltInNumSubgroups:
462      case BuiltInNumEnqueuedSubgroups:
463      case BuiltInSubgroupId:
464      case BuiltInSubgroupLocalInvocationId:
465      case BuiltInVertexIndex:
466      case BuiltInInstanceIndex:
467        return true;
468      default:
469        return false;
470    }
471  }
472  
473  inline bool
isValid(spv::Scope V)474  isValid(spv::Scope V) {
475    switch(V) {
476      case ScopeCrossDevice:
477      case ScopeDevice:
478      case ScopeWorkgroup:
479      case ScopeSubgroup:
480      case ScopeInvocation:
481        return true;
482      default:
483        return false;
484    }
485  }
486  
487  inline bool
isValid(spv::GroupOperation V)488  isValid(spv::GroupOperation V) {
489    switch(V) {
490      case GroupOperationReduce:
491      case GroupOperationInclusiveScan:
492      case GroupOperationExclusiveScan:
493        return true;
494      default:
495        return false;
496    }
497  }
498  
499  inline bool
isValid(spv::KernelEnqueueFlags V)500  isValid(spv::KernelEnqueueFlags V) {
501    switch(V) {
502      case KernelEnqueueFlagsNoWait:
503      case KernelEnqueueFlagsWaitKernel:
504      case KernelEnqueueFlagsWaitWorkGroup:
505        return true;
506      default:
507        return false;
508    }
509  }
510  
511  inline bool
isValid(spv::Capability V)512  isValid(spv::Capability V) {
513    switch(V) {
514      case CapabilityMatrix:
515      case CapabilityShader:
516      case CapabilityGeometry:
517      case CapabilityTessellation:
518      case CapabilityAddresses:
519      case CapabilityLinkage:
520      case CapabilityKernel:
521      case CapabilityVector16:
522      case CapabilityFloat16Buffer:
523      case CapabilityFloat16:
524      case CapabilityFloat64:
525      case CapabilityInt64:
526      case CapabilityInt64Atomics:
527      case CapabilityImageBasic:
528      case CapabilityImageReadWrite:
529      case CapabilityImageMipmap:
530      case CapabilityPipes:
531      case CapabilityGroups:
532      case CapabilityDeviceEnqueue:
533      case CapabilityLiteralSampler:
534      case CapabilityAtomicStorage:
535      case CapabilityInt16:
536      case CapabilityTessellationPointSize:
537      case CapabilityGeometryPointSize:
538      case CapabilityImageGatherExtended:
539      case CapabilityStorageImageMultisample:
540      case CapabilityUniformBufferArrayDynamicIndexing:
541      case CapabilitySampledImageArrayDynamicIndexing:
542      case CapabilityStorageBufferArrayDynamicIndexing:
543      case CapabilityStorageImageArrayDynamicIndexing:
544      case CapabilityClipDistance:
545      case CapabilityCullDistance:
546      case CapabilityImageCubeArray:
547      case CapabilitySampleRateShading:
548      case CapabilityImageRect:
549      case CapabilitySampledRect:
550      case CapabilityGenericPointer:
551      case CapabilityInt8:
552      case CapabilityInputAttachment:
553      case CapabilitySparseResidency:
554      case CapabilityMinLod:
555      case CapabilitySampled1D:
556      case CapabilityImage1D:
557      case CapabilitySampledCubeArray:
558      case CapabilitySampledBuffer:
559      case CapabilityImageBuffer:
560      case CapabilityImageMSArray:
561      case CapabilityStorageImageExtendedFormats:
562      case CapabilityImageQuery:
563      case CapabilityDerivativeControl:
564      case CapabilityInterpolationFunction:
565      case CapabilityTransformFeedback:
566      case CapabilityGeometryStreams:
567      case CapabilityStorageImageReadWithoutFormat:
568      case CapabilityStorageImageWriteWithoutFormat:
569      case CapabilityMultiViewport:
570      case CapabilitySubgroupDispatch:
571      case CapabilityNamedBarrier:
572      case CapabilityPipeStorage:
573        return true;
574      default:
575        return false;
576    }
577  }
578  
579  inline bool
isValid(spv::Op V)580  isValid(spv::Op V) {
581    switch(V) {
582      case OpNop:
583      case OpUndef:
584      case OpSourceContinued:
585      case OpSource:
586      case OpSourceExtension:
587      case OpName:
588      case OpMemberName:
589      case OpString:
590      case OpLine:
591      case OpExtension:
592      case OpExtInstImport:
593      case OpExtInst:
594      case OpMemoryModel:
595      case OpEntryPoint:
596      case OpExecutionMode:
597      case OpCapability:
598      case OpTypeVoid:
599      case OpTypeBool:
600      case OpTypeInt:
601      case OpTypeFloat:
602      case OpTypeVector:
603      case OpTypeMatrix:
604      case OpTypeImage:
605      case OpTypeSampler:
606      case OpTypeSampledImage:
607      case OpTypeArray:
608      case OpTypeRuntimeArray:
609      case OpTypeStruct:
610      case OpTypeOpaque:
611      case OpTypePointer:
612      case OpTypeFunction:
613      case OpTypeEvent:
614      case OpTypeDeviceEvent:
615      case OpTypeReserveId:
616      case OpTypeQueue:
617      case OpTypePipe:
618      case OpTypeForwardPointer:
619      case OpConstantTrue:
620      case OpConstantFalse:
621      case OpConstant:
622      case OpConstantComposite:
623      case OpConstantSampler:
624      case OpConstantNull:
625      case OpSpecConstantTrue:
626      case OpSpecConstantFalse:
627      case OpSpecConstant:
628      case OpSpecConstantComposite:
629      case OpSpecConstantOp:
630      case OpFunction:
631      case OpFunctionParameter:
632      case OpFunctionEnd:
633      case OpFunctionCall:
634      case OpVariable:
635      case OpImageTexelPointer:
636      case OpLoad:
637      case OpStore:
638      case OpCopyMemory:
639      case OpCopyMemorySized:
640      case OpAccessChain:
641      case OpInBoundsAccessChain:
642      case OpPtrAccessChain:
643      case OpArrayLength:
644      case OpGenericPtrMemSemantics:
645      case OpInBoundsPtrAccessChain:
646      case OpDecorate:
647      case OpMemberDecorate:
648      case OpDecorationGroup:
649      case OpGroupDecorate:
650      case OpGroupMemberDecorate:
651      case OpVectorExtractDynamic:
652      case OpVectorInsertDynamic:
653      case OpVectorShuffle:
654      case OpCompositeConstruct:
655      case OpCompositeExtract:
656      case OpCompositeInsert:
657      case OpCopyObject:
658      case OpTranspose:
659      case OpSampledImage:
660      case OpImageSampleImplicitLod:
661      case OpImageSampleExplicitLod:
662      case OpImageSampleDrefImplicitLod:
663      case OpImageSampleDrefExplicitLod:
664      case OpImageSampleProjImplicitLod:
665      case OpImageSampleProjExplicitLod:
666      case OpImageSampleProjDrefImplicitLod:
667      case OpImageSampleProjDrefExplicitLod:
668      case OpImageFetch:
669      case OpImageGather:
670      case OpImageDrefGather:
671      case OpImageRead:
672      case OpImageWrite:
673      case OpImage:
674      case OpImageQueryFormat:
675      case OpImageQueryOrder:
676      case OpImageQuerySizeLod:
677      case OpImageQuerySize:
678      case OpImageQueryLod:
679      case OpImageQueryLevels:
680      case OpImageQuerySamples:
681      case OpConvertFToU:
682      case OpConvertFToS:
683      case OpConvertSToF:
684      case OpConvertUToF:
685      case OpUConvert:
686      case OpSConvert:
687      case OpFConvert:
688      case OpQuantizeToF16:
689      case OpConvertPtrToU:
690      case OpSatConvertSToU:
691      case OpSatConvertUToS:
692      case OpConvertUToPtr:
693      case OpPtrCastToGeneric:
694      case OpGenericCastToPtr:
695      case OpGenericCastToPtrExplicit:
696      case OpBitcast:
697      case OpSNegate:
698      case OpFNegate:
699      case OpIAdd:
700      case OpFAdd:
701      case OpISub:
702      case OpFSub:
703      case OpIMul:
704      case OpFMul:
705      case OpUDiv:
706      case OpSDiv:
707      case OpFDiv:
708      case OpUMod:
709      case OpSRem:
710      case OpSMod:
711      case OpFRem:
712      case OpFMod:
713      case OpVectorTimesScalar:
714      case OpMatrixTimesScalar:
715      case OpVectorTimesMatrix:
716      case OpMatrixTimesVector:
717      case OpMatrixTimesMatrix:
718      case OpOuterProduct:
719      case OpDot:
720      case OpIAddCarry:
721      case OpISubBorrow:
722      case OpUMulExtended:
723      case OpSMulExtended:
724      case OpAny:
725      case OpAll:
726      case OpIsNan:
727      case OpIsInf:
728      case OpIsFinite:
729      case OpIsNormal:
730      case OpSignBitSet:
731      case OpLessOrGreater:
732      case OpOrdered:
733      case OpUnordered:
734      case OpLogicalEqual:
735      case OpLogicalNotEqual:
736      case OpLogicalOr:
737      case OpLogicalAnd:
738      case OpLogicalNot:
739      case OpSelect:
740      case OpIEqual:
741      case OpINotEqual:
742      case OpUGreaterThan:
743      case OpSGreaterThan:
744      case OpUGreaterThanEqual:
745      case OpSGreaterThanEqual:
746      case OpULessThan:
747      case OpSLessThan:
748      case OpULessThanEqual:
749      case OpSLessThanEqual:
750      case OpFOrdEqual:
751      case OpFUnordEqual:
752      case OpFOrdNotEqual:
753      case OpFUnordNotEqual:
754      case OpFOrdLessThan:
755      case OpFUnordLessThan:
756      case OpFOrdGreaterThan:
757      case OpFUnordGreaterThan:
758      case OpFOrdLessThanEqual:
759      case OpFUnordLessThanEqual:
760      case OpFOrdGreaterThanEqual:
761      case OpFUnordGreaterThanEqual:
762      case OpShiftRightLogical:
763      case OpShiftRightArithmetic:
764      case OpShiftLeftLogical:
765      case OpBitwiseOr:
766      case OpBitwiseXor:
767      case OpBitwiseAnd:
768      case OpNot:
769      case OpBitFieldInsert:
770      case OpBitFieldSExtract:
771      case OpBitFieldUExtract:
772      case OpBitReverse:
773      case OpBitCount:
774      case OpDPdx:
775      case OpDPdy:
776      case OpFwidth:
777      case OpDPdxFine:
778      case OpDPdyFine:
779      case OpFwidthFine:
780      case OpDPdxCoarse:
781      case OpDPdyCoarse:
782      case OpFwidthCoarse:
783      case OpEmitVertex:
784      case OpEndPrimitive:
785      case OpEmitStreamVertex:
786      case OpEndStreamPrimitive:
787      case OpControlBarrier:
788      case OpMemoryBarrier:
789      case OpAtomicLoad:
790      case OpAtomicStore:
791      case OpAtomicExchange:
792      case OpAtomicCompareExchange:
793      case OpAtomicCompareExchangeWeak:
794      case OpAtomicIIncrement:
795      case OpAtomicIDecrement:
796      case OpAtomicIAdd:
797      case OpAtomicISub:
798      case OpAtomicSMin:
799      case OpAtomicUMin:
800      case OpAtomicSMax:
801      case OpAtomicUMax:
802      case OpAtomicAnd:
803      case OpAtomicOr:
804      case OpAtomicXor:
805      case OpPhi:
806      case OpLoopMerge:
807      case OpSelectionMerge:
808      case OpLabel:
809      case OpBranch:
810      case OpBranchConditional:
811      case OpSwitch:
812      case OpKill:
813      case OpReturn:
814      case OpReturnValue:
815      case OpUnreachable:
816      case OpLifetimeStart:
817      case OpLifetimeStop:
818      case OpGroupAsyncCopy:
819      case OpGroupWaitEvents:
820      case OpGroupAll:
821      case OpGroupAny:
822      case OpGroupBroadcast:
823      case OpGroupIAdd:
824      case OpGroupFAdd:
825      case OpGroupFMin:
826      case OpGroupUMin:
827      case OpGroupSMin:
828      case OpGroupFMax:
829      case OpGroupUMax:
830      case OpGroupSMax:
831      case OpReadPipe:
832      case OpWritePipe:
833      case OpReservedReadPipe:
834      case OpReservedWritePipe:
835      case OpReserveReadPipePackets:
836      case OpReserveWritePipePackets:
837      case OpCommitReadPipe:
838      case OpCommitWritePipe:
839      case OpIsValidReserveId:
840      case OpGetNumPipePackets:
841      case OpGetMaxPipePackets:
842      case OpGroupReserveReadPipePackets:
843      case OpGroupReserveWritePipePackets:
844      case OpGroupCommitReadPipe:
845      case OpGroupCommitWritePipe:
846      case OpEnqueueMarker:
847      case OpEnqueueKernel:
848      case OpGetKernelNDrangeSubGroupCount:
849      case OpGetKernelNDrangeMaxSubGroupSize:
850      case OpGetKernelWorkGroupSize:
851      case OpGetKernelPreferredWorkGroupSizeMultiple:
852      case OpRetainEvent:
853      case OpReleaseEvent:
854      case OpCreateUserEvent:
855      case OpIsValidEvent:
856      case OpSetUserEventStatus:
857      case OpCaptureEventProfilingInfo:
858      case OpGetDefaultQueue:
859      case OpBuildNDRange:
860      case OpImageSparseSampleImplicitLod:
861      case OpImageSparseSampleExplicitLod:
862      case OpImageSparseSampleDrefImplicitLod:
863      case OpImageSparseSampleDrefExplicitLod:
864      case OpImageSparseSampleProjImplicitLod:
865      case OpImageSparseSampleProjExplicitLod:
866      case OpImageSparseSampleProjDrefImplicitLod:
867      case OpImageSparseSampleProjDrefExplicitLod:
868      case OpImageSparseFetch:
869      case OpImageSparseGather:
870      case OpImageSparseDrefGather:
871      case OpImageSparseTexelsResident:
872      case OpNoLine:
873      case OpAtomicFlagTestAndSet:
874      case OpAtomicFlagClear:
875      case OpImageSparseRead:
876      case OpSizeOf:
877      case OpTypePipeStorage:
878      case OpConstantPipeStorage:
879      case OpCreatePipeFromPipeStorage:
880      case OpGetKernelLocalSizeForSubgroupCount:
881      case OpGetKernelMaxNumSubgroups:
882      case OpTypeNamedBarrier:
883      case OpNamedBarrierInitialize:
884      case OpMemoryNamedBarrier:
885      case OpModuleProcessed:
886      case OpForward:
887        return true;
888      default:
889        return false;
890    }
891  }
892  
893  inline bool
isValidImageOperandsMask(SPIRVWord Mask)894  isValidImageOperandsMask(SPIRVWord Mask) {
895    SPIRVWord ValidMask = 0u;
896    ValidMask |= ImageOperandsBiasMask;
897    ValidMask |= ImageOperandsLodMask;
898    ValidMask |= ImageOperandsGradMask;
899    ValidMask |= ImageOperandsConstOffsetMask;
900    ValidMask |= ImageOperandsOffsetMask;
901    ValidMask |= ImageOperandsConstOffsetsMask;
902    ValidMask |= ImageOperandsSampleMask;
903    ValidMask |= ImageOperandsMinLodMask;
904  
905    return (Mask & ~ValidMask) == 0;
906  }
907  
908  inline bool
isValidFPFastMathModeMask(SPIRVWord Mask)909  isValidFPFastMathModeMask(SPIRVWord Mask) {
910    SPIRVWord ValidMask = 0u;
911    ValidMask |= FPFastMathModeNotNaNMask;
912    ValidMask |= FPFastMathModeNotInfMask;
913    ValidMask |= FPFastMathModeNSZMask;
914    ValidMask |= FPFastMathModeAllowRecipMask;
915    ValidMask |= FPFastMathModeFastMask;
916  
917    return (Mask & ~ValidMask) == 0;
918  }
919  
920  inline bool
isValidSelectionControlMask(SPIRVWord Mask)921  isValidSelectionControlMask(SPIRVWord Mask) {
922    SPIRVWord ValidMask = 0u;
923    ValidMask |= SelectionControlFlattenMask;
924    ValidMask |= SelectionControlDontFlattenMask;
925  
926    return (Mask & ~ValidMask) == 0;
927  }
928  
929  inline bool
isValidLoopControlMask(SPIRVWord Mask)930  isValidLoopControlMask(SPIRVWord Mask) {
931    SPIRVWord ValidMask = 0u;
932    ValidMask |= LoopControlUnrollMask;
933    ValidMask |= LoopControlDontUnrollMask;
934    ValidMask |= LoopControlDependencyInfiniteMask;
935    ValidMask |= LoopControlDependencyLengthMask;
936  
937    return (Mask & ~ValidMask) == 0;
938  }
939  
940  inline bool
isValidFunctionControlMask(SPIRVWord Mask)941  isValidFunctionControlMask(SPIRVWord Mask) {
942    SPIRVWord ValidMask = 0u;
943    ValidMask |= FunctionControlInlineMask;
944    ValidMask |= FunctionControlDontInlineMask;
945    ValidMask |= FunctionControlPureMask;
946    ValidMask |= FunctionControlConstMask;
947  
948    return (Mask & ~ValidMask) == 0;
949  }
950  
951  inline bool
isValidMemorySemanticsMask(SPIRVWord Mask)952  isValidMemorySemanticsMask(SPIRVWord Mask) {
953    SPIRVWord ValidMask = 0u;
954    ValidMask |= MemorySemanticsAcquireMask;
955    ValidMask |= MemorySemanticsReleaseMask;
956    ValidMask |= MemorySemanticsAcquireReleaseMask;
957    ValidMask |= MemorySemanticsSequentiallyConsistentMask;
958    ValidMask |= MemorySemanticsUniformMemoryMask;
959    ValidMask |= MemorySemanticsSubgroupMemoryMask;
960    ValidMask |= MemorySemanticsWorkgroupMemoryMask;
961    ValidMask |= MemorySemanticsCrossWorkgroupMemoryMask;
962    ValidMask |= MemorySemanticsAtomicCounterMemoryMask;
963    ValidMask |= MemorySemanticsImageMemoryMask;
964  
965    return (Mask & ~ValidMask) == 0;
966  }
967  
968  inline bool
isValidMemoryAccessMask(SPIRVWord Mask)969  isValidMemoryAccessMask(SPIRVWord Mask) {
970    SPIRVWord ValidMask = 0u;
971    ValidMask |= MemoryAccessVolatileMask;
972    ValidMask |= MemoryAccessAlignedMask;
973    ValidMask |= MemoryAccessNontemporalMask;
974  
975    return (Mask & ~ValidMask) == 0;
976  }
977  
978  inline bool
isValidKernelProfilingInfoMask(SPIRVWord Mask)979  isValidKernelProfilingInfoMask(SPIRVWord Mask) {
980    SPIRVWord ValidMask = 0u;
981    ValidMask |= KernelProfilingInfoCmdExecTimeMask;
982  
983    return (Mask & ~ValidMask) == 0;
984  }
985  
986  } /* namespace SPIRV */
987  
988  #endif /* SPIRVISVALIDENUM_H_ */
989