RuntimeSpirv(3)

# RuntimeSpirv(3) Manual Page

## Name

RuntimeSpirv - Runtime SPIR-V Validation

## 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-shaderRelaxedExtendedInstruction-10773
  If the `shaderRelaxedExtendedInstruction` feature is not enabled, the `OpExtInstWithForwardRefsKHR` must not be used

- 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 the effective subgroup size 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 the effective subgroup size 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 the effective subgroup size 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 the effective subgroup size 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 the effective subgroup size 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 the effective subgroup size 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 the effective subgroup size 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-04745
  All block members in a variable with a `Storage` `Class` of `PushConstant` declared as an array must only be accessed by dynamically uniform indices

- VUID-RuntimeSpirv-None-10148
  If an instruction accesses memory through any resource, the effective subgroup size is 1, the `DescriptorHeapEXT` capability is not declared, 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, the effective subgroup size is greater than 1, the `DescriptorHeapEXT` capability is not declared, 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-shaderFmaFloat16-10977
  `shaderFmaFloat16` must be enabled for `OpFmaKHR` to be supported with a result type that includes a 16-bit float

- VUID-RuntimeSpirv-shaderFmaFloat32-10978
  `shaderFmaFloat32` must be enabled for `OpFmaKHR` to be supported with a result type that includes a 32-bit float

- VUID-RuntimeSpirv-shaderFmaFloat64-10979
  `shaderFmaFloat64` must be enabled for `OpFmaKHR` to be supported with a result type that includes a 64-bit float

- 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-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-PhysicalStorageBuffer64-11819
  If the `PhysicalStorageBuffer64` addressing model is enabled the pointer value of a memory access instruction in the `PhysicalStorageBuffer` `Storage` `Class` must reference a buffer created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT usage flag set

- 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-NSize-12352
  For `OpExtractSubArrayQCOM`, the length of the `Source` `Array` operand must match the VkCooperativeMatrixPropertiesKHR::`NSize` of one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR

- VUID-RuntimeSpirv-KSize-12353
  For `OpExtractSubArrayQCOM`, the length of the `Result` `Type` operand must match the VkCooperativeMatrixPropertiesKHR::`KSize` of one of the matrices in any of the supported VkCooperativeMatrixPropertiesKHR

- VUID-RuntimeSpirv-OpExtractSubArrayQCOM-12354
  For `OpExtractSubArrayQCOM`, the `Start` `Index` operand must be a multiple of the length of the `Result` `Type` operand

- 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-OpCooperativeMatrixLoadTensorNV-12429
  For each `OpCooperativeMatrixLoadTensorNV` instruction that includes DecodeVectorFunc in Tensor Addressing Operands, the tensor block size in the innermost dimension must be a multiple of the number of components of the DecodeVectorFunc function’s return type.

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

- VUID-RuntimeSpirv-OpTypeCooperativeMatrixKHR-10770
  Any pipeline containing a shader with `OpTypeCooperativeMatrixKHR` or `OpCooperativeMatrix*KHR` instructions must be created with the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT flag or the shader module must be version 1.6 or greater

- VUID-RuntimeSpirv-OpTypeCooperativeMatrixKHR-10771
  Any shader object containing `OpTypeCooperativeMatrixKHR` or `OpCooperativeMatrix*KHR` instructions must be created with the VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag or the shader module must be version 1.6 or greater

- VUID-RuntimeSpirv-OpCooperativeMatrix-12379
  If any `OpCooperativeMatrix*` instructions accesses a descriptor, it must not be a null descriptor

- 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-OpCooperativeVectorMatrixMulNV-10089
  For `OpCooperativeVectorMatrixMulNV` and `OpCooperativeVectorMatrixMulAddNV`, the following must be satisfied by the same entry in the VkCooperativeVectorPropertiesNV array returned by vkGetPhysicalDeviceCooperativeVectorPropertiesNV:

  - The component type of `Input` must match VkCooperativeVectorPropertiesNV::`inputType`

  - The `InputInterpretation` must match VkCooperativeVectorPropertiesNV::`inputInterpretation`

  - The `MatrixInterpretation` must match VkCooperativeVectorPropertiesNV::`matrixInterpretation`

  - For `OpCooperativeVectorMatrixMulAddNV`, the `BiasInterpretation` must match VkCooperativeVectorPropertiesNV::`biasInterpretation`

  - The `Result` `Type` must match VkCooperativeVectorPropertiesNV::`resultType`

  - If `Transpose` is true, VkCooperativeVectorPropertiesNV::`transpose` must be VK_TRUE

- VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulNV-10090
  For `OpCooperativeVectorMatrixMulNV` and `OpCooperativeVectorMatrixMulAddNV`, if `MatrixInterpretation` is either VK_COMPONENT_TYPE_FLOAT_E4M3_NV or VK_COMPONENT_TYPE_FLOAT_E5M2_NV then `MemoryLayout` must be either VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV or VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV

- VUID-RuntimeSpirv-cooperativeVectorSupportedStages-10091
  `OpTypeCooperativeVectorNV` and `OpCooperativeVector*` instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeVectorPropertiesNV::`cooperativeVectorSupportedStages`

- VUID-RuntimeSpirv-OpCooperativeVectorReduceSumAccumulateNV-10092
  For `OpCooperativeVectorReduceSumAccumulateNV`:

  - The component type of `V` must be either 16- or 32-bit floating-point

  - If the component type of `V` is 16-bit floating-point, `cooperativeVectorTrainingFloat16Accumulation` must be supported

  - If the component type of `V` is 32-bit floating-point, `cooperativeVectorTrainingFloat32Accumulation` must be supported

  - The pointer’s storage class must be `StorageBuffer` or `PhysicalStorageBuffer`

- VUID-RuntimeSpirv-OpCooperativeVectorOuterProductAccumulateNV-10093
  For `OpCooperativeVectorOuterProductAccumulateNV`:

  - `MatrixInterpretation` must be VK_COMPONENT_TYPE_FLOAT16_KHR or VK_COMPONENT_TYPE_FLOAT32_KHR

  - If `MatrixInterpretation` is VK_COMPONENT_TYPE_FLOAT16_KHR, `cooperativeVectorTrainingFloat16Accumulation` must be supported

  - If `MatrixInterpretation` is VK_COMPONENT_TYPE_FLOAT32_KHR, `cooperativeVectorTrainingFloat32Accumulation` must be supported

  - The component types of `A` and `B` must be 16-bit floating-point

  - The matrix layout must be training-optimal

  - The pointer’s storage class must be `StorageBuffer` or `PhysicalStorageBuffer`

- VUID-RuntimeSpirv-maxCooperativeVectorComponents-10094
  `OpTypeCooperativeVector` instructions must have `Component` `Count` less than or equal to `maxCooperativeVectorComponents`

- VUID-RuntimeSpirv-OpTypeCooperativeVector-10095
  `OpTypeCooperativeVector` instructions must have `Component` `Type` that is any supported type reported by vkGetPhysicalDeviceCooperativeVectorPropertiesNV

- 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-MeshEXT-12333
  For mesh shaders using the `MeshEXT` `Execution` `Model` the index into the array of any variable decorated with the `PerPrimitiveEXT` decoration must be less than the “Primitive Count” operand of `OpSetMeshOutputsEXT`

- 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-MeshEXT-12380
  If the `MeshEXT` `Execution` `Model` dynamically accesses a variable with the `TaskPayloadWorkgroupEXT` `Storage` `Class`, there must be a matching `TaskPayloadWorkgroupEXT` `Storage` `Class` variable in the `TaskEXT` `Execution` `Model` passed as an argument to `OpEmitMeshTasksEXT`

- 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-OpCooperativeVectorMatrixMulNV-10096
  For `OpCooperativeVectorMatrixMulNV` and `OpCooperativeVectorMatrixMulAddNV` instructions using non-optimal layouts, the `Stride` operand must be aligned to 16 bytes

- VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulNV-10097
  For `OpCooperativeVectorMatrixMulNV` and `OpCooperativeVectorMatrixMulAddNV` instructions, the `Matrix` and `MatrixOffset` must be aligned to 64 bytes

- VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulAddNV-10098
  For `OpCooperativeVectorMatrixMulAddNV` instructions, the `Bias` and `BiasOffset` must be aligned to 16 bytes

- VUID-RuntimeSpirv-OpCooperativeVectorLoadNV-10099
  For `OpCooperativeVectorLoadNV` and `OpCooperativeVectorStoreNV` instructions, the `Pointer` and `Offset` must be aligned to 16 bytes

- VUID-RuntimeSpirv-OpCooperativeVectorReduceSumAccumulateNV-10100
  For `OpCooperativeVectorReduceSumAccumulateNV` instructions, the `Pointer` and `Offset` must be aligned to 16 bytes

- VUID-RuntimeSpirv-OpCooperativeVectorOuterProductAccumulateNV-10101
  For `OpCooperativeVectorOuterProductAccumulateNV` instructions, the `Pointer` and `Offset` must be aligned to 64 bytes

- 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` unless `shaderUntypedPointers` is VK_TRUE and they are accessed in:

  - 32-bit multiples, or

  - 16-bit multiples if `storageBuffer16BitAccess` is VK_TRUE.

- 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 unless `shaderUntypedPointers` is VK_TRUE and they are accessed in:

  - 32-bit multiples, or

  - 16-bit multiples if `uniformAndStorageBuffer16BitAccess` is VK_TRUE.

- VUID-RuntimeSpirv-storagePushConstant8-06330
  If `storagePushConstant8` is VK_FALSE, then objects containing an 8-bit integer element must not have `Storage` `Class` of `PushConstant` unless `shaderUntypedPointers` is VK_TRUE and they are accessed in:

  - 32-bit multiples, or

  - 16-bit multiples if `storagePushConstant16` is VK_TRUE.

- VUID-RuntimeSpirv-workgroupMemoryExplicitLayout8BitAccess-10756
  If `workgroupMemoryExplicitLayout8BitAccess` is VK_FALSE, then objects in the `Workgroup` `Storage` `Class` with the `Block` decoration must not have an 8-bit integer element unless `shaderUntypedPointers` is VK_TRUE and they are accessed in:

  - 32-bit multiples, or

  - 16-bit multiples if `workgroupMemoryExplicitLayout16BitAccess` is VK_TRUE

- VUID-RuntimeSpirv-storageBuffer16BitAccess-11161
  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` unless:

  - `storageBuffer8BitAccess` is VK_TRUE, or

  - the elements are accessed in 32-bit multiples if `shaderUntypedPointers` is VK_TRUE.

- 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 unless:

  - `uniformAndStorageBuffer8BitAccess` is VK_TRUE, or

  - members are accessed in 32-bit multiples and `shaderUntypedPointers` is VK_TRUE

- 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` unless:

  - `StoragePushConstant8` is VK_TRUE, or

  - elements are accessed in 32-bit multiples if `shaderUntypedPointers` is VK_TRUE

- VUID-RuntimeSpirv-storageInputOutput16-11162
  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-10980
  Objects containing 8-bit integer or 8-bit floating-point elements must not have storage class of Input or Output

- VUID-RuntimeSpirv-workgroupMemoryExplicitLayout16BitAccess-10757
  If `workgroupMemoryExplicitLayout16BitAccess` is VK_FALSE, then objects in the `Workgroup` `Storage` `Class` with the `Block` decoration must not have an 16-bit integer or 16-bit floating-point elements unless:

  - `workgroupMemoryExplicitLayout8BitAccess` is VK_TRUE, or

  - elements are accessed in 32-bit multiples if `shaderUntypedPointers` is VK_TRUE

- 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, storage tensor, 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, storage tensor, 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-RayTracingOpacityMicromapKHR-11542
  If the `RayTracingOpacityMicromapKHR` capability is not enabled, any `Rayflags` operand provided to an instruction must not contain `ForceOpacityMicromap2StateKHR`

- VUID-RuntimeSpirv-micromap-11630
  If the `OpacityMicromapIdKHR` execution mode is specified with its specialization constant operand equal to VK_TRUE, the pipeline must not have been created with VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM

- 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_BIT_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-11855
  For modules which contain `OpTraceRayKHR` or `OpTraceRayMotionNV` instructions that declare a variable in the `RayPayloadKHR` `Storage` `Class`, all shaders which may be invoked as part of that shader call must declare an identical variable in the `IncomingRayPayloadKHR` `Storage` `Class`

- 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-flags-11875
  For `OpHitObjectTraceRayMotionEXT` and `OpHitObjectTraceMotionReorderExecuteEXT` 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-flags-11876
  For `OpHitObjectTraceRayMotionEXT` and `OpHitObjectTraceMotionReorderExecuteEXT` 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-OpHitObjectTraceRayMotionEXT-11877
  For `OpHitObjectTraceRayMotionEXT` and `OpHitObjectTraceMotionReorderExecuteEXT` instructions, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11878
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, all components of the `RayOrigin` and `RayDirection` operands must be finite floating-point values

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11879
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, the `RayTmin` and `RayTmax` operands must be non-negative floating-point values

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11880
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, the `RayTmin` operand must be less than or equal to the `RayTmax` operand

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11881
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, `RayOrigin`, `RayDirection`, `RayTmin`, and `RayTmax` operands must not contain NaNs

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11882
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions the `time` operand must be between 0.0 and 1.0

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11883
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, the `Rayflags` operand must not contain both `SkipTrianglesKHR` and `SkipAABBsKHR`

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11884
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, the `Rayflags` operand must not contain more than one of `SkipTrianglesKHR`, `CullBackFacingTrianglesKHR`, and `CullFrontFacingTrianglesKHR`

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11885
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` instructions, the `Rayflags` operand must not contain more than one of `OpaqueKHR`, `NoOpaqueKHR`, `CullOpaqueKHR`, and `CullNoOpaqueKHR`

- VUID-RuntimeSpirv-OpHitObjectTraceRayEXT-11886
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` 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-OpHitObjectTraceRayEXT-11887
  For `OpHitObjectTraceRayEXT`, `OpHitObjectTraceRayMotionEXT`, `OpHitObjectTraceMotionReorderExecuteEXT` and `OpHitObjectTraceReorderExecuteEXT` 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 vector type output interface variables must not have a higher `Component` `Count` than a matching vector type 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 variable, `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 variable with `Workgroup` as its `Storage` `Class` must not have an `Initializer` operand

- VUID-RuntimeSpirv-Offset-10213
  If the `maintenance8` feature is not enabled, image operand `Offset` must only be used with `OpImage*Gather` or `OpImageGatherQCOM` instructions

- VUID-RuntimeSpirv-Size-11165
  The `Size` operand of `OpCopyMemorySized` must be a multiple of 4

  - If 16-bit storage is enabled for the storage classes of both the `Target` and `Source` operands the `Size` operand may instead be a multiple of 2

  - If 8-bit storage is enabled for the storage classes of both the `Target` and `Source` operands the `Size` operand may instead be any value

- VUID-RuntimeSpirv-OpTypeUntypedPointerKHR-11166
  Any memory access made using an `OpTypeUntypedPointerKHR` must have an alignment that satisfies Offset and Stride Assignment

- VUID-RuntimeSpirv-OpImage-06376
  If an `OpImage*Gather` or `OpImageGatherQCOM` 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` or `OpImageGatherQCOM` 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 `Offset` or `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 `Offset` or `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_EXT, 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 `EarlyAndLateFragmentTestsAMD` `Execution` `Mode` must not be used

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

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

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

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

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

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

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

- VUID-RuntimeSpirv-OpImageSampleWeightedQCOM-06980
  If an `OpImageSampleWeightedQCOM` 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-OpImageSampleWeightedQCOM-06981
  If an `OpImageSampleWeightedQCOM` 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-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-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-maintenance5-10934
  If the `maintenance5` feature is enabled and a `PointSize` decorated variable is written to for any output vertex in the `Geometry` `Execution` `Model`, all execution paths for all output vertices 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-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 a sampler object that included VkSamplerBlockMatchWindowCreateInfoQCOM in the `pNext` chain

- VUID-RuntimeSpirv-OpControlBarrierArriveEXT-13558
  If a `OpControlBarrierArriveEXT` or `OpControlBarrierWaitEXT` instruction is executed with an execution scope equal to `Workgroup`, its execution must be inside uniform control flow within the invocation group

- VUID-RuntimeSpirv-OpControlBarrierWaitEXT-13559
  If a `OpControlBarrierWaitEXT` instruction is executed, a `OpControlBarrierArriveEXT` instruction with the same execution scope must have been executed previously

- VUID-RuntimeSpirv-OpControlBarrierWaitEXT-13560
  If a `OpControlBarrierWaitEXT` instruction is executed, another `OpControlBarrierWaitEXT` instruction with the same execution scope must not have been previously executed prior to the last executed `OpControlBarrierArriveEXT` instruction with the same execution scope

- VUID-RuntimeSpirv-OpControlBarrierArriveEXT-13561
  If a `OpControlBarrierArriveEXT` instruction is executed, another `OpControlBarrierArriveEXT` instruction with the same execution scope must not have been previously executed unless a `OpControlBarrierWaitEXT` instruction with the same execution scope has been executed after it

- VUID-RuntimeSpirv-OpControlBarrierArriveEXT-13562
  If the module uses `OpControlBarrierArriveEXT` or `OpControlBarrierWaitEXT`, 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 `splitBarrierReservedSharedMemory`

- VUID-RuntimeSpirv-maxShaderWaitQueues-12426
  The literal operand of the `MultipleWaitQueuesQCOM` Loop Control must be less than or equal to VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM::`maxShaderWaitQueues`

- 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`

- VUID-RuntimeSpirv-TileShadingQCOM-10698
  `TileShadingQCOM` capability must not be declared in the compute stage unless the tileShading feature is enabled

- VUID-RuntimeSpirv-TileShadingQCOM-10699
  The `TileShadingQCOM` capability must not be declared in the fragment stage unless the tileShadingFragmentStage feature is enabled

- VUID-RuntimeSpirv-TileShadingQCOM-10700
  A shader that enables SPIR-V capability `TileShadingQCOM` must not be invoked outside a tile shading render pass

- VUID-RuntimeSpirv-TileShadingQCOM-10701
  A compute shader that enables SPIR-V capability `TileShadingQCOM` must only be invoked inside those portions of a command buffer where per-tile execution model is enabled

- VUID-RuntimeSpirv-x-10702
  In compute shaders that enables SPIR-V capability `TileShadingQCOM`, the `x` size in `TileShadingRateQCOM` must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate.x

- VUID-RuntimeSpirv-y-10703
  In compute shaders that enables SPIR-V capability `TileShadingQCOM`, the `y` size in `TileShadingRateQCOM` must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate.y

- VUID-RuntimeSpirv-z-10704
  In compute shaders that enables SPIR-V capability `TileShadingQCOM`, the `z` size in `TileShadingRateQCOM` must be less than or equal to VkTilePropertiesQCOM.tileSize.z

- VUID-RuntimeSpirv-tileSize-10705
  In compute shaders that enables SPIR-V capability `TileShadingQCOM`, VkTilePropertiesQCOM.tileSize.z % `TileShadingRateQCOM`::`z` must equal `0`

- VUID-RuntimeSpirv-OpImage-10706
  An `OpImage` with `Storage` `Class` `TileAttachmentQCOM` must not be consumed by `OpImageTexelPointer` or `OpUntypedImageTexelPointerEXT` unless the tileShadingAtomicOps feature is enabled

- VUID-RuntimeSpirv-OpTypeImage-10707
  An `OpTypeImage` with `Storage` `Class` `TileAttachmentQCOM` must not be backed by a view equivalent to the color attachment of the current subpass instance unless the tileShadingColorAttachments feature is enabled

- VUID-RuntimeSpirv-OpTypeImage-10708
  An `OpTypeImage` with `Storage` `Class` `TileAttachmentQCOM` must not be backed by a view equivalent to the depth aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingDepthAttachments

- VUID-RuntimeSpirv-OpTypeImage-10709
  An `OpTypeImage` with `Storage` `Class` `TileAttachmentQCOM` must not be backed by a view equivalent to the stencil aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingStencilAttachments feature is enabled

- VUID-RuntimeSpirv-OpTypeImage-10710
  An `OpTypeImage` with `Storage` `Class` `TileAttachmentQCOM` must not be backed by a view equivalent to the input attachment of the current subpass instance unless the tileShadingInputAttachments feature is enabled

- VUID-RuntimeSpirv-OpTypeSampledImage-10711
  An `OpTypeSampledImage` with `Storage` `Class` `TileAttachmentQCOM` must not be backed by a view equivalent to an attachment of the current subpass instance unless the tileShadingSampledAttachments feature is enabled

- VUID-RuntimeSpirv-tileShadingImageProcessing-10712
  If an `OpTypeSampledImage` with `Storage` `Class` `TileAttachmentQCOM` is consumed by any argument of the following operations, `tileShadingImageProcessing` must be enabled:

  - `OpImageSampleWeightedQCOM`

  - `OpImageBoxFilterQCOM`

  - `OpImageBlockMatch*QCOM`

- VUID-RuntimeSpirv-Coordinate-10713
  The `Coordinate` operand of any `OpImageRead`, `OpImageSparseRead`, `OpImageWrite`, `OpUntypedImageTexelPointerEXT` or `OpImageTexelPointer` instruction that consumes an `OpTypeImage` with an image `Storage` `Class` `TileAttachmentQCOM` must not result in any texels accessed outside the boundaries of the current tile, computed as described in Tile Attachments

- VUID-RuntimeSpirv-Coordinate-10714
  The `Coordinate` operand(s) of any of the following instructions that consumes an `OpTypeSampledImage` with an image of `Storage` `Class` `TileAttachmentQCOM` must not result in any texels accessed outside boundaries of the current tile, computed as described in Tile Attachments:

  - `OpImageSample*`

  - `OpImageSparseSample*`

  - `OpImageFetch`

  - `OpImageSparseFetch`

  - `OpImage*Gather`

  - `OpImageSparse*Gather`

  - `OpImageSampleWeightedQCOM`

  - `OpImageBoxFilterQCOM`

  - `OpImageBlockMatch*QCOM`

  - `OpImageGatherQCOM`

- VUID-RuntimeSpirv-OpTypeSampler-12203
  If a variable with type `OpTypeSampler` is declared in the Shader Resource Interface, it must not be backed by a sampler that requires sampler Y′CBCR conversion

- VUID-RuntimeSpirv-OpTypeImage-12204
  If a variable with type `OpTypeImage` is declared in the Shader Resource Interface, it must not be backed by an image view that requires sampler Y′CBCR conversion

- VUID-RuntimeSpirv-None-12205
  If an image view or sampler that requires sampler Y′CBCR conversion is accessed in a shader, it must be determined by constant integral expressions

- VUID-RuntimeSpirv-OpTypeSampledImage-12206
  If an `OpTypeSampledImage` variable backed by an image view and sampler that require sampler Y′CBCR conversion is statically used in a shader, it must only be used with `OpImageSample*`, `OpImageSparseSample*`, or `OpImage` instructions

- VUID-RuntimeSpirv-OpTypeImage-12207
  If a `OpTypeImage` variable backed by an image view that requires sampler Y′CBCR conversion is statically used in a shader, it must only be used with `OpImageQueryLevels` or `OpImageQuerySizeLod` instructions

- VUID-RuntimeSpirv-ConstOffset-10718
  If an `OpTypeSampledImage` variable backed by an image view and sampler that require sampler Y′CBCR conversion is statically used in a shader with a sampling instruction, it must not use the `ConstOffset` or `Offset` operands

- VUID-RuntimeSpirv-OpTypeSampledImage-12208
  If an `OpTypeSampledImage` variable backed by an image view and sampler that require sampler Y′CBCR conversion is statically used in a shader, the image view and sampler must have been created with an identically defined VkSamplerYcbcrConversion set via VkSamplerYcbcrConversionInfo

- VUID-RuntimeSpirv-shaderUniformBufferUnsizedArray-11806
  If the `shaderUniformBufferUnsizedArray` feature is not enabled, `OpTypeRuntimeArray` must not be used for the last member of a `Block`-decorated `OpTypeStruct` in the `Uniform` storage `Storage` `Class`

- VUID-RuntimeSpirv-shaderTensorSupportedStages-09901
  `OpTypeTensorARM`, `OpTensorReadARM`, `OpTensorWriteARM`, or `OpTensorQuerySizeARM` must not be used in shader stages not in `shaderTensorSupportedStages`

- VUID-RuntimeSpirv-OpTypeTensorARM-09902
  `OpTypeTensorARM` with a `Shape` must not be used in shader stages

- VUID-RuntimeSpirv-OpTypeTensorARM-09907
  `OpTypeTensorARM` without a `Rank` must not be used in shader stages

- VUID-RuntimeSpirv-maxTensorShaderAccessArrayLength-09903
  The length of an array returned by `OpTensorReadARM` or passed as the `Object` operand to `OpTensorWriteARM` must be less than or equal to `maxTensorShaderAccessArrayLength`

- VUID-RuntimeSpirv-maxTensorShaderAccessSize-09904
  The total size of the data (number of tensor elements × size of an element) read or written by one `OpTensorReadARM`, or `OpTensorWriteARM` instruction, respectively, must be less than or equal to `maxTensorShaderAccessSize`

- VUID-RuntimeSpirv-None-10824
  If the `maintenance9` feature is not enabled, the `Base` operand of any `OpBitCount`, `OpBitReverse`, `OpBitFieldInsert`, `OpBitFieldSExtract`, or `OpBitFieldUExtract` instruction must be a 32-bit integer scalar or a vector of 32-bit integers

- VUID-RuntimeSpirv-GraphARM-09922
  The `GraphARM` capability must not be declared in modules used to create a shader stage

- VUID-RuntimeSpirv-pNext-09919
  For each data graph pipeline created with a VkDataGraphPipelineShaderModuleCreateInfoARM structure included in the `pNext` chain of VkDataGraphPipelineCreateInfoARM, the `OpGraph` that is used by the `OpGraphEntryPointARM` the pipeline is being created for must have an `OpTypeGraphARM` that only uses `OpTypeTensorARM` with `Shape` present

- VUID-RuntimeSpirv-pNext-09920
  For each data graph pipeline created with a VkDataGraphPipelineShaderModuleCreateInfoARM structure included in the `pNext` chain of VkDataGraphPipelineCreateInfoARM, all the `OpGraphConstantARM` with `OpTypeTensorARM` type used by the `OpGraph` that is used by the `OpGraphEntryPointARM` the pipeline is being created for must have an `OpTypeTensorARM` with `Shape` present

- VUID-RuntimeSpirv-pNext-09921
  For each data graph pipeline created with a VkDataGraphPipelineShaderModuleCreateInfoARM structure included in the `pNext` chain of VkDataGraphPipelineCreateInfoARM, one and only one VkDataGraphPipelineConstantARM structure that satisfies all the following constraints must be present in VkDataGraphPipelineShaderModuleCreateInfoARM::`pConstants` for each `OpGraphConstantARM` used by the `OpGraph` that has a `OpTypeTensorARM` type and is used by the `OpGraphEntryPointARM` the pipeline is being created for:

  - its `id` member must match the `GraphConstantID` of the `OpGraphConstantARM`

  - its `pNext` chain must include a VkTensorDescriptionARM structure

    - whose `dimensionCount` is equal to the `Rank` of the `OpTypeTensorARM` of the `OpGraphConstantARM`

    - whose `pDimensions` array elements are individually and in order equal to the elements of the array that defines the `Shape` of the `OpTypeTensorARM` of the `OpGraphConstantARM`

    - whose `format` is compatible with the `ElementType` of the `OpTypeTensorARM` of the `OpGraphConstantARM`

- VUID-RuntimeSpirv-pNext-09923
  For each data graph pipeline created with a VkDataGraphPipelineShaderModuleCreateInfoARM structure included in the `pNext` chain of VkDataGraphPipelineCreateInfoARM, one and only one VkDataGraphPipelineResourceInfoARM structure that satisfies all the following constraints must be present in VkDataGraphPipelineCreateInfoARM::`pResourceInfos` for each `OpVariable` with a `OpTypeTensorARM` type that is part of the `Interface` of the `OpGraphEntryPointARM` the pipeline is being created for:

  - its `descriptorSet` member must match the `DescriptorSet` decoration applied to the `OpVariable`

  - its `binding` member must match the `Binding` decoration applied to the `OpVariable`

  - its `arrayElement` member must be zero

  - its `pNext` chain must include a VkTensorDescriptionARM structure

    - whose `dimensionCount` is equal to the `Rank` of the `OpTypeTensorARM` of the `OpVariable` or its elements

    - whose `pDimensions` array elements are individually and in order equal to the elements of the array that defines the `Shape` of the `OpTypeTensorARM` of the `OpVariable` or its elements

    - whose `format` is compatible with the `ElementType` of the `OpTypeTensorARM` of the `OpVariable`

- VUID-RuntimeSpirv-maxShaderBindingTableRecordIndex-11888
  The SBT Index passed in to `OpHitObjectSetShaderBindingTableRecordIndexEXT` must be less than or equal to VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT::`maxShaderBindingTableRecordIndex`

- VUID-RuntimeSpirv-None-10834
  Buffer indexing calculations must not wrap 32 bits if the pipeline or shader was not created with the VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT or VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT flags and the entry point does not set the `Shader64BitIndexingEXT` execution mode

- VUID-RuntimeSpirv-OpArrayLength-11807
  `OpArrayLength` and `OpUntypedArrayLengthKHR` result type must be a 32-bit integer type if the pipeline or shader was not compiled with the VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT or VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT flags and the entry point does not set the `Shader64BitIndexingEXT` execution mode

- VUID-RuntimeSpirv-OpConstantSizeOfEXT-11475
  The result type of `OpConstantSizeOfEXT` must not be a 64-bit integer type if the pipeline or shader was not compiled with the VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT or VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT flags and the entry point does not set the `Shader64BitIndexingEXT` execution mode

- VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulAddNV-11808
  `OpCooperativeVectorMatrixMulAddNV` and `OpCooperativeVectorMatrixMulNV` `MatrixOffset` and `BiasOffset` parameters must be 32-bit integer types if the pipeline or shader was not compiled with the VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT or VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT flags and the entry point does not set the `Shader64BitIndexingEXT` execution mode

- VUID-RuntimeSpirv-OpCooperativeVectorLoadNV-11809
  `OpCooperativeVectorLoadNV`, `OpCooperativeVectorStoreNV`, `OpCooperativeVectorOuterProductAccumulateNV`, and `OpCooperativeVectorReduceSumAccumulateNV` `Offset` parameters must be 32-bit integer types if the pipeline or shader was not compiled with the VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT or VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT flags and the entry point does not set the `Shader64BitIndexingEXT` execution mode

- VUID-RuntimeSpirv-longVector-12296
  If the `longVector` feature is enabled, the `Component` `Count` of any vector type must be less than or equal to `maxVectorComponents`

- VUID-RuntimeSpirv-samplerDescriptorAlignment-11348
  If the `Result` `Type` operand of `OpLoad` is `OpTypeSampler`, and `Pointer` is derived from a variable decorated with `SamplerHeapEXT`, it must be at an offset from the base that is a multiple of `samplerDescriptorAlignment`

- VUID-RuntimeSpirv-imageDescriptorAlignment-11349
  If the `Result` `Type` operand of `OpLoad` is `OpTypeImage`, and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, it must be at an offset from the base that is a multiple of `imageDescriptorAlignment`

- VUID-RuntimeSpirv-imageDescriptorAlignment-11383
  If the `Image` operand of `OpImageTexelPointer` or `OpUntypedImageTexelPointerEXT` is derived from a variable decorated with `ResourceHeapEXT`, it must be at an offset from the base that is a multiple of `imageDescriptorAlignment`

- VUID-RuntimeSpirv-Result-11350
  If the `Result` `Type` operand of `OpLoad` is `OpTypeAccelerationStructureKHR` and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, it must be at an offset from the base that is a multiple of `bufferDescriptorAlignment`

- VUID-RuntimeSpirv-bufferDescriptorAlignment-11384
  The `Buffer` operand of `OpBufferPointerEXT` must be at an offset from the base of the `ResourceHeapEXT` that is a multiple of `bufferDescriptorAlignment`

- VUID-RuntimeSpirv-tensorDescriptorAlignment-11481
  If the `Result` `Type` operand of `OpLoad` is `OpTypeTensorARM` and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, it must be at an offset from the base that is a multiple of `tensorDescriptorAlignment`

- VUID-RuntimeSpirv-samplerDescriptorAlignment-11476
  If a `OpTypeSampler` member of a struct is decorated with `Offset` or `OffsetIdEXT`, the `Byte` `Offset` value must be a multiple of `samplerDescriptorAlignment`

- VUID-RuntimeSpirv-imageDescriptorAlignment-11477
  If a `OpTypeImage` member of a struct is decorated with `Offset` or `OffsetIdEXT`, the `Byte` `Offset` value must be a multiple of `imageDescriptorAlignment`

- VUID-RuntimeSpirv-bufferDescriptorAlignment-11478
  If a `OpTypeBufferEXT` member of a struct is decorated with `Offset` or `OffsetIdEXT`, the `Byte` `Offset` value must be a multiple of `bufferDescriptorAlignment`

- VUID-RuntimeSpirv-bufferDescriptorAlignment-11479
  If a `OpTypeAccelerationStructureKHR` member of a struct is decorated with `Offset` or `OffsetIdEXT`, the `Byte` `Offset` value must be a multiple of `bufferDescriptorAlignment`

- VUID-RuntimeSpirv-tensorDescriptorAlignment-11480
  If a `OpTypeTensorARM` member of a struct is decorated with `Offset` or `OffsetIdEXT`, the `Byte` `Offset` value must be a multiple of `tensorDescriptorAlignment`

- VUID-RuntimeSpirv-DescriptorSet-11385
  If an instruction accesses memory through any resource with a `DescriptorSet` and `Binding` that are mapped using VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT, or VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT, the resource through which that memory is accessed must be determined by constant integral expressions

- VUID-RuntimeSpirv-source-11387
  All possible values of a variable pointer to a resource that are not `OpConstantNull` must either all be pointers to resources with `DescriptorSet` and `Binding` decorations with the same mapping types as specified by VkDescriptorSetAndBindingMappingEXT::`source`, or all be pointers to resources without `DescriptorSet` and `Binding` decorations

- VUID-RuntimeSpirv-DescriptorSet-11388
  All possible values of a variable pointer to a resource must not be resources with a `DescriptorSet` and `Binding` that are mapped using VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT, or VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT

- VUID-RuntimeSpirv-Result-11340
  If the `Result` `Type` operand of `OpLoad` is `OpTypeSampler`, and `Pointer` is derived from a variable decorated with `SamplerHeapEXT`, it must correspond to loading a descriptor matching one of the descriptor types listed in Heap Resource Type Correspondence for `OpTypeSampler`

- VUID-RuntimeSpirv-Result-11341
  If the `Result` `Type` operand of `OpLoad` is `OpTypeImage`, and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, it must correspond to loading a descriptor matching one of the descriptor types listed in Heap Resource Type Correspondence for `OpTypeImage`

- VUID-RuntimeSpirv-Result-11342
  The `Buffer` operand of `OpBufferPointerEXT` must correspond to accessing a descriptor matching one of the descriptor types listed in Heap Resource Type Correspondence for `OpTypePointer`

- VUID-RuntimeSpirv-Result-11343
  If the `Result` `Type` operand of `OpLoad` is `OpTypeImage`, and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, the `Image` `Format` and `Sampled` `Type` of that `OpTypeImage` must correspond to a descriptor with a VkFormat that matches as described by Compatibility Between SPIR-V Image Formats and Vulkan Formats and Image Format and Type Matching Between SPIR-V Image Formats and Vulkan Formats

- VUID-RuntimeSpirv-Result-11345
  If the `Result` `Type` operand of `OpLoad` is `OpTypeImage`, and `Pointer` is derived from a variable decorated with `ResourceHeapEXT`, the operands of that `OpTypeImage` must correspond to a descriptor with operands that match as described by Heap Image Operand Correspondence and Heap Image View Type Dimensionality

- VUID-RuntimeSpirv-Image-11379
  If the `Image` operand of `OpImageTexelPointer` or `OpUntypedImageTexelPointerEXT` is derived from a variable decorated with `ResourceHeapEXT`, it must correspond to accessing a descriptor matching one of the descriptor types listed in Heap Resource Type Correspondence for the `OpTypeImage` pointed to

- VUID-RuntimeSpirv-Image-11380
  If the `Image` operand of `OpImageTexelPointer` or `OpUntypedImageTexelPointerEXT` is derived from a variable decorated with `ResourceHeapEXT`, the `Image` `Format` and `Sampled` `Type` of the `OpTypeImage` pointed to must correspond to a descriptor with a VkFormat that matches as described by Compatibility Between SPIR-V Image Formats and Vulkan Formats and Image Format and Type Matching

- VUID-RuntimeSpirv-Image-11382
  If the `Image` operand of `OpImageTexelPointer` or `OpUntypedImageTexelPointerEXT` is derived from a variable decorated with `ResourceHeapEXT`, the operands of that `OpTypeImage` must correspond to a descriptor with operands that match as described by Heap Image Operand Correspondence and Heap Image View Type Dimensionality

- VUID-RuntimeSpirv-maxPushDataSize-12455
  The size of the `PushConstant` `Storage` `Class` block must be less than or equal to `maxPushDataSize`

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

SPDX-License-Identifier: CC-BY-4.0