//===- SPIRVIsValidEnum.h - SPIR-V isValid enums ----------------*- C++ -*-===//
//
//                     The LLVM/SPIRV Translator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
// Copyright (c) 2014 Advanced Micro Devices, Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal with the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimers.
// Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimers in the documentation
// and/or other materials provided with the distribution.
// Neither the names of Advanced Micro Devices, Inc., nor the names of its
// contributors may be used to endorse or promote products derived from this
// Software without specific prior written permission.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
// THE SOFTWARE.
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file defines SPIR-V isValid enums.
///
//===----------------------------------------------------------------------===//
// WARNING:
//
// This file has been generated using `tools/spirv-tool/gen_spirv.bash` and
// should not be modified manually. If the file needs to be updated, edit the
// script and any other source file instead, before re-generating this file.
//===----------------------------------------------------------------------===//

#ifndef SPIRVISVALIDENUM_H_
#define SPIRVISVALIDENUM_H_

#include "spirv.hpp"
#include "SPIRVEnum.h"

using namespace spv;

namespace SPIRV{

inline bool
isValid(spv::SourceLanguage V) {
  switch(V) {
    case SourceLanguageUnknown:
    case SourceLanguageESSL:
    case SourceLanguageGLSL:
    case SourceLanguageOpenCL_C:
    case SourceLanguageOpenCL_CPP:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::ExecutionModel V) {
  switch(V) {
    case ExecutionModelVertex:
    case ExecutionModelTessellationControl:
    case ExecutionModelTessellationEvaluation:
    case ExecutionModelGeometry:
    case ExecutionModelFragment:
    case ExecutionModelGLCompute:
    case ExecutionModelKernel:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::AddressingModel V) {
  switch(V) {
    case AddressingModelLogical:
    case AddressingModelPhysical32:
    case AddressingModelPhysical64:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::MemoryModel V) {
  switch(V) {
    case MemoryModelSimple:
    case MemoryModelGLSL450:
    case MemoryModelOpenCL:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::ExecutionMode V) {
  switch(V) {
    case ExecutionModeInvocations:
    case ExecutionModeSpacingEqual:
    case ExecutionModeSpacingFractionalEven:
    case ExecutionModeSpacingFractionalOdd:
    case ExecutionModeVertexOrderCw:
    case ExecutionModeVertexOrderCcw:
    case ExecutionModePixelCenterInteger:
    case ExecutionModeOriginUpperLeft:
    case ExecutionModeOriginLowerLeft:
    case ExecutionModeEarlyFragmentTests:
    case ExecutionModePointMode:
    case ExecutionModeXfb:
    case ExecutionModeDepthReplacing:
    case ExecutionModeDepthGreater:
    case ExecutionModeDepthLess:
    case ExecutionModeDepthUnchanged:
    case ExecutionModeLocalSize:
    case ExecutionModeLocalSizeHint:
    case ExecutionModeInputPoints:
    case ExecutionModeInputLines:
    case ExecutionModeInputLinesAdjacency:
    case ExecutionModeTriangles:
    case ExecutionModeInputTrianglesAdjacency:
    case ExecutionModeQuads:
    case ExecutionModeIsolines:
    case ExecutionModeOutputVertices:
    case ExecutionModeOutputPoints:
    case ExecutionModeOutputLineStrip:
    case ExecutionModeOutputTriangleStrip:
    case ExecutionModeVecTypeHint:
    case ExecutionModeContractionOff:
    case ExecutionModeInitializer:
    case ExecutionModeFinalizer:
    case ExecutionModeSubgroupSize:
    case ExecutionModeSubgroupsPerWorkgroup:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::StorageClass V) {
  switch(V) {
    case StorageClassUniformConstant:
    case StorageClassInput:
    case StorageClassUniform:
    case StorageClassOutput:
    case StorageClassWorkgroup:
    case StorageClassCrossWorkgroup:
    case StorageClassPrivate:
    case StorageClassFunction:
    case StorageClassGeneric:
    case StorageClassPushConstant:
    case StorageClassAtomicCounter:
    case StorageClassImage:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::Dim V) {
  switch(V) {
    case Dim1D:
    case Dim2D:
    case Dim3D:
    case DimCube:
    case DimRect:
    case DimBuffer:
    case DimSubpassData:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::SamplerAddressingMode V) {
  switch(V) {
    case SamplerAddressingModeNone:
    case SamplerAddressingModeClampToEdge:
    case SamplerAddressingModeClamp:
    case SamplerAddressingModeRepeat:
    case SamplerAddressingModeRepeatMirrored:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::SamplerFilterMode V) {
  switch(V) {
    case SamplerFilterModeNearest:
    case SamplerFilterModeLinear:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::ImageFormat V) {
  switch(V) {
    case ImageFormatUnknown:
    case ImageFormatRgba32f:
    case ImageFormatRgba16f:
    case ImageFormatR32f:
    case ImageFormatRgba8:
    case ImageFormatRgba8Snorm:
    case ImageFormatRg32f:
    case ImageFormatRg16f:
    case ImageFormatR11fG11fB10f:
    case ImageFormatR16f:
    case ImageFormatRgba16:
    case ImageFormatRgb10A2:
    case ImageFormatRg16:
    case ImageFormatRg8:
    case ImageFormatR16:
    case ImageFormatR8:
    case ImageFormatRgba16Snorm:
    case ImageFormatRg16Snorm:
    case ImageFormatRg8Snorm:
    case ImageFormatR16Snorm:
    case ImageFormatR8Snorm:
    case ImageFormatRgba32i:
    case ImageFormatRgba16i:
    case ImageFormatRgba8i:
    case ImageFormatR32i:
    case ImageFormatRg32i:
    case ImageFormatRg16i:
    case ImageFormatRg8i:
    case ImageFormatR16i:
    case ImageFormatR8i:
    case ImageFormatRgba32ui:
    case ImageFormatRgba16ui:
    case ImageFormatRgba8ui:
    case ImageFormatR32ui:
    case ImageFormatRgb10a2ui:
    case ImageFormatRg32ui:
    case ImageFormatRg16ui:
    case ImageFormatRg8ui:
    case ImageFormatR16ui:
    case ImageFormatR8ui:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::ImageChannelOrder V) {
  switch(V) {
    case ImageChannelOrderR:
    case ImageChannelOrderA:
    case ImageChannelOrderRG:
    case ImageChannelOrderRA:
    case ImageChannelOrderRGB:
    case ImageChannelOrderRGBA:
    case ImageChannelOrderBGRA:
    case ImageChannelOrderARGB:
    case ImageChannelOrderIntensity:
    case ImageChannelOrderLuminance:
    case ImageChannelOrderRx:
    case ImageChannelOrderRGx:
    case ImageChannelOrderRGBx:
    case ImageChannelOrderDepth:
    case ImageChannelOrderDepthStencil:
    case ImageChannelOrderABGR:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::ImageChannelDataType V) {
  switch(V) {
    case ImageChannelDataTypeSnormInt8:
    case ImageChannelDataTypeSnormInt16:
    case ImageChannelDataTypeUnormInt8:
    case ImageChannelDataTypeUnormInt16:
    case ImageChannelDataTypeUnormShort565:
    case ImageChannelDataTypeUnormShort555:
    case ImageChannelDataTypeUnormInt101010:
    case ImageChannelDataTypeSignedInt8:
    case ImageChannelDataTypeSignedInt16:
    case ImageChannelDataTypeSignedInt32:
    case ImageChannelDataTypeUnsignedInt8:
    case ImageChannelDataTypeUnsignedInt16:
    case ImageChannelDataTypeUnsignedInt32:
    case ImageChannelDataTypeHalfFloat:
    case ImageChannelDataTypeFloat:
    case ImageChannelDataTypeUnormInt24:
    case ImageChannelDataTypeUnormInt101010_2:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::FPRoundingMode V) {
  switch(V) {
    case FPRoundingModeRTE:
    case FPRoundingModeRTZ:
    case FPRoundingModeRTP:
    case FPRoundingModeRTN:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::LinkageType V) {
  switch(V) {
    case LinkageTypeExport:
    case LinkageTypeImport:
    case LinkageTypeInternal:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::AccessQualifier V) {
  switch(V) {
    case AccessQualifierReadOnly:
    case AccessQualifierWriteOnly:
    case AccessQualifierReadWrite:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::FunctionParameterAttribute V) {
  switch(V) {
    case FunctionParameterAttributeZext:
    case FunctionParameterAttributeSext:
    case FunctionParameterAttributeByVal:
    case FunctionParameterAttributeSret:
    case FunctionParameterAttributeNoAlias:
    case FunctionParameterAttributeNoCapture:
    case FunctionParameterAttributeNoWrite:
    case FunctionParameterAttributeNoReadWrite:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::Decoration V) {
  switch(V) {
    case DecorationRelaxedPrecision:
    case DecorationSpecId:
    case DecorationBlock:
    case DecorationBufferBlock:
    case DecorationRowMajor:
    case DecorationColMajor:
    case DecorationArrayStride:
    case DecorationMatrixStride:
    case DecorationGLSLShared:
    case DecorationGLSLPacked:
    case DecorationCPacked:
    case DecorationBuiltIn:
    case DecorationNoPerspective:
    case DecorationFlat:
    case DecorationPatch:
    case DecorationCentroid:
    case DecorationSample:
    case DecorationInvariant:
    case DecorationRestrict:
    case DecorationAliased:
    case DecorationVolatile:
    case DecorationConstant:
    case DecorationCoherent:
    case DecorationNonWritable:
    case DecorationNonReadable:
    case DecorationUniform:
    case DecorationSaturatedConversion:
    case DecorationStream:
    case DecorationLocation:
    case DecorationComponent:
    case DecorationIndex:
    case DecorationBinding:
    case DecorationDescriptorSet:
    case DecorationOffset:
    case DecorationXfbBuffer:
    case DecorationXfbStride:
    case DecorationFuncParamAttr:
    case DecorationFPRoundingMode:
    case DecorationFPFastMathMode:
    case DecorationLinkageAttributes:
    case DecorationNoContraction:
    case DecorationInputAttachmentIndex:
    case DecorationAlignment:
    case DecorationMaxByteOffset:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::BuiltIn V) {
  switch(V) {
    case BuiltInPosition:
    case BuiltInPointSize:
    case BuiltInClipDistance:
    case BuiltInCullDistance:
    case BuiltInVertexId:
    case BuiltInInstanceId:
    case BuiltInPrimitiveId:
    case BuiltInInvocationId:
    case BuiltInLayer:
    case BuiltInViewportIndex:
    case BuiltInTessLevelOuter:
    case BuiltInTessLevelInner:
    case BuiltInTessCoord:
    case BuiltInPatchVertices:
    case BuiltInFragCoord:
    case BuiltInPointCoord:
    case BuiltInFrontFacing:
    case BuiltInSampleId:
    case BuiltInSamplePosition:
    case BuiltInSampleMask:
    case BuiltInFragDepth:
    case BuiltInHelperInvocation:
    case BuiltInNumWorkgroups:
    case BuiltInWorkgroupSize:
    case BuiltInWorkgroupId:
    case BuiltInLocalInvocationId:
    case BuiltInGlobalInvocationId:
    case BuiltInLocalInvocationIndex:
    case BuiltInWorkDim:
    case BuiltInGlobalSize:
    case BuiltInEnqueuedWorkgroupSize:
    case BuiltInGlobalOffset:
    case BuiltInGlobalLinearId:
    case BuiltInSubgroupSize:
    case BuiltInSubgroupMaxSize:
    case BuiltInNumSubgroups:
    case BuiltInNumEnqueuedSubgroups:
    case BuiltInSubgroupId:
    case BuiltInSubgroupLocalInvocationId:
    case BuiltInVertexIndex:
    case BuiltInInstanceIndex:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::Scope V) {
  switch(V) {
    case ScopeCrossDevice:
    case ScopeDevice:
    case ScopeWorkgroup:
    case ScopeSubgroup:
    case ScopeInvocation:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::GroupOperation V) {
  switch(V) {
    case GroupOperationReduce:
    case GroupOperationInclusiveScan:
    case GroupOperationExclusiveScan:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::KernelEnqueueFlags V) {
  switch(V) {
    case KernelEnqueueFlagsNoWait:
    case KernelEnqueueFlagsWaitKernel:
    case KernelEnqueueFlagsWaitWorkGroup:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::Capability V) {
  switch(V) {
    case CapabilityMatrix:
    case CapabilityShader:
    case CapabilityGeometry:
    case CapabilityTessellation:
    case CapabilityAddresses:
    case CapabilityLinkage:
    case CapabilityKernel:
    case CapabilityVector16:
    case CapabilityFloat16Buffer:
    case CapabilityFloat16:
    case CapabilityFloat64:
    case CapabilityInt64:
    case CapabilityInt64Atomics:
    case CapabilityImageBasic:
    case CapabilityImageReadWrite:
    case CapabilityImageMipmap:
    case CapabilityPipes:
    case CapabilityGroups:
    case CapabilityDeviceEnqueue:
    case CapabilityLiteralSampler:
    case CapabilityAtomicStorage:
    case CapabilityInt16:
    case CapabilityTessellationPointSize:
    case CapabilityGeometryPointSize:
    case CapabilityImageGatherExtended:
    case CapabilityStorageImageMultisample:
    case CapabilityUniformBufferArrayDynamicIndexing:
    case CapabilitySampledImageArrayDynamicIndexing:
    case CapabilityStorageBufferArrayDynamicIndexing:
    case CapabilityStorageImageArrayDynamicIndexing:
    case CapabilityClipDistance:
    case CapabilityCullDistance:
    case CapabilityImageCubeArray:
    case CapabilitySampleRateShading:
    case CapabilityImageRect:
    case CapabilitySampledRect:
    case CapabilityGenericPointer:
    case CapabilityInt8:
    case CapabilityInputAttachment:
    case CapabilitySparseResidency:
    case CapabilityMinLod:
    case CapabilitySampled1D:
    case CapabilityImage1D:
    case CapabilitySampledCubeArray:
    case CapabilitySampledBuffer:
    case CapabilityImageBuffer:
    case CapabilityImageMSArray:
    case CapabilityStorageImageExtendedFormats:
    case CapabilityImageQuery:
    case CapabilityDerivativeControl:
    case CapabilityInterpolationFunction:
    case CapabilityTransformFeedback:
    case CapabilityGeometryStreams:
    case CapabilityStorageImageReadWithoutFormat:
    case CapabilityStorageImageWriteWithoutFormat:
    case CapabilityMultiViewport:
    case CapabilitySubgroupDispatch:
    case CapabilityNamedBarrier:
    case CapabilityPipeStorage:
      return true;
    default:
      return false;
  }
}

inline bool
isValid(spv::Op V) {
  switch(V) {
    case OpNop:
    case OpUndef:
    case OpSourceContinued:
    case OpSource:
    case OpSourceExtension:
    case OpName:
    case OpMemberName:
    case OpString:
    case OpLine:
    case OpExtension:
    case OpExtInstImport:
    case OpExtInst:
    case OpMemoryModel:
    case OpEntryPoint:
    case OpExecutionMode:
    case OpCapability:
    case OpTypeVoid:
    case OpTypeBool:
    case OpTypeInt:
    case OpTypeFloat:
    case OpTypeVector:
    case OpTypeMatrix:
    case OpTypeImage:
    case OpTypeSampler:
    case OpTypeSampledImage:
    case OpTypeArray:
    case OpTypeRuntimeArray:
    case OpTypeStruct:
    case OpTypeOpaque:
    case OpTypePointer:
    case OpTypeFunction:
    case OpTypeEvent:
    case OpTypeDeviceEvent:
    case OpTypeReserveId:
    case OpTypeQueue:
    case OpTypePipe:
    case OpTypeForwardPointer:
    case OpConstantTrue:
    case OpConstantFalse:
    case OpConstant:
    case OpConstantComposite:
    case OpConstantSampler:
    case OpConstantNull:
    case OpSpecConstantTrue:
    case OpSpecConstantFalse:
    case OpSpecConstant:
    case OpSpecConstantComposite:
    case OpSpecConstantOp:
    case OpFunction:
    case OpFunctionParameter:
    case OpFunctionEnd:
    case OpFunctionCall:
    case OpVariable:
    case OpImageTexelPointer:
    case OpLoad:
    case OpStore:
    case OpCopyMemory:
    case OpCopyMemorySized:
    case OpAccessChain:
    case OpInBoundsAccessChain:
    case OpPtrAccessChain:
    case OpArrayLength:
    case OpGenericPtrMemSemantics:
    case OpInBoundsPtrAccessChain:
    case OpDecorate:
    case OpMemberDecorate:
    case OpDecorationGroup:
    case OpGroupDecorate:
    case OpGroupMemberDecorate:
    case OpVectorExtractDynamic:
    case OpVectorInsertDynamic:
    case OpVectorShuffle:
    case OpCompositeConstruct:
    case OpCompositeExtract:
    case OpCompositeInsert:
    case OpCopyObject:
    case OpTranspose:
    case OpSampledImage:
    case OpImageSampleImplicitLod:
    case OpImageSampleExplicitLod:
    case OpImageSampleDrefImplicitLod:
    case OpImageSampleDrefExplicitLod:
    case OpImageSampleProjImplicitLod:
    case OpImageSampleProjExplicitLod:
    case OpImageSampleProjDrefImplicitLod:
    case OpImageSampleProjDrefExplicitLod:
    case OpImageFetch:
    case OpImageGather:
    case OpImageDrefGather:
    case OpImageRead:
    case OpImageWrite:
    case OpImage:
    case OpImageQueryFormat:
    case OpImageQueryOrder:
    case OpImageQuerySizeLod:
    case OpImageQuerySize:
    case OpImageQueryLod:
    case OpImageQueryLevels:
    case OpImageQuerySamples:
    case OpConvertFToU:
    case OpConvertFToS:
    case OpConvertSToF:
    case OpConvertUToF:
    case OpUConvert:
    case OpSConvert:
    case OpFConvert:
    case OpQuantizeToF16:
    case OpConvertPtrToU:
    case OpSatConvertSToU:
    case OpSatConvertUToS:
    case OpConvertUToPtr:
    case OpPtrCastToGeneric:
    case OpGenericCastToPtr:
    case OpGenericCastToPtrExplicit:
    case OpBitcast:
    case OpSNegate:
    case OpFNegate:
    case OpIAdd:
    case OpFAdd:
    case OpISub:
    case OpFSub:
    case OpIMul:
    case OpFMul:
    case OpUDiv:
    case OpSDiv:
    case OpFDiv:
    case OpUMod:
    case OpSRem:
    case OpSMod:
    case OpFRem:
    case OpFMod:
    case OpVectorTimesScalar:
    case OpMatrixTimesScalar:
    case OpVectorTimesMatrix:
    case OpMatrixTimesVector:
    case OpMatrixTimesMatrix:
    case OpOuterProduct:
    case OpDot:
    case OpIAddCarry:
    case OpISubBorrow:
    case OpUMulExtended:
    case OpSMulExtended:
    case OpAny:
    case OpAll:
    case OpIsNan:
    case OpIsInf:
    case OpIsFinite:
    case OpIsNormal:
    case OpSignBitSet:
    case OpLessOrGreater:
    case OpOrdered:
    case OpUnordered:
    case OpLogicalEqual:
    case OpLogicalNotEqual:
    case OpLogicalOr:
    case OpLogicalAnd:
    case OpLogicalNot:
    case OpSelect:
    case OpIEqual:
    case OpINotEqual:
    case OpUGreaterThan:
    case OpSGreaterThan:
    case OpUGreaterThanEqual:
    case OpSGreaterThanEqual:
    case OpULessThan:
    case OpSLessThan:
    case OpULessThanEqual:
    case OpSLessThanEqual:
    case OpFOrdEqual:
    case OpFUnordEqual:
    case OpFOrdNotEqual:
    case OpFUnordNotEqual:
    case OpFOrdLessThan:
    case OpFUnordLessThan:
    case OpFOrdGreaterThan:
    case OpFUnordGreaterThan:
    case OpFOrdLessThanEqual:
    case OpFUnordLessThanEqual:
    case OpFOrdGreaterThanEqual:
    case OpFUnordGreaterThanEqual:
    case OpShiftRightLogical:
    case OpShiftRightArithmetic:
    case OpShiftLeftLogical:
    case OpBitwiseOr:
    case OpBitwiseXor:
    case OpBitwiseAnd:
    case OpNot:
    case OpBitFieldInsert:
    case OpBitFieldSExtract:
    case OpBitFieldUExtract:
    case OpBitReverse:
    case OpBitCount:
    case OpDPdx:
    case OpDPdy:
    case OpFwidth:
    case OpDPdxFine:
    case OpDPdyFine:
    case OpFwidthFine:
    case OpDPdxCoarse:
    case OpDPdyCoarse:
    case OpFwidthCoarse:
    case OpEmitVertex:
    case OpEndPrimitive:
    case OpEmitStreamVertex:
    case OpEndStreamPrimitive:
    case OpControlBarrier:
    case OpMemoryBarrier:
    case OpAtomicLoad:
    case OpAtomicStore:
    case OpAtomicExchange:
    case OpAtomicCompareExchange:
    case OpAtomicCompareExchangeWeak:
    case OpAtomicIIncrement:
    case OpAtomicIDecrement:
    case OpAtomicIAdd:
    case OpAtomicISub:
    case OpAtomicSMin:
    case OpAtomicUMin:
    case OpAtomicSMax:
    case OpAtomicUMax:
    case OpAtomicAnd:
    case OpAtomicOr:
    case OpAtomicXor:
    case OpPhi:
    case OpLoopMerge:
    case OpSelectionMerge:
    case OpLabel:
    case OpBranch:
    case OpBranchConditional:
    case OpSwitch:
    case OpKill:
    case OpReturn:
    case OpReturnValue:
    case OpUnreachable:
    case OpLifetimeStart:
    case OpLifetimeStop:
    case OpGroupAsyncCopy:
    case OpGroupWaitEvents:
    case OpGroupAll:
    case OpGroupAny:
    case OpGroupBroadcast:
    case OpGroupIAdd:
    case OpGroupFAdd:
    case OpGroupFMin:
    case OpGroupUMin:
    case OpGroupSMin:
    case OpGroupFMax:
    case OpGroupUMax:
    case OpGroupSMax:
    case OpReadPipe:
    case OpWritePipe:
    case OpReservedReadPipe:
    case OpReservedWritePipe:
    case OpReserveReadPipePackets:
    case OpReserveWritePipePackets:
    case OpCommitReadPipe:
    case OpCommitWritePipe:
    case OpIsValidReserveId:
    case OpGetNumPipePackets:
    case OpGetMaxPipePackets:
    case OpGroupReserveReadPipePackets:
    case OpGroupReserveWritePipePackets:
    case OpGroupCommitReadPipe:
    case OpGroupCommitWritePipe:
    case OpEnqueueMarker:
    case OpEnqueueKernel:
    case OpGetKernelNDrangeSubGroupCount:
    case OpGetKernelNDrangeMaxSubGroupSize:
    case OpGetKernelWorkGroupSize:
    case OpGetKernelPreferredWorkGroupSizeMultiple:
    case OpRetainEvent:
    case OpReleaseEvent:
    case OpCreateUserEvent:
    case OpIsValidEvent:
    case OpSetUserEventStatus:
    case OpCaptureEventProfilingInfo:
    case OpGetDefaultQueue:
    case OpBuildNDRange:
    case OpImageSparseSampleImplicitLod:
    case OpImageSparseSampleExplicitLod:
    case OpImageSparseSampleDrefImplicitLod:
    case OpImageSparseSampleDrefExplicitLod:
    case OpImageSparseSampleProjImplicitLod:
    case OpImageSparseSampleProjExplicitLod:
    case OpImageSparseSampleProjDrefImplicitLod:
    case OpImageSparseSampleProjDrefExplicitLod:
    case OpImageSparseFetch:
    case OpImageSparseGather:
    case OpImageSparseDrefGather:
    case OpImageSparseTexelsResident:
    case OpNoLine:
    case OpAtomicFlagTestAndSet:
    case OpAtomicFlagClear:
    case OpImageSparseRead:
    case OpSizeOf:
    case OpTypePipeStorage:
    case OpConstantPipeStorage:
    case OpCreatePipeFromPipeStorage:
    case OpGetKernelLocalSizeForSubgroupCount:
    case OpGetKernelMaxNumSubgroups:
    case OpTypeNamedBarrier:
    case OpNamedBarrierInitialize:
    case OpMemoryNamedBarrier:
    case OpModuleProcessed:
    case OpForward:
      return true;
    default:
      return false;
  }
}

inline bool
isValidImageOperandsMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= ImageOperandsBiasMask;
  ValidMask |= ImageOperandsLodMask;
  ValidMask |= ImageOperandsGradMask;
  ValidMask |= ImageOperandsConstOffsetMask;
  ValidMask |= ImageOperandsOffsetMask;
  ValidMask |= ImageOperandsConstOffsetsMask;
  ValidMask |= ImageOperandsSampleMask;
  ValidMask |= ImageOperandsMinLodMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidFPFastMathModeMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= FPFastMathModeNotNaNMask;
  ValidMask |= FPFastMathModeNotInfMask;
  ValidMask |= FPFastMathModeNSZMask;
  ValidMask |= FPFastMathModeAllowRecipMask;
  ValidMask |= FPFastMathModeFastMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidSelectionControlMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= SelectionControlFlattenMask;
  ValidMask |= SelectionControlDontFlattenMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidLoopControlMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= LoopControlUnrollMask;
  ValidMask |= LoopControlDontUnrollMask;
  ValidMask |= LoopControlDependencyInfiniteMask;
  ValidMask |= LoopControlDependencyLengthMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidFunctionControlMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= FunctionControlInlineMask;
  ValidMask |= FunctionControlDontInlineMask;
  ValidMask |= FunctionControlPureMask;
  ValidMask |= FunctionControlConstMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidMemorySemanticsMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= MemorySemanticsAcquireMask;
  ValidMask |= MemorySemanticsReleaseMask;
  ValidMask |= MemorySemanticsAcquireReleaseMask;
  ValidMask |= MemorySemanticsSequentiallyConsistentMask;
  ValidMask |= MemorySemanticsUniformMemoryMask;
  ValidMask |= MemorySemanticsSubgroupMemoryMask;
  ValidMask |= MemorySemanticsWorkgroupMemoryMask;
  ValidMask |= MemorySemanticsCrossWorkgroupMemoryMask;
  ValidMask |= MemorySemanticsAtomicCounterMemoryMask;
  ValidMask |= MemorySemanticsImageMemoryMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidMemoryAccessMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= MemoryAccessVolatileMask;
  ValidMask |= MemoryAccessAlignedMask;
  ValidMask |= MemoryAccessNontemporalMask;

  return (Mask & ~ValidMask) == 0;
}

inline bool
isValidKernelProfilingInfoMask(SPIRVWord Mask) {
  SPIRVWord ValidMask = 0u;
  ValidMask |= KernelProfilingInfoCmdExecTimeMask;

  return (Mask & ~ValidMask) == 0;
}

} /* namespace SPIRV */

#endif /* SPIRVISVALIDENUM_H_ */