RuntimeSpirv(3)

# RuntimeSpirv(3) Manual Page

## Name

RuntimeSpirv - Runtime SPIR-V Validation

Loading… please wait.

## Description

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-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-Fragment-06427
  When blending is enabled and one of the dual source blend modes is in use, the maximum number of output attachments written to in the `Fragment` `Execution` `Model` must be less than or equal to `maxFragmentDualSrcAttachments`

- 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` 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` 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-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-
  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-
  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-
  For `OpCooperativeMatrixMulAddKHR`, when the component type of `A` is a signed integer type, the `MatrixASignedComponents` cooperative matrix operand must be present.

- VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-
  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-
  For `OpCooperativeMatrixMulAddKHR`, when the component type of `B` is a signed integer type, the `MatrixBSignedComponents` cooperative matrix operand must be present.

- VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-
  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-
  For `OpCooperativeMatrixMulAddKHR`, when the component type of `C` is a signed integer type, the `MatrixCSignedComponents` cooperative matrix operand must be present.

- VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-
  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-
  For `OpCooperativeMatrixMulAddKHR`, when the component type of `Result` is a signed integer type, the `MatrixResultSignedComponents` cooperative matrix operand must be present.

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

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

- VUID-RuntimeSpirv-OpTypeCooperativeMatrixKHR-
  `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-
  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-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:
  fragwidth × `minInterpolationOffset`
  where fragwidth 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
  fragwidth × (`maxInterpolationOffset` + ULP ) - ULP
  where fragwidth 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
  fragheight × `minInterpolationOffset`
  where fragheight 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
  fragheight × (`maxInterpolationOffset` + ULP ) - ULP
  where fragheight 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
  The `x` size in `LocalSize` or `LocalSizeId` must be less than or equal to VkPhysicalDeviceLimits::`maxComputeWorkGroupSize`[0]

- VUID-RuntimeSpirv-y-06430
  The `y` size in `LocalSize` or `LocalSizeId` must be less than or equal to VkPhysicalDeviceLimits::`maxComputeWorkGroupSize`[1]

- VUID-RuntimeSpirv-z-06431
  The `z` size in `LocalSize` or `LocalSizeId` must be less than or equal to VkPhysicalDeviceLimits::`maxComputeWorkGroupSize`[2]

- VUID-RuntimeSpirv-x-06432
  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 sampler object with `unnormalizeCordinates` 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 sampler object with `unnormalizeCordinates` 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

## See Also

No cross-references are available

## Document Notes

For more information, see the Vulkan Specification

This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.

## Copyright

Copyright 2014-2023 The Khronos Group Inc.

SPDX-License-Identifier: CC-BY-4.0