RuntimeSpirv

The following rules must be validated at runtime. These rules depend on knowledge of the implementation and its capabilities and knowledge of runtime information, such as enabled features.

Valid Usage

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 declared as an OpTypeArray where the Element

Type is an OpTypeImage with a Dim operand of SubpassData must be decorated with InputAttachmentIndex

VUID-RuntimeSpirv-shaderStorageImageWriteWithoutFormat-07956

If the VK_KHR_format_feature_flags2 extension is not enabled, 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 Unknownmust be decorated with NonWritable

VUID-RuntimeSpirv-shaderStorageImageReadWithoutFormat-07957

If the VK_KHR_format_feature_flags2 extension is not enabled, 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 Table 19. Shader Input and Output Locations

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-UniformBufferArrayNonUniformIndexing-10134

If the UniformBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a uniform buffer, the uniform buffer through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-SampledImageArrayNonUniformIndexing-10135

If the SampledImageArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a sampled image or sampler, the sampled image or sampler through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-StorageBufferArrayNonUniformIndexing-10136

If the StorageBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a storage buffer, the storage buffer through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-StorageImageArrayNonUniformIndexing-10137

If the StorageImageArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a storage image, the storage image through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-InputAttachmentArrayNonUniformIndexing-10138

If the InputAttachmentArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through an input attachment, the input attachment through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-UniformTexelBufferArrayNonUniformIndexing-10139

If the UniformTexelBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a uniform texel buffer, the uniform texel buffer through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-StorageTexelBufferArrayNonUniformIndexing-10140

If the StorageTexelBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a storage texel buffer, the storage texel buffer through which that memory is accessed must be dynamically uniform within the invocation group

VUID-RuntimeSpirv-None-10148

If an instruction accesses memory through any resource, and the resource through which that memory is accessed is not uniform within the invocation group, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform

VUID-RuntimeSpirv-None-06278

shaderBufferInt64Atomicsmust 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

shaderSharedInt64Atomicsmust 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 shaderFloat16VectorAtomicsmust 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

shaderImageInt64Atomicsmust 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-OpTypeCooperativeMatrixMulAddNV-10059

For OpTypeCooperativeMatrixMulAddNV, the operands must match a supported VkCooperativeMatrixPropertiesNV, such that:- The type of A must have Rows match VkCooperativeMatrixPropertiesNV::MSize, Columns match VkCooperativeMatrixPropertiesNV::KSize, and ComponentType match VkCooperativeMatrixPropertiesNV::AType.

The type of B must have Rows match VkCooperativeMatrixPropertiesNV::KSize, Columns match VkCooperativeMatrixPropertiesNV::NSize, and ComponentType match VkCooperativeMatrixPropertiesNV::BType.
The type of C must have Rows match VkCooperativeMatrixPropertiesNV::MSize, Columns match VkCooperativeMatrixPropertiesNV::NSize, and ComponentType match VkCooperativeMatrixPropertiesNV::CType.
The type of Result must have Rows match VkCooperativeMatrixPropertiesNV::MSize, Columns match VkCooperativeMatrixPropertiesNV::NSize, and ComponentType match VkCooperativeMatrixPropertiesNV::DType.
The scope of all cooperative matrix operands must be VkScopeNV::VK_SCOPE_SUBGROUP_NV.
If ComponentType of A, B, C, or Result is a signed integral type, the Signedness operand of the OpTypeInt must be 1.
If ComponentType of A, B, C, or Result is an unsigned integral type, the Signedness operand of the OpTypeInt must be 0 ::

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-OpCooperativeMatrixMulAddKHR-10060

For OpCooperativeMatrixMulAddKHR, the operands must match a supported VkCooperativeMatrixPropertiesKHR, such that:- The type of A must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::KSize, Use be MatrixAKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::AType.

The type of B must have Rows match VkCooperativeMatrixPropertiesKHR::KSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixBKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::BType.
The type of C must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::CType.
The type of Result must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::ResultType.
If and only if VkCooperativeMatrixPropertiesKHR::AType is a signed integer type, MatrixASignedComponents must be used.
If and only if VkCooperativeMatrixPropertiesKHR::BType is a signed integer type, MatrixBSignedComponents must be used.
If and only if VkCooperativeMatrixPropertiesKHR::CType is a signed integer type, MatrixCSignedComponents must be used.
If and only if VkCooperativeMatrixPropertiesKHR::ResultType is a signed integer type, MatrixResultSignedComponents must be used.
If and only if VkCooperativeMatrixPropertiesKHR::saturatingAccumulation is VK_TRUE, SaturatingAccumulationKHR must be used.
If and only if VkCooperativeMatrixPropertiesKHR::saturatingAccumulation is VK_FALSE, SaturatingAccumulationKHR must not be used.
The scope of all cooperative matrix operands must be VkScopeKHR::VK_SCOPE_SUBGROUP_KHR ::

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 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 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 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-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-Offset-06344

The first element of the Offset operand of InterpolateAtOffsetmust 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 InterpolateAtOffsetmust 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 Tmust 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 Structuremust be an acceleration structure built as a top-level acceleration structure

VUID-RuntimeSpirv-OpReportIntersectionKHR-06998

The value of the Hit Kind operand of OpReportIntersectionKHRmust 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, the corresponding shader stage bit is set in subgroupSupportedStages, 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

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06987

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 or MeshEXT execution model

VUID-RuntimeSpirv-NodePayloadAMDX-09192

Variables in the NodePayloadAMDX storage class must only be declared in the GLCompute or MeshEXT 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