RuntimeSpirv(3)

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 Shader Input and Output Locations

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

VUID-RuntimeSpirv-UniformBufferArrayNonUniformIndexing-10134
If the UniformBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a uniform buffer, the uniform buffer through which that memory is accessed must be dynamically uniform within the invocation group 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-10148
If an instruction accesses memory through any resource, the effective subgroup size is 1, and the resource through which that memory is accessed is not uniform within the invocation group, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform

VUID-RuntimeSpirv-subgroupSize-10149
If an instruction accesses memory through any resource, the effective subgroup size is greater than 1, and the resource through which that memory is accessed is not uniform within the invocation group, and not uniform within the subgroup, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

VUID-RuntimeSpirv-OpTypeCooperativeMatrixMulAddNV-10059
For OpTypeCooperativeMatrixMulAddNV, the operands must match a supported VkCooperativeMatrixPropertiesNV, such that:

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

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-10060
For OpCooperativeMatrixMulAddKHR, if the cooperativeMatrixFlexibleDimensions feature is not enabled, the operands must match a supported VkCooperativeMatrixPropertiesKHR, such that:

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

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:

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

VUID-RuntimeSpirv-maxComputeSharedMemorySize-10168
If the module uses OpTypeCooperativeMatrixKHR with Scope equal to Workgroup, the sum of size in bytes for variables and padding in the Workgroup Storage Class in the GLCompute Execution Model must be less than or equal to maxComputeSharedMemorySize minus cooperativeMatrixWorkgroupScopeReservedSharedMemory

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

VUID-RuntimeSpirv-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-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:

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:

VUID-RuntimeSpirv-OpCooperativeVectorOuterProductAccumulateNV-10093
For OpCooperativeVectorOuterProductAccumulateNV:

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-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-10883
If the MeshEXT Execution Model declares a variable with the TaskPayloadWorkgroupEXT Storage Class in the entry point, 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:

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:

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:

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:

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:

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:

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:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

VUID-RuntimeSpirv-flags-08761
For OpRayQueryGetIntersectionTriangleVertexPositionsKHR instructions, Acceleration Structure must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_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-06360
For OpTraceRayKHR instructions, if Acceleration Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

VUID-RuntimeSpirv-OpVariable-08746
Any 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 instructions

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

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

VUID-RuntimeSpirv-OpUntypedVariableKHR-11167
Any OpUntypedVariableKHR must have a Data Type operand specified

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

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

VUID-RuntimeSpirv-OpImageSample-06435
If an OpImageSample* or OpImageFetch* operation has an image operand of 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_QCOM, then the SPIR-V fragment shader Capability SampleRateShading must not be enabled

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

VUID-RuntimeSpirv-Coordinate-10713
The Coordinate operand of any OpImageRead, OpImageSparseRead, OpImageWrite, 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:

VUID-RuntimeSpirv-None-10715
If a VkSampler object that enables sampler Y′C_BC_R conversion is accessed in a shader, both the sampler and image accessed must be determined by constant integral expressions

VUID-RuntimeSpirv-None-10716
If a VkSampler object that enables sampler Y′C_BC_R conversion is statically used, it must only be used with OpImageSample* or OpImageSparseSample* instructions

VUID-RuntimeSpirv-OpImage-10717
An OpImage instruction must not be used on a VkSampler object that enables sampler Y′C_BC_R conversion

VUID-RuntimeSpirv-ConstOffset-10718
If a VkSampler object that enables sampler Y′C_BC_R conversion is statically used, it must not use the ConstOffset or Offset operands

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:

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:

VUID-RuntimeSpirv-None-10834
Buffer indexing calculations must not wrap 32 bits