RuntimeSpirv

If the vulkanMemoryModel feature is enabled and the vulkanMemoryModelDeviceScope feature is not enabled, Device memory scope must not be used

If the vulkanMemoryModel feature is not enabled, QueueFamily memory scope must not be used

If the shaderSubgroupClock feature is not enabled, the Subgroup scope must not be used for OpReadClockKHR

If the shaderDeviceClock feature is not enabled, the Device scope must not be used for OpReadClockKHR

If the shaderRelaxedExtendedInstruction feature is not enabled, the OpExtInstWithForwardRefsKHR must not be used

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

Any variable declared as an OpTypeArray where the Element

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

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 Unknownmust be decorated with NonWritable

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 Unknownmust be decorated with NonReadable

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

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 interfaces-iointerfaces-limits

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

All block members in a variable with a Storage Class of PushConstant declared as an array must only be accessed by dynamically uniform indices

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

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

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

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

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

shaderBufferInt64Atomicsmust be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer or Uniform

shaderSharedInt64Atomicsmust be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Workgroup

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

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

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

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

shaderImageInt64Atomicsmust be enabled for 64-bit integer atomic operations to be supported on a Pointer with a Storage Class of Image

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

shaderFmaFloat16 must be enabled for OpFmaKHR to be supported with a result type that includes a 16-bit float

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

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

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

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

The Stream value to OpEmitStreamVertex and OpEndStreamPrimitive must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams

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

The stream number value to Stream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams

The XFB Stride value to XfbStride must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride

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

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

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

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

OpTypeCooperativeMatrixNV and OpCooperativeMatrix* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeMatrixPropertiesNV::cooperativeMatrixSupportedStages

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

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.

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

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

For OpExtractSubArrayQCOM, the Start Index operand must be a multiple of the length of the Result Type operand

If the cooperativeMatrixWorkgroupScope feature is not enabled, the scope of all OpTypeCooperativeMatrixKHR must not be VkScopeKHR::VK_SCOPE_WORKGROUP_KHR

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

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

All OpTypeCooperativeMatrixKHR dimensions must be less than or equal to cooperativeMatrixFlexibleDimensionsMaxDimension

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

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

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

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

If any OpCooperativeMatrix* instructions accesses a descriptor, it must not be a null descriptor

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)

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 BiasInterpretationmust match VkCooperativeVectorPropertiesNV::biasInterpretation
• The Result Type must match VkCooperativeVectorPropertiesNV::resultType
• If Transpose is true, VkCooperativeVectorPropertiesNV::transpose must be VK_TRUE

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

OpTypeCooperativeVectorNV and OpCooperativeVector* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeVectorPropertiesNV::cooperativeVectorSupportedStages

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

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

OpTypeCooperativeVector instructions must have Component

Count less than or equal to maxCooperativeVectorComponents

OpTypeCooperativeVector instructions must have Component

Type that is any supported type reported by vkGetPhysicalDeviceCooperativeVectorPropertiesNV

For mesh shaders using the MeshNV Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices

For mesh shaders using the MeshNV Execution Model the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives

For mesh shaders using the MeshEXT Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputVertices

For mesh shaders using the MeshEXT Execution Model the Vertex Count operand of OpSetMeshOutputsEXT must be less than or equal to OutputVertices OpExecutionMode

For mesh shaders using the MeshEXT Execution Model the OutputPrimitivesEXT OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputPrimitives

For mesh shaders using the MeshEXT Execution Model the Primitive Count operand of OpSetMeshOutputsEXT must be less than or equal to OutputPrimitivesEXT OpExecutionMode

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

In task shaders using the TaskEXT Execution Model

OpEmitMeshTasksEXT must be called exactly once under dynamically uniform conditions

In mesh shaders using the MeshEXT Execution Model

OpSetMeshOutputsEXT must be called at most once under dynamically uniform conditions

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]

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]

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]

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

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]

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]

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]

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

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]

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]

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]

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

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

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

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

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

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

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

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

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

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)

For OpCooperativeVectorMatrixMulNV and OpCooperativeVectorMatrixMulAddNV instructions using non-optimal layouts, the Stride operand must be aligned to 16 bytes

For OpCooperativeVectorMatrixMulNV and OpCooperativeVectorMatrixMulAddNV instructions, the Matrix and MatrixOffset must be aligned to 64 bytes

For OpCooperativeVectorMatrixMulAddNV instructions, the Bias and BiasOffset must be aligned to 16 bytes

For OpCooperativeVectorLoadNV and OpCooperativeVectorStoreNV instructions, the Pointer and Offset must be aligned to 16 bytes

For OpCooperativeVectorReduceSumAccumulateNV instructions, the Pointer and Offset must be aligned to 16 bytes

For OpCooperativeVectorOuterProductAccumulateNV instructions, the Pointer and Offset must be aligned to 64 bytes

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

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

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

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.

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.

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.

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

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.

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

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

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

Objects containing 8-bit integer or 8-bit floating-point elements must not have storage class of Input or Output

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

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

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

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

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

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

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

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

Group operations with subgroup scope must not be used if the shader stage is not in subgroupSupportedStages

The first element of the Offset operand of InterpolateAtOffsetmust be greater than or equal to:\

frag_width × minInterpolationOffset\

where frag_width is the width of the current fragment in pixels

The first element of the Offset operand of InterpolateAtOffsetmust be less than or equal to\

frag_width × (maxInterpolationOffset + ULP ) - ULP\

where frag_width is the width of the current fragment in pixels and ULP = 1 / 2^subPixelInterpolationOffsetBits^

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

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^

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

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

For OpRayQueryInitializeKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

For OpRayQueryInitializeKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

For OpRayQueryInitializeKHR instructions, Acceleration

Structure must be an acceleration structure built as a top-level acceleration structure

For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

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

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

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

For OpRayQueryGenerateIntersectionKHR instructions, Acceleration Structure must not be built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

For OpRayQueryGetIntersectionTriangleVertexPositionsKHR instructions, Acceleration Structure must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR in flags

For OpTraceRayKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

For OpTraceRayKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

For OpTraceRayKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

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

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

For OpTraceRayKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

For OpTraceRayKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

For OpTraceRayKHR instructions, Acceleration Structuremust be an acceleration structure built as a top-level acceleration structure

The value of the Hit Kind operand of OpReportIntersectionKHRmust be in the range [0,127]

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

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

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

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

For OpTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand

For OpTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

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

For OpTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

For OpTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

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

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

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

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

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

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

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

For OpHitObjectTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

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

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

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

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

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

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

For OpHitObjectTraceRayMotionEXT and OpHitObjectTraceMotionReorderExecuteEXT instructions, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

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

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

For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, the RayTmin operand must be less than or equal to the RayTmax operand

For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions the time operand must be between 0.0 and 1.0

For OpHitObjectTraceRayEXT, OpHitObjectTraceRayMotionEXT, OpHitObjectTraceMotionReorderExecuteEXT and OpHitObjectTraceReorderExecuteEXT instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

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

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

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

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

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]

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]

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]

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

If Execution Mode LocalSizeId is used, maintenance4 must be enabled

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

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

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

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

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

If the shaderZeroInitializeWorkgroupMemory feature is not enabled, any variable with Workgroup as its Storage Class must not have an Initializer operand

If the maintenance8 feature is not enabled, image operand Offset must only be used with OpImage*Gather instructions

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

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

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

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

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

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

If an OpTypeImage has an MS operand 0, its bound image must have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT

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

If the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, then the SPIR-V fragment shader Capability SampleRateShading must not be enabled

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

If the shaderEarlyAndLateFragmentTests feature is not enabled, the EarlyAndLateFragmentTestsEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefUnchangedFrontEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefUnchangedBackEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefGreaterFrontEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefGreaterBackEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefLessFrontEXT Execution Mode must not be used

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefLessBackEXT Execution Mode must not be used

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

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

If an OpImageSampleWeightedQCOM operation is used, then the Weight Image parameter must be decorated with WeightTextureQCOM

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

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

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

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

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

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

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

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

If an OpImageBoxFilterQCOM operation is used, then Sampled

Texture Image and Box Size parameters must be dynamically uniform

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

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

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

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

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

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

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

Variables in the NodePayloadAMDX storage class must only be declared in the GLCompute or MeshEXT execution model

Variables declared in the NodePayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

Variables declared in the NodeOutputPayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

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

Shaders must not statically initialize more than maxExecutionGraphShaderPayloadCount variables in the NodeOutputPayloadAMDX storage class

Shaders must not include more than maxExecutionGraphShaderOutputNodes instances of OpInitializeNodePayloadsAMDX

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

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

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

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

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

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

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then Block

Size less than or equal to maxBlockMatchRegion

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

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

If shaderSubgroupRotateClustered is VK_FALSE, then the ClusterSize operand to OpGroupNonUniformRotateKHR must not be used

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

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

TileShadingQCOM capability must not be declared in the compute stage unless the tileShading feature is enabled

The TileShadingQCOM capability must not be declared in the fragment stage unless the tileShadingFragmentStage feature is enabled

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

A compute shader that enables SPIR-V capability TileShadingQCOMmust only be invoked inside those portions of a command buffer where per-tile execution model is enabled

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

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

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

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

An OpImage with Storage Class TileAttachmentQCOMmust not be consumed by OpImageTexelPointer or OpUntypedImageTexelPointerEXT unless the tileShadingAtomicOps feature is enabled

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the color attachment of the current subpass instance unless the tileShadingColorAttachments feature is enabled

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the depth aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingDepthAttachments

An OpTypeImage with Storage Class TileAttachmentQCOMmust 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

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the input attachment of the current subpass instance unless the tileShadingInputAttachments feature is enabled

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

If an OpTypeSampledImage with Storage Class

TileAttachmentQCOM is consumed by any argument of the following operations, tileShadingImageProcessingmust be enabled:

• OpImageSampleWeightedQCOM
• OpImageBoxFilterQCOM
• OpImageBlockMatch*QCOM

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

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

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′C_BC_R conversion

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′C_BC_R conversion

If an image view or sampler that requires sampler Y′C_BC_R conversion is accessed in a shader, it must be determined by constant integral expressions

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

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

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

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

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

OpTypeTensorARM, OpTensorReadARM, OpTensorWriteARM, or OpTensorQuerySizeARM must not be used in shader stages not in shaderTensorSupportedStages

OpTypeTensorARM with a Shape must not be used in shader stages

OpTypeTensorARM without a Rank must not be used in shader stages

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

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

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

The GraphARM capability must not be declared in modules used to create a shader stage

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

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

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

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

The SBT Index passed in to OpHitObjectSetShaderBindingTableRecordIndexEXT must be less than or equal to VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT::maxShaderBindingTableRecordIndex

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

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

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

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

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

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

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

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

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

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

The Buffer operand of OpBufferPointerEXT must be at an offset from the base of the ResourceHeapEXT that is a multiple of bufferDescriptorAlignment

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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