RuntimeSpirv(3) Manual Page

VUID-RuntimeSpirv-vulkanMemoryModel-06265
If vulkanMemoryModel is enabled and vulkanMemoryModelDeviceScope is not enabled, Device memory scope must not be used

VUID-RuntimeSpirv-vulkanMemoryModel-06266
If vulkanMemoryModel is not enabled, QueueFamily memory scope must not be used

VUID-RuntimeSpirv-shaderSubgroupClock-06267
If shaderSubgroupClock is not enabled, the Subgroup scope must not be used for OpReadClockKHR

VUID-RuntimeSpirv-shaderDeviceClock-06268
If shaderDeviceClock is not enabled, the Device scope must not be used for OpReadClockKHR

VUID-RuntimeSpirv-None-09558
If dynamicRenderingLocalRead is not enabled, any variable created with a “Type” of OpTypeImage that has a “Dim” operand of SubpassData must be decorated with InputAttachmentIndex

VUID-RuntimeSpirv-OpTypeImage-09644
Any variable created with a “Type” of OpTypeImage that has a “Dim” operand of SubpassData and Arrayed=1 must be decorated with InputAttachmentIndex

VUID-RuntimeSpirv-apiVersion-07954
If VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.3, the VK_KHR_format_feature_flags2 extension is not supported, and shaderStorageImageWriteWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonWritable

VUID-RuntimeSpirv-apiVersion-07955
If VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.3, the VK_KHR_format_feature_flags2 extension is not supported, and shaderStorageImageReadWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonReadable

VUID-RuntimeSpirv-OpImageWrite-07112
OpImageWrite to any Image whose Image Format is not Unknown must have the Texel operand contain at least as many components as the corresponding VkFormat as given in the SPIR-V Image Format compatibility table

VUID-RuntimeSpirv-Location-06272
The sum of Location and the number of locations the variable it decorates consumes must be less than or equal to the value for the matching Execution Model defined in https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#interfaces-iointerfaces-limits

VUID-RuntimeSpirv-Location-06428
The maximum number of storage buffers, storage images, and output Location decorated color attachments written to in the Fragment Execution Model must be less than or equal to maxFragmentCombinedOutputResources

VUID-RuntimeSpirv-NonUniform-06274
If an instruction loads from or stores to a resource (including atomics and image instructions) and the resource descriptor being accessed is not dynamically uniform, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform

VUID-RuntimeSpirv-None-06275
shaderSubgroupExtendedTypes must be enabled for group operations to use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types

VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06276
If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Index” for OpGroupNonUniformQuadBroadcast must be dynamically uniform within the derivative group. Otherwise, “Index” must be a constant

VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06277
If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Id” for OpGroupNonUniformBroadcast must be dynamically uniform within the subgroup. Otherwise, “Id” must be a constant

VUID-RuntimeSpirv-None-06278
shaderBufferInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer or Uniform

VUID-RuntimeSpirv-None-06279
shaderSharedInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Workgroup

VUID-RuntimeSpirv-None-06284
shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderBufferFloat16Atomics, or shaderBufferFloat16AtomicAdd, or shaderBufferFloat16AtomicMinMax, or shaderBufferFloat32AtomicMinMax, or shaderBufferFloat64AtomicMinMax, or shaderFloat16VectorAtomics must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer

VUID-RuntimeSpirv-None-06285
shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, or shaderSharedFloat16Atomics, or shaderSharedFloat16AtomicAdd, or shaderSharedFloat16AtomicMinMax, or shaderSharedFloat32AtomicMinMax, or shaderSharedFloat64AtomicMinMax, or shaderFloat16VectorAtomics, must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of Workgroup

VUID-RuntimeSpirv-None-06286
shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd, or shaderImageFloat32AtomicMinMax, must be enabled for 32-bit floating-point atomic operations to be supported on a Pointer with a Storage Class of Image

VUID-RuntimeSpirv-None-06287
sparseImageFloat32Atomics, or sparseImageFloat32AtomicAdd, or sparseImageFloat32AtomicMinMax, must be enabled for 32-bit floating-point atomics to be supported on sparse images

VUID-RuntimeSpirv-None-06288
shaderImageInt64Atomics must be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Image

VUID-RuntimeSpirv-denormBehaviorIndependence-06289
If denormBehaviorIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, then the entry point must use the same denormals Execution Mode for both 16-bit and 64-bit floating-point types

VUID-RuntimeSpirv-denormBehaviorIndependence-06290
If denormBehaviorIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, then the entry point must use the same denormals Execution Mode for all floating-point types

VUID-RuntimeSpirv-roundingModeIndependence-06291
If roundingModeIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, then the entry point must use the same rounding Execution Mode for both 16-bit and 64-bit floating-point types

VUID-RuntimeSpirv-roundingModeIndependence-06292
If roundingModeIndependence is VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, then the entry point must use the same rounding Execution Mode for all floating-point types

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-06293
If shaderSignedZeroInfNanPreserveFloat16 is VK_FALSE, then SignedZeroInfNanPreserve for 16-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-06294
If shaderSignedZeroInfNanPreserveFloat32 is VK_FALSE, then SignedZeroInfNanPreserve for 32-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-06295
If shaderSignedZeroInfNanPreserveFloat64 is VK_FALSE, then SignedZeroInfNanPreserve for 64-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormPreserveFloat16-06296
If shaderDenormPreserveFloat16 is VK_FALSE, then DenormPreserve for 16-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormPreserveFloat32-06297
If shaderDenormPreserveFloat32 is VK_FALSE, then DenormPreserve for 32-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormPreserveFloat64-06298
If shaderDenormPreserveFloat64 is VK_FALSE, then DenormPreserve for 64-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat16-06299
If shaderDenormFlushToZeroFloat16 is VK_FALSE, then DenormFlushToZero for 16-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat32-06300
If shaderDenormFlushToZeroFloat32 is VK_FALSE, then DenormFlushToZero for 32-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderDenormFlushToZeroFloat64-06301
If shaderDenormFlushToZeroFloat64 is VK_FALSE, then DenormFlushToZero for 64-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTEFloat16-06302
If shaderRoundingModeRTEFloat16 is VK_FALSE, then RoundingModeRTE for 16-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTEFloat32-06303
If shaderRoundingModeRTEFloat32 is VK_FALSE, then RoundingModeRTE for 32-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTEFloat64-06304
If shaderRoundingModeRTEFloat64 is VK_FALSE, then RoundingModeRTE for 64-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTZFloat16-06305
If shaderRoundingModeRTZFloat16 is VK_FALSE, then RoundingModeRTZ for 16-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTZFloat32-06306
If shaderRoundingModeRTZFloat32 is VK_FALSE, then RoundingModeRTZ for 32-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderRoundingModeRTZFloat64-06307
If shaderRoundingModeRTZFloat64 is VK_FALSE, then RoundingModeRTZ for 64-bit floating-point type must not be used

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-09559
If shaderSignedZeroInfNanPreserveFloat16 is VK_FALSE then any FPFastMathDefault execution mode with a type of 16-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat16-09560
If shaderSignedZeroInfNanPreserveFloat16 is VK_FALSE then any FPFastMathMode decoration on an instruction with result type or any operand type that includes a 16-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-09561
If shaderSignedZeroInfNanPreserveFloat32 is VK_FALSE then any FPFastMathDefault execution mode with a type of 32-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat32-09562
If shaderSignedZeroInfNanPreserveFloat32 is VK_FALSE then any FPFastMathMode decoration on an instruction with result type or any operand type that includes a 32-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-09563
If shaderSignedZeroInfNanPreserveFloat64 is VK_FALSE then any FPFastMathDefault execution mode with a type of 64-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-shaderSignedZeroInfNanPreserveFloat64-09564
If shaderSignedZeroInfNanPreserveFloat64 is VK_FALSE then any FPFastMathMode decoration on an instruction with result type or any operand type that includes a 64-bit float must include the NSZ, NotInf, and NotNaN flags

VUID-RuntimeSpirv-Offset-06308
The Offset plus size of the type of each variable, in the output interface of the entry point being compiled, decorated with XfbBuffer must not be greater than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataSize

VUID-RuntimeSpirv-XfbBuffer-06309
For any given XfbBuffer value, define the buffer data size to be smallest number of bytes such that, for all outputs decorated with the same XfbBuffer value, the size of the output interface variable plus the Offset is less than or equal to the buffer data size. For a given Stream, the sum of all the buffer data sizes for all buffers writing to that stream the must not exceed VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreamDataSize

VUID-RuntimeSpirv-OpEmitStreamVertex-06310
The Stream value to OpEmitStreamVertex and OpEndStreamPrimitive must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams

VUID-RuntimeSpirv-transformFeedbackStreamsLinesTriangles-06311
If the geometry shader emits to more than one vertex stream and VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackStreamsLinesTriangles is VK_FALSE, then Execution Mode must be OutputPoints

VUID-RuntimeSpirv-Stream-06312
The stream number value to Stream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams

VUID-RuntimeSpirv-XfbStride-06313
The XFB Stride value to XfbStride must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride

VUID-RuntimeSpirv-PhysicalStorageBuffer64-06314
If the PhysicalStorageBuffer64 addressing model is enabled any load or store through a physical pointer type must be aligned to a multiple of the size of the largest scalar type in the pointed-to type

VUID-RuntimeSpirv-PhysicalStorageBuffer64-06315
If the PhysicalStorageBuffer64 addressing model is enabled the pointer value of a memory access instruction must be at least as aligned as specified by the Aligned memory access operand

VUID-RuntimeSpirv-OpTypeCooperativeMatrixNV-06316
For OpTypeCooperativeMatrixNV, the component type, scope, number of rows, and number of columns must match one of the matrices in any of the supported VkCooperativeMatrixPropertiesNV

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06317
For OpCooperativeMatrixMulAddNV, the type of A must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::KSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::AType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06318
For OpCooperativeMatrixMulAddNV, the type of B must have VkCooperativeMatrixPropertiesNV::KSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::BType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06319
For OpCooperativeMatrixMulAddNV, the type of C must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::CType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06320
For OpCooperativeMatrixMulAddNV, the type of Result must have VkCooperativeMatrixPropertiesNV::MSize rows and VkCooperativeMatrixPropertiesNV::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesNV::DType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddNV-06321
For OpCooperativeMatrixMulAddNV, the type of A, B, C, and Result must all have a scope of scope

VUID-RuntimeSpirv-OpTypeCooperativeMatrixNV-06322
OpTypeCooperativeMatrixNV and OpCooperativeMatrix* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeMatrixPropertiesNV::cooperativeMatrixSupportedStages

VUID-RuntimeSpirv-OpTypeCooperativeMatrixKHR-08974
For OpTypeCooperativeMatrixKHR, the component type, scope, number of rows, and number of columns must match one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR

VUID-RuntimeSpirv-MSize-08975
For OpCooperativeMatrixMulAddKHR, the type of A must have VkCooperativeMatrixPropertiesKHR::MSize rows and VkCooperativeMatrixPropertiesKHR::KSize columns and have a component type that matches VkCooperativeMatrixPropertiesKHR::AType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-08976
For OpCooperativeMatrixMulAddKHR, when the component type of A is a signed integer type, the MatrixASignedComponents cooperative matrix operand must be present

VUID-RuntimeSpirv-KSize-08977
For OpCooperativeMatrixMulAddKHR, the type of B must have VkCooperativeMatrixPropertiesKHR::KSize rows and VkCooperativeMatrixPropertiesKHR::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesKHR::BType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-08978
For OpCooperativeMatrixMulAddKHR, when the component type of B is a signed integer type, the MatrixBSignedComponents cooperative matrix operand must be present

VUID-RuntimeSpirv-MSize-08979
For OpCooperativeMatrixMulAddKHR, the type of C must have VkCooperativeMatrixPropertiesKHR::MSize rows and VkCooperativeMatrixPropertiesKHR::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesKHR::CType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-08980
For OpCooperativeMatrixMulAddKHR, when the component type of C is a signed integer type, the MatrixCSignedComponents cooperative matrix operand must be present

VUID-RuntimeSpirv-MSize-08981
For OpCooperativeMatrixMulAddKHR, the type of Result must have VkCooperativeMatrixPropertiesKHR::MSize rows and VkCooperativeMatrixPropertiesKHR::NSize columns and have a component type that matches VkCooperativeMatrixPropertiesKHR::ResultType

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-08982
For OpCooperativeMatrixMulAddKHR, when the component type of Result is a signed integer type, the MatrixResultSignedComponents cooperative matrix operand must be present

VUID-RuntimeSpirv-saturatingAccumulation-08983
For OpCooperativeMatrixMulAddKHR, the SaturatingAccumulation cooperative matrix operand must be present if and only if VkCooperativeMatrixPropertiesKHR::saturatingAccumulation is VK_TRUE

VUID-RuntimeSpirv-scope-08984
For OpCooperativeMatrixMulAddKHR, the type of A, B, C, and Result must all have a scope of scope

VUID-RuntimeSpirv-cooperativeMatrixSupportedStages-08985
OpTypeCooperativeMatrixKHR and OpCooperativeMatrix* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeMatrixPropertiesKHR::cooperativeMatrixSupportedStages

VUID-RuntimeSpirv-DescriptorSet-06323
DescriptorSet and Binding decorations must obey the constraints on Storage Class, type, and descriptor type described in DescriptorSet and Binding Assignment

VUID-RuntimeSpirv-OpCooperativeMatrixLoadNV-06324
For OpCooperativeMatrixLoadNV and OpCooperativeMatrixStoreNV instructions, the Pointer and Stride operands must be aligned to at least the lesser of 16 bytes or the natural alignment of a row or column (depending on ColumnMajor) of the matrix (where the natural alignment is the number of columns/rows multiplied by the component size)

VUID-RuntimeSpirv-MeshNV-07113
For mesh shaders using the MeshNV Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices

VUID-RuntimeSpirv-MeshNV-07114
For mesh shaders using the MeshNV Execution Model the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives

VUID-RuntimeSpirv-MeshEXT-07115
For mesh shaders using the MeshEXT Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputVertices

VUID-RuntimeSpirv-MeshEXT-07332
For mesh shaders using the MeshEXT Execution Model the “Vertex Count” operand of OpSetMeshOutputsEXT must be less than or equal to OutputVertices OpExecutionMode

VUID-RuntimeSpirv-MeshEXT-07116
For mesh shaders using the MeshEXT Execution Model the OutputPrimitivesEXT OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputPrimitives

VUID-RuntimeSpirv-MeshEXT-07333
For mesh shaders using the MeshEXT Execution Model the “Primitive Count” operand of OpSetMeshOutputsEXT must be less than or equal to OutputPrimitivesEXT OpExecutionMode

VUID-RuntimeSpirv-TaskEXT-07117
In task shaders using the TaskEXT Execution Model OpEmitMeshTasksEXT must be called exactly once under dynamically uniform conditions

VUID-RuntimeSpirv-MeshEXT-07118
In mesh shaders using the MeshEXT Execution Model OpSetMeshOutputsEXT must be called at most once under dynamically uniform conditions

VUID-RuntimeSpirv-TaskEXT-07291
In task shaders using the TaskEXT Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[0]

VUID-RuntimeSpirv-TaskEXT-07292
In task shaders using the TaskEXT Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[1]

VUID-RuntimeSpirv-TaskEXT-07293
In task shaders using the TaskEXT Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[2]

VUID-RuntimeSpirv-TaskEXT-07294
In task shaders using the TaskEXT Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupInvocations

VUID-RuntimeSpirv-MeshEXT-07295
For mesh shaders using the MeshEXT Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[0]

VUID-RuntimeSpirv-MeshEXT-07296
For mesh shaders using the MeshEXT Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[1]

VUID-RuntimeSpirv-MeshEXT-07297
For mesh shaders using the MeshEXT Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[2]

VUID-RuntimeSpirv-MeshEXT-07298
For mesh shaders using the MeshEXT Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupInvocations

VUID-RuntimeSpirv-TaskEXT-07299
In task shaders using the TaskEXT Execution Model the value of the “Group Count X” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[0]

VUID-RuntimeSpirv-TaskEXT-07300
In task shaders using the TaskEXT Execution Model the value of the “Group Count Y” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[1]

VUID-RuntimeSpirv-TaskEXT-07301
In task shaders using the TaskEXT Execution Model the value of the “Group Count Z” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[2]

VUID-RuntimeSpirv-TaskEXT-07302
In task shaders using the TaskEXT Execution Model the product of the “Group Count” operands of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupTotalCount

VUID-RuntimeSpirv-maxMeshSharedMemorySize-08754
The sum of size in bytes for variables and padding in the Workgroup Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshSharedMemorySize

VUID-RuntimeSpirv-maxMeshPayloadAndSharedMemorySize-08755
The sum of size in bytes for variables and padding in the TaskPayloadWorkgroupEXT or Workgroup Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshPayloadAndSharedMemorySize

VUID-RuntimeSpirv-maxMeshOutputMemorySize-08756
The sum of size in bytes for variables in the Output Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshOutputMemorySize according to the formula in Mesh Shader Output

VUID-RuntimeSpirv-maxMeshPayloadAndOutputMemorySize-08757
The sum of size in bytes for variables and in the TaskPayloadWorkgroupEXT or Output Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshPayloadAndOutputMemorySize according to the formula in Mesh Shader Output

VUID-RuntimeSpirv-maxTaskPayloadSize-08758
The sum of size in bytes for variables and in the TaskPayloadWorkgroupEXT Storage Class in the TaskEXT Execution Model must be less than or equal to maxTaskPayloadSize

VUID-RuntimeSpirv-maxTaskSharedMemorySize-08759
The sum of size in bytes for variables and padding in the Workgroup Storage Class in the TaskEXT Execution Model must be less than or equal to maxTaskSharedMemorySize

VUID-RuntimeSpirv-maxTaskPayloadAndSharedMemorySize-08760
The sum of size in bytes for variables and padding in the TaskPayloadWorkgroupEXT or Workgroup Storage Class in the TaskEXT Execution Model must be less than or equal to maxTaskPayloadAndSharedMemorySize

VUID-RuntimeSpirv-OpCooperativeMatrixLoadKHR-08986
For OpCooperativeMatrixLoadKHR and OpCooperativeMatrixStoreKHR instructions, the Pointer and Stride operands must be aligned to at least the lesser of 16 bytes or the natural alignment of a row or column (depending on ColumnMajor) of the matrix (where the natural alignment is the number of columns/rows multiplied by the component size)

VUID-RuntimeSpirv-shaderSampleRateInterpolationFunctions-06325
If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::shaderSampleRateInterpolationFunctions is VK_FALSE, then GLSL.std.450 fragment interpolation functions are not supported by the implementation and OpCapability must not be set to InterpolationFunction

VUID-RuntimeSpirv-tessellationShader-06326
If tessellationShader is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationIsolines is VK_FALSE, then OpExecutionMode must not be set to IsoLines

VUID-RuntimeSpirv-tessellationShader-06327
If tessellationShader is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationPointMode is VK_FALSE, then OpExecutionMode must not be set to PointMode

VUID-RuntimeSpirv-storageBuffer8BitAccess-06328
If storageBuffer8BitAccess is VK_FALSE, then objects containing an 8-bit integer element must not have Storage Class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer

VUID-RuntimeSpirv-uniformAndStorageBuffer8BitAccess-06329
If uniformAndStorageBuffer8BitAccess is VK_FALSE, then objects in the Uniform Storage Class with the Block decoration must not have an 8-bit integer member

VUID-RuntimeSpirv-storagePushConstant8-06330
If storagePushConstant8 is VK_FALSE, then objects containing an 8-bit integer element must not have Storage Class of PushConstant

VUID-RuntimeSpirv-storageBuffer16BitAccess-06331
If storageBuffer16BitAccess is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer

VUID-RuntimeSpirv-uniformAndStorageBuffer16BitAccess-06332
If uniformAndStorageBuffer16BitAccess is VK_FALSE, then objects in the Uniform Storage Class with the Block decoration must not have 16-bit integer or 16-bit floating-point members

VUID-RuntimeSpirv-storagePushConstant16-06333
If storagePushConstant16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of PushConstant

VUID-RuntimeSpirv-storageInputOutput16-06334
If storageInputOutput16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of Input or Output

VUID-RuntimeSpirv-None-06337
shaderBufferFloat16Atomics, or shaderBufferFloat16AtomicAdd, or shaderBufferFloat16AtomicMinMax, or shaderSharedFloat16Atomics, or shaderSharedFloat16AtomicAdd, or shaderSharedFloat16AtomicMinMax must be enabled for 16-bit floating point atomic operations

VUID-RuntimeSpirv-None-06338
shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd or shaderBufferFloat32AtomicMinMax, or shaderSharedFloat32AtomicMinMax, or shaderImageFloat32AtomicMinMax must be enabled for 32-bit floating point atomic operations

VUID-RuntimeSpirv-None-06339
shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, or shaderBufferFloat64AtomicMinMax, or shaderSharedFloat64AtomicMinMax, must be enabled for 64-bit floating point atomic operations

VUID-RuntimeSpirv-shaderFloat16VectorAtomics-09581
shaderFloat16VectorAtomics, must be enabled for 16-bit floating-point, 2- and 4-component vector atomic operations to be supported

VUID-RuntimeSpirv-NonWritable-06340
If fragmentStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the fragment stage must be decorated with the NonWritable decoration

VUID-RuntimeSpirv-NonWritable-06341
If vertexPipelineStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the vertex, tessellation, and geometry stages must be decorated with the NonWritable decoration

VUID-RuntimeSpirv-None-06342
If subgroupQuadOperationsInAllStages is VK_FALSE, then quad subgroup operations must not be used except for in fragment and compute stages

VUID-RuntimeSpirv-None-06343
Group operations with subgroup scope must not be used if the shader stage is not in subgroupSupportedStages

VUID-RuntimeSpirv-Offset-06344
The first element of the Offset operand of InterpolateAtOffset must be greater than or equal to:
frag_width × minInterpolationOffset
where frag_width is the width of the current fragment in pixels

VUID-RuntimeSpirv-Offset-06345
The first element of the Offset operand of InterpolateAtOffset must be less than or equal to
frag_width × (maxInterpolationOffset + ULP ) - ULP
where frag_width is the width of the current fragment in pixels and ULP = 1 / 2^{subPixelInterpolationOffsetBits}^

VUID-RuntimeSpirv-Offset-06346
The second element of the Offset operand of InterpolateAtOffset must be greater than or equal to
frag_height × minInterpolationOffset
where frag_height is the height of the current fragment in pixels

VUID-RuntimeSpirv-Offset-06347
The second element of the Offset operand of InterpolateAtOffset must be less than or equal to
frag_height × (maxInterpolationOffset + ULP ) - ULP
where frag_height is the height of the current fragment in pixels and ULP = 1 / 2^{subPixelInterpolationOffsetBits}^

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06348
For OpRayQueryInitializeKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06349
For OpRayQueryInitializeKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06350
For OpRayQueryInitializeKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06351
For OpRayQueryInitializeKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06352
For OpRayQueryInitializeKHR instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06889
For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06890
For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06891
For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06353
For OpRayQueryGenerateIntersectionKHR instructions, Hit T must satisfy the condition RayTmin ≤ Hit T ≤ RayTmax, where RayTmin is equal to the value returned by OpRayQueryGetRayTMinKHR with the same ray query object, and RayTmax is equal to the value of OpRayQueryGetIntersectionTKHR for the current committed intersection with the same ray query object

VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06354
For OpRayQueryGenerateIntersectionKHR instructions, Acceleration Structure must not be built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-flags-08761
For OpRayQueryGetIntersectionTriangleVertexPositionsKHR instructions, Acceleration Structure must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR in flags

VUID-RuntimeSpirv-OpTraceRayKHR-06355
For OpTraceRayKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpTraceRayKHR-06356
For OpTraceRayKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpTraceRayKHR-06552
For OpTraceRayKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06892
For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06893
For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06553
For OpTraceRayKHR instructions, if the Rayflags operand contains SkipTrianglesKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR set

VUID-RuntimeSpirv-OpTraceRayKHR-06554
For OpTraceRayKHR instructions, if the Rayflags operand contains SkipAABBsKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR set

VUID-RuntimeSpirv-OpTraceRayKHR-06357
For OpTraceRayKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpTraceRayKHR-06358
For OpTraceRayKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpTraceRayKHR-06359
For OpTraceRayKHR instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure

VUID-RuntimeSpirv-OpReportIntersectionKHR-06998
The value of the “Hit Kind” operand of OpReportIntersectionKHR must be in the range [0,127]

VUID-RuntimeSpirv-OpTraceRayKHR-06360
For OpTraceRayKHR instructions, if Acceleration Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpTraceRayMotionNV-06361
For OpTraceRayMotionNV instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpTraceRayMotionNV-06362
For OpTraceRayMotionNV instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpTraceRayMotionNV-06363
For OpTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpTraceRayMotionNV-06364
For OpTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpTraceRayMotionNV-06365
For OpTraceRayMotionNV instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-OpTraceRayMotionNV-06366
For OpTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

VUID-RuntimeSpirv-OpTraceRayMotionNV-06367
For OpTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07704
For OpHitObjectTraceRayMotionNV instructions, if Acceleration Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07705
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07706
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07707
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07708
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07709
For OpHitObjectTraceRayMotionNV instructions, Acceleration Structure must be an acceleration structure built as a top-level acceleration structure with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07710
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07711
For OpHitObjectTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07712
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07713
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07714
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07715
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, if the Rayflags operand contains SkipTrianglesKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07716
For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, if the Rayflags operand contains SkipAABBsKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR set

VUID-RuntimeSpirv-x-06429
In compute shaders using the GLCompute Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]

VUID-RuntimeSpirv-y-06430
In compute shaders using the GLCompute Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]

VUID-RuntimeSpirv-z-06431
In compute shaders using the GLCompute Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]

VUID-RuntimeSpirv-x-06432
In compute shaders using the GLCompute Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations

VUID-RuntimeSpirv-LocalSizeId-06434
If Execution Mode LocalSizeId is used, maintenance4 must be enabled

VUID-RuntimeSpirv-maintenance4-06817
If maintenance4 is not enabled, any OpTypeVector output interface variables must not have a higher Component Count than a matching OpTypeVector input interface variable

VUID-RuntimeSpirv-OpEntryPoint-08743
Any user-defined variables shared between the OpEntryPoint of two shader stages, and declared with Input as its Storage Class for the subsequent shader stage, must have all Location slots and Component words declared in the preceding shader stage’s OpEntryPoint with Output as the Storage Class

VUID-RuntimeSpirv-OpEntryPoint-07754
Any user-defined variables between the OpEntryPoint of two shader stages must have the same type and width for each Component

VUID-RuntimeSpirv-OpVariable-08746
Any OpVariable, Block-decorated OpTypeStruct, or Block-decorated OpTypeStruct members shared between the OpEntryPoint of two shader stages must have matching decorations as defined in interface matching

VUID-RuntimeSpirv-Workgroup-06530
The sum of size in bytes for variables and padding in the Workgroup Storage Class in the GLCompute Execution Model must be less than or equal to maxComputeSharedMemorySize

VUID-RuntimeSpirv-shaderZeroInitializeWorkgroupMemory-06372
If shaderZeroInitializeWorkgroupMemory is not enabled, any OpVariable with Workgroup as its Storage Class must not have an Initializer operand

VUID-RuntimeSpirv-OpImage-06376
If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be greater than or equal to minTexelGatherOffset

VUID-RuntimeSpirv-OpImage-06377
If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be less than or equal to maxTexelGatherOffset

VUID-RuntimeSpirv-OpImageSample-06435
If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be greater than or equal to minTexelOffset

VUID-RuntimeSpirv-OpImageSample-06436
If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be less than or equal to maxTexelOffset

VUID-RuntimeSpirv-samples-08725
If an OpTypeImage has an MS operand 0, its bound image must have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT

VUID-RuntimeSpirv-samples-08726
If an OpTypeImage has an MS operand 1, its bound image must not have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT

VUID-RuntimeSpirv-SampleRateShading-06378
If the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then the SPIR-V fragment shader Capability SampleRateShading must not be enabled

VUID-RuntimeSpirv-SubgroupUniformControlFlowKHR-06379
The Execution Mode SubgroupUniformControlFlowKHR must not be applied to an entry point unless shaderSubgroupUniformControlFlow is enabled and the corresponding shader stage bit is set in subgroup supportedStages and the entry point does not execute any invocation repack instructions

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06767
If shaderEarlyAndLateFragmentTests is not enabled, the EarlyAndLateFragmentTestsEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06768
If shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefUnchangedFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06769
If shaderEarlyAndLateFragmentTests is not enabled, the StencilRefUnchangedBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06770
If shaderEarlyAndLateFragmentTests is not enabled, the StencilRefGreaterFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06771
If shaderEarlyAndLateFragmentTests is not enabled, the StencilRefGreaterBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06772
If shaderEarlyAndLateFragmentTests is not enabled, the StencilRefLessFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06773
If shaderEarlyAndLateFragmentTests is not enabled, the StencilRefLessBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06979
If an OpImageWeightedSampleQCOM operation is used, then the Texture Sampled Image and Weight Image parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06980
If an OpImageWeightedSampleQCOM operation is used, then the Weight Image parameter must be of Storage Class UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=1, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06981
If an OpImageWeightedSampleQCOM operation is used, then the Weight Image parameter must be decorated with WeightTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchSADQCOM-06982
If an OpImageBlockMatchSADQCOM or OpImageBlockMatchSSDQCOM operation is used, then the target sampled image, reference sampled image, and Block Size parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06983
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must be of storage class UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=0, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06984
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then the target sampled image and reference sampled image parameters must be decorated with BlockMatchTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06985
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created using an identical sampler object

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06986
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06987
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06988
If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then Block Size less than or equal to maxBlockMatchRegion

VUID-RuntimeSpirv-OpImageBoxFilterQCOM-06989
If an OpImageBoxFilterQCOM operation is used, then Box Size.y must be equal to or greater than 1.0 and less than or equal to maxBoxFilterBlockSize.height

VUID-RuntimeSpirv-OpImageBoxFilterQCOM-06990
If an OpImageBoxFilterQCOM operation is used, then Sampled Texture Image and Box Size parameters must be dynamically uniform

VUID-RuntimeSpirv-OpEntryPoint-08727
Each OpEntryPoint must not have more than one variable decorated with InputAttachmentIndex per image aspect of the attachment image bound to it, either explicitly or implicitly as described by input attachment interface

VUID-RuntimeSpirv-shaderTileImageColorReadAccess-08728
If shaderTileImageColorReadAccess is not enabled, OpColorAttachmentReadEXT operation must not be used

VUID-RuntimeSpirv-shaderTileImageDepthReadAccess-08729
If shaderTileImageDepthReadAccess is not enabled, OpDepthAttachmentReadEXT operation must not be used

VUID-RuntimeSpirv-shaderTileImageStencilReadAccess-08730
If shaderTileImageStencilReadAccess is not enabled, OpStencilAttachmentReadEXT operation must not be used

VUID-RuntimeSpirv-minSampleShading-08731
If sample shading is enabled and minSampleShading is 1.0, the sample operand of any OpColorAttachmentReadEXT, OpDepthAttachmentReadEXT, or OpStencilAttachmentReadEXT operation must evaluate to the value of the coverage index for any given fragment invocation

VUID-RuntimeSpirv-minSampleShading-08732
If sample shading is enabled and any of the OpColorAttachmentReadEXT, OpDepthAttachmentReadEXT, or OpStencilAttachmentReadEXT operations are used, then minSampleShading must be 1.0

VUID-RuntimeSpirv-MeshEXT-09218
In mesh shaders using the MeshEXT or MeshNV Execution Model and the OutputPoints Execution Mode, if maintenance5 is not enabled, and if the number of output points is greater than 0, a PointSize decorated variable must be written to for each output point

VUID-RuntimeSpirv-maintenance5-09190
If maintenance5 is enabled and a PointSize decorated variable is written to, all execution paths must write to a PointSize decorated variable

VUID-RuntimeSpirv-ShaderEnqueueAMDX-09191
The ShaderEnqueueAMDX capability must only be used in shaders with the GLCompute execution model

VUID-RuntimeSpirv-NodePayloadAMDX-09192
Variables in the NodePayloadAMDX storage class must only be declared in the GLCompute execution model

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09193
Variables declared in the NodePayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09194
Variables declared in the NodeOutputPayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09195
For a given entry point, the sum of the size of any variable in the NodePayloadAMDX storage class, and the combined size of all statically initialized variables in the NodeOutputPayloadAMDX storage class must not be greater than maxExecutionGraphShaderPayloadSize

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadCount-09196
Shaders must not statically initialize more than maxExecutionGraphShaderPayloadCount variables in the NodeOutputPayloadAMDX storage class

VUID-RuntimeSpirv-maxExecutionGraphShaderOutputNodes-09197
Shaders must not include more than maxExecutionGraphShaderOutputNodes instances of OpInitializeNodePayloadsAMDX

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09219
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then the target sampled image, reference sampled image, and Block Size parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09220
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target sampled image and reference sampled image parameters must be of storage class UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=0, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09221
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then the target sampled image and reference sampled image parameters must be decorated with BlockMatchTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09222
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target sampled image and reference sampled image parameters must have been created using an identical sampler object

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09223
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09224
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target sampled image and reference sampled image parameters must have been created with sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-maxBlockMatchRegion-09225
If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then Block Size less than or equal to maxBlockMatchRegion

VUID-RuntimeSpirv-pNext-09226
If a OpImageBlockMatchWindow*QCOM operation is used, then target sampled image must have been created using asampler object that included VkSamplerBlockMatchWindowCreateInfoQCOM in the pNext chain

VUID-RuntimeSpirv-MaximallyReconvergesKHR-09565
The execution mode MaximallyReconvergesKHR must not be applied to an entry point unless the entry point does not execute any invocation repack instructions

VUID-RuntimeSpirv-shaderSubgroupRotateClustered-09566
If shaderSubgroupRotateClustered is VK_FALSE, then the ClusterSize operand to OpGroupNonUniformRotateKHR must not be used

VUID-RuntimeSpirv-protectedNoFault-09645
If protectedNoFault is not supported, the Storage Class of the PhysicalStorageBuffer must not be used if the buffer being accessed is protected