# 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 the `vulkanMemoryModel` feature is enabled and the `vulkanMemoryModelDeviceScope` feature is not enabled, `Device` memory scope must not be used

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

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

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

- VUID-RuntimeSpirv-None-09558
  If the `dynamicRenderingLocalRead` feature 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-apiVersion-07954
  If VkPhysicalDeviceProperties::`apiVersion` is less than Vulkan 1.3, the VK_KHR_format_feature_flags2 extension is not supported, and the `shaderStorageImageWriteWithoutFormat` feature 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 the `shaderStorageImageReadWithoutFormat` feature 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/latest/html/vkspec.html#interfaces-iointerfaces-limits

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

- VUID-RuntimeSpirv-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 or subgroup

- 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 or subgroup

- 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 or subgroup

- 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 or subgroup

- 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 or subgroup

- 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 or subgroup

- 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 or subgroup

- VUID-RuntimeSpirv-subgroupSize-10141
  If `subgroupSize` is 1, 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-subgroupSize-10142
  If `subgroupSize` is 1, 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-subgroupSize-10143
  If `subgroupSize` is 1, 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-subgroupSize-10144
  If `subgroupSize` is 1, 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-subgroupSize-10145
  If `subgroupSize` is 1, 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-subgroupSize-10146
  If `subgroupSize` is 1, 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-subgroupSize-10147
  If `subgroupSize` is 1, the `StorageTexelBufferArrayNonUniformIndexing` capability is not 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, `subgroupSize` is 1, 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-subgroupSize-10149
  If an instruction accesses memory through any resource, `subgroupSize` is greater than 1, and the resource through which that memory is accessed is not uniform within the invocation group, and not uniform within the subgroup, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with `NonUniform`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-RuntimeSpirv-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-10163
  For `OpTypeCooperativeMatrixKHR`, if the `cooperativeMatrixFlexibleDimensions` feature is not enabled, the component type, scope, number of rows, and number of columns must match one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR, where

  - for `Use` of `MatrixA`, the number of rows must match VkCooperativeMatrixPropertiesKHR::`MSize` and the number of columns must match VkCooperativeMatrixPropertiesKHR::`KSize` and the type must match VkCooperativeMatrixPropertiesKHR::`AType`

  - for `Use` of `MatrixB`, the number of rows must match VkCooperativeMatrixPropertiesKHR::`KSize` and the number of columns must match VkCooperativeMatrixPropertiesKHR::`NSize` and the type must match VkCooperativeMatrixPropertiesKHR::`BType`

  - for `Use` of `MatrixAccumulator`, the number of rows must match VkCooperativeMatrixPropertiesKHR::`MSize` and the number of columns must match VkCooperativeMatrixPropertiesKHR::`NSize` and the type must match VkCooperativeMatrixPropertiesKHR::`CType` or VkCooperativeMatrixPropertiesKHR::`ResultType`

- VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-10060
  For `OpCooperativeMatrixMulAddKHR`, if the `cooperativeMatrixFlexibleDimensions` feature is not enabled, 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 match VkCooperativeMatrixPropertiesKHR::`scope`.

- VUID-RuntimeSpirv-cooperativeMatrixWorkgroupScope-10164
  If the `cooperativeMatrixWorkgroupScope` feature is not enabled, the scope of all `OpTypeCooperativeMatrixKHR` must not be VkScopeKHR::`VK_SCOPE_WORKGROUP_KHR`

- VUID-RuntimeSpirv-cooperativeMatrixFlexibleDimensions-10165
  For `OpTypeCooperativeMatrixKHR`, if the `cooperativeMatrixFlexibleDimensions` feature is enabled, the component type, scope, number of rows, and number of columns must match either one of the matrices in one of the supported VkCooperativeMatrixPropertiesKHR as described above, or one of the supported VkCooperativeMatrixFlexibleDimensionsPropertiesNV, where

  - for `MatrixA`, the number of rows must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`MGranularity` and the number of columns must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`KGranularity` and the type must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`AType`

  - for `MatrixB`, the number of rows must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`KGranularity` and the number of columns must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`NGranularity` and the type must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`BType`

  - for `MatrixAccumulator`, the number of rows must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`MGranularity` and the number of columns must be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`NGranularity` and the type must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`CType` or VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`ResultType`

  - if the scope is `VK_SCOPE_WORKGROUP_KHR`, the number of invocations in the local workgroup must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`workgroupInvocations`

- VUID-RuntimeSpirv-cooperativeMatrixFlexibleDimensions-10166
  For `OpCooperativeMatrixMulAddKHR`, if the `cooperativeMatrixFlexibleDimensions` feature is enabled, the operands must match either one of the supported VkCooperativeMatrixPropertiesKHR as described above, or one of the supported VkCooperativeMatrixFlexibleDimensionsPropertiesNV, such that:

  - The type of `A` must have `Rows` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`MGranularity`, `Columns` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`KGranularity`, `Use` be `MatrixAKHR`, and `ComponentType` match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`AType`.

  - The type of `B` must have `Rows` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`KGranularity`, `Columns` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`NGranularity`, `Use` be `MatrixBKHR`, and `ComponentType` match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`BType`.

  - The type of `C` must have `Rows` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`MGranularity`, `Columns` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`NGranularity`, `Use` be `MatrixAccumulatorKHR`, and `ComponentType` match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`CType`.

  - The type of `Result` must have `Rows` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`MGranularity`, `Columns` be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`NGranularity`, `Use` be `MatrixAccumulatorKHR`, and `ComponentType` match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`ResultType`.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`AType` is a signed integer type, `MatrixASignedComponents` must be used.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`BType` is a signed integer type, `MatrixBSignedComponents` must be used.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`CType` is a signed integer type, `MatrixCSignedComponents` must be used.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`ResultType` is a signed integer type, `MatrixResultSignedComponents` must be used.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`saturatingAccumulation` is `VK_TRUE`, `SaturatingAccumulationKHR` must be used.

  - If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`saturatingAccumulation` is `VK_FALSE`, `SaturatingAccumulationKHR` must not be used.

  - The scope of all cooperative matrix operands must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`scope`.

  - If the scope is `VK_SCOPE_WORKGROUP_KHR`, the number of invocations in the local workgroup must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::`workgroupInvocations`

- VUID-RuntimeSpirv-cooperativeMatrixFlexibleDimensionsMaxDimension-10167
  All `OpTypeCooperativeMatrixKHR` dimensions must be less than or equal to `cooperativeMatrixFlexibleDimensionsMaxDimension`

- VUID-RuntimeSpirv-maxComputeSharedMemorySize-10168
  If the module uses `OpTypeCooperativeMatrixKHR` with `Scope` equal to `Workgroup`, 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` minus `cooperativeMatrixWorkgroupScopeReservedSharedMemory`

- 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 the `tessellationShader` feature 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 the `tessellationShader` feature 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-None-06337
  `shaderBufferFloat16Atomics`, or `shaderBufferFloat16AtomicAdd`, or `shaderBufferFloat16AtomicMinMax`, or `shaderSharedFloat16Atomics`, or `shaderSharedFloat16AtomicAdd`, or `shaderSharedFloat16AtomicMinMax` must be enabled for 16-bit floating-point atomic operations

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

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

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

- VUID-RuntimeSpirv-NonWritable-06340
  If the `fragmentStoresAndAtomics` feature 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 the `vertexPipelineStoresAndAtomics` feature 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
  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 the `maintenance4` feature 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 the `shaderZeroInitializeWorkgroupMemory` feature 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 the `shaderSubgroupUniformControlFlow` feature 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 the `shaderEarlyAndLateFragmentTests` feature is not enabled, the `EarlyAndLateFragmentTestsEXT` `Execution` `Mode` must not be used

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-RuntimeSpirv-shaderTileImageStencilReadAccess-08730
  If the `shaderTileImageStencilReadAccess` feature 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 the `maintenance5` feature 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 the `maintenance5` feature 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`

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

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

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

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

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

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

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

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

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

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

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

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

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

- VUID-RuntimeSpirv-meshAndTaskShaderDerivatives-10153
  If `meshAndTaskShaderDerivatives` is `VK_FALSE`, the `DerivativeGroupLinearKHR` and `DerivativeGroupQuadsKHR` execution modes must not be used in the `MeshEXT`, `MeshNV`, `TaskEXT`, or `TaskNV` `Execution` `Model`

## 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-2024 The Khronos Group Inc.

SPDX-License-Identifier: CC-BY-4.0