Vulkan® 1.3.283 - A Specification

Appendix A: Vulkan Environment for SPIR-V

Shaders for Vulkan are defined by the Khronos SPIR-V Specification as well as the Khronos SPIR-V Extended Instructions for GLSL Specification. This appendix defines additional SPIR-V requirements applying to Vulkan shaders.

Versions and Formats

A Vulkan 1.3 implementation must support the 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, and 1.6 versions of SPIR-V and the 1.0 version of the SPIR-V Extended Instructions for GLSL.

A SPIR-V module passed into vkCreateShaderModule is interpreted as a series of 32-bit words in host endianness, with literal strings packed as described in section 2.2 of the SPIR-V Specification. The first few words of the SPIR-V module must be a magic number and a SPIR-V version number, as described in section 2.3 of the SPIR-V Specification.

Capabilities

The table below lists the set of SPIR-V capabilities that may be supported in Vulkan implementations. The application must not use any of these capabilities in SPIR-V passed to vkCreateShaderModule unless one of the following conditions is met for the VkDevice specified in the device parameter of vkCreateShaderModule:

The corresponding field in the table is blank.
Any corresponding Vulkan feature is enabled.
Any corresponding Vulkan extension is enabled.
Any corresponding Vulkan property is supported.
The corresponding core version is supported (as returned by VkPhysicalDeviceProperties::apiVersion).

Table 63. List of SPIR-V Capabilities and corresponding Vulkan features, extensions, or core version
SPIR-V `OpCapability` Vulkan feature, extension, or core version
`Matrix` VK_VERSION_1_0
`Shader` VK_VERSION_1_0
`InputAttachment` VK_VERSION_1_0
`Sampled1D` VK_VERSION_1_0
`Image1D` VK_VERSION_1_0
`SampledBuffer` VK_VERSION_1_0
`ImageBuffer` VK_VERSION_1_0
`ImageQuery` VK_VERSION_1_0
`DerivativeControl` VK_VERSION_1_0
`Geometry` `VkPhysicalDeviceFeatures`::`geometryShader`
`Tessellation` `VkPhysicalDeviceFeatures`::`tessellationShader`
`Float64` `VkPhysicalDeviceFeatures`::`shaderFloat64`
`Int64` `VkPhysicalDeviceFeatures`::`shaderInt64`
`Int64Atomics` `VkPhysicalDeviceVulkan12Features`::`shaderBufferInt64Atomics` `VkPhysicalDeviceVulkan12Features`::`shaderSharedInt64Atomics`
`Int16` `VkPhysicalDeviceFeatures`::`shaderInt16`
`TessellationPointSize` `VkPhysicalDeviceFeatures`::`shaderTessellationAndGeometryPointSize`
`GeometryPointSize` `VkPhysicalDeviceFeatures`::`shaderTessellationAndGeometryPointSize`
`ImageGatherExtended` `VkPhysicalDeviceFeatures`::`shaderImageGatherExtended`
`StorageImageMultisample` `VkPhysicalDeviceFeatures`::`shaderStorageImageMultisample`
`UniformBufferArrayDynamicIndexing` `VkPhysicalDeviceFeatures`::`shaderUniformBufferArrayDynamicIndexing`
`SampledImageArrayDynamicIndexing` `VkPhysicalDeviceFeatures`::`shaderSampledImageArrayDynamicIndexing`
`StorageBufferArrayDynamicIndexing` `VkPhysicalDeviceFeatures`::`shaderStorageBufferArrayDynamicIndexing`
`StorageImageArrayDynamicIndexing` `VkPhysicalDeviceFeatures`::`shaderStorageImageArrayDynamicIndexing`
`ClipDistance` `VkPhysicalDeviceFeatures`::`shaderClipDistance`
`CullDistance` `VkPhysicalDeviceFeatures`::`shaderCullDistance`
`ImageCubeArray` `VkPhysicalDeviceFeatures`::`imageCubeArray`
`SampleRateShading` `VkPhysicalDeviceFeatures`::`sampleRateShading`
`SparseResidency` `VkPhysicalDeviceFeatures`::`shaderResourceResidency`
`MinLod` `VkPhysicalDeviceFeatures`::`shaderResourceMinLod`
`SampledCubeArray` `VkPhysicalDeviceFeatures`::`imageCubeArray`
`ImageMSArray` `VkPhysicalDeviceFeatures`::`shaderStorageImageMultisample`
`StorageImageExtendedFormats` VK_VERSION_1_0
`InterpolationFunction` `VkPhysicalDeviceFeatures`::`sampleRateShading`
`StorageImageReadWithoutFormat` `VkPhysicalDeviceFeatures`::`shaderStorageImageReadWithoutFormat` VK_VERSION_1_3
`StorageImageWriteWithoutFormat` `VkPhysicalDeviceFeatures`::`shaderStorageImageWriteWithoutFormat` VK_VERSION_1_3
`MultiViewport` `VkPhysicalDeviceFeatures`::`multiViewport`
`DrawParameters` `VkPhysicalDeviceVulkan11Features`::`shaderDrawParameters` `VkPhysicalDeviceShaderDrawParametersFeatures`::`shaderDrawParameters`
`MultiView` `VkPhysicalDeviceVulkan11Features`::`multiview`
`DeviceGroup` VK_VERSION_1_1
`VariablePointersStorageBuffer` `VkPhysicalDeviceVulkan11Features`::`variablePointersStorageBuffer`
`VariablePointers` `VkPhysicalDeviceVulkan11Features`::`variablePointers`
`ShaderViewportIndex` `VkPhysicalDeviceVulkan12Features`::`shaderOutputViewportIndex`
`ShaderLayer` `VkPhysicalDeviceVulkan12Features`::`shaderOutputLayer`
`StorageBuffer16BitAccess` `VkPhysicalDeviceVulkan11Features`::`storageBuffer16BitAccess`
`UniformAndStorageBuffer16BitAccess` `VkPhysicalDeviceVulkan11Features`::`uniformAndStorageBuffer16BitAccess`
`StoragePushConstant16` `VkPhysicalDeviceVulkan11Features`::`storagePushConstant16`
`StorageInputOutput16` `VkPhysicalDeviceVulkan11Features`::`storageInputOutput16`
`GroupNonUniform` VK_SUBGROUP_FEATURE_BASIC_BIT
`GroupNonUniformVote` VK_SUBGROUP_FEATURE_VOTE_BIT
`GroupNonUniformArithmetic` VK_SUBGROUP_FEATURE_ARITHMETIC_BIT
`GroupNonUniformBallot` VK_SUBGROUP_FEATURE_BALLOT_BIT
`GroupNonUniformShuffle` VK_SUBGROUP_FEATURE_SHUFFLE_BIT
`GroupNonUniformShuffleRelative` VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT
`GroupNonUniformClustered` VK_SUBGROUP_FEATURE_CLUSTERED_BIT
`GroupNonUniformQuad` VK_SUBGROUP_FEATURE_QUAD_BIT
`ShaderNonUniform` VK_VERSION_1_2
`RuntimeDescriptorArray` `VkPhysicalDeviceVulkan12Features`::`runtimeDescriptorArray`
`InputAttachmentArrayDynamicIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderInputAttachmentArrayDynamicIndexing`
`UniformTexelBufferArrayDynamicIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderUniformTexelBufferArrayDynamicIndexing`
`StorageTexelBufferArrayDynamicIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderStorageTexelBufferArrayDynamicIndexing`
`UniformBufferArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderUniformBufferArrayNonUniformIndexing`
`SampledImageArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderSampledImageArrayNonUniformIndexing`
`StorageBufferArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderStorageBufferArrayNonUniformIndexing`
`StorageImageArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderStorageImageArrayNonUniformIndexing`
`InputAttachmentArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderInputAttachmentArrayNonUniformIndexing`
`UniformTexelBufferArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderUniformTexelBufferArrayNonUniformIndexing`
`StorageTexelBufferArrayNonUniformIndexing` `VkPhysicalDeviceVulkan12Features`::`shaderStorageTexelBufferArrayNonUniformIndexing`
`Float16` `VkPhysicalDeviceVulkan12Features`::`shaderFloat16`
`Int8` `VkPhysicalDeviceVulkan12Features`::`shaderInt8`
`StorageBuffer8BitAccess` `VkPhysicalDeviceVulkan12Features`::`storageBuffer8BitAccess`
`UniformAndStorageBuffer8BitAccess` `VkPhysicalDeviceVulkan12Features`::`uniformAndStorageBuffer8BitAccess`
`StoragePushConstant8` `VkPhysicalDeviceVulkan12Features`::`storagePushConstant8`
`VulkanMemoryModel` `VkPhysicalDeviceVulkan12Features`::`vulkanMemoryModel`
`VulkanMemoryModelDeviceScope` `VkPhysicalDeviceVulkan12Features`::`vulkanMemoryModelDeviceScope`
`DenormPreserve` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormPreserveFloat16` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormPreserveFloat32` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormPreserveFloat64`
`DenormFlushToZero` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormFlushToZeroFloat16` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormFlushToZeroFloat32` `VkPhysicalDeviceVulkan12Properties`::`shaderDenormFlushToZeroFloat64`
`SignedZeroInfNanPreserve` `VkPhysicalDeviceVulkan12Properties`::`shaderSignedZeroInfNanPreserveFloat16` `VkPhysicalDeviceVulkan12Properties`::`shaderSignedZeroInfNanPreserveFloat32` `VkPhysicalDeviceVulkan12Properties`::`shaderSignedZeroInfNanPreserveFloat64`
`RoundingModeRTE` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTEFloat16` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTEFloat32` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTEFloat64`
`RoundingModeRTZ` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTZFloat16` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTZFloat32` `VkPhysicalDeviceVulkan12Properties`::`shaderRoundingModeRTZFloat64`
`PhysicalStorageBufferAddresses` `VkPhysicalDeviceVulkan12Features`::`bufferDeviceAddress`
`DemoteToHelperInvocationEXT` `VkPhysicalDeviceVulkan13Features`::`shaderDemoteToHelperInvocation`
`DotProductInputAllKHR` `VkPhysicalDeviceVulkan13Features`::`shaderIntegerDotProduct`
`DotProductInput4x8BitKHR` `VkPhysicalDeviceVulkan13Features`::`shaderIntegerDotProduct`
`DotProductInput4x8BitPackedKHR` `VkPhysicalDeviceVulkan13Features`::`shaderIntegerDotProduct`
`DotProductKHR` `VkPhysicalDeviceVulkan13Features`::`shaderIntegerDotProduct`

The application must not pass a SPIR-V module containing any of the following to vkCreateShaderModule:

any OpCapability not listed above,
an unsupported capability, or
a capability which corresponds to a Vulkan feature or extension which has not been enabled.

SPIR-V Extensions

The following table lists SPIR-V extensions that implementations may support. The application must not pass a SPIR-V module to vkCreateShaderModule that uses the following SPIR-V extensions unless one of the following conditions is met for the VkDevice specified in the device parameter of vkCreateShaderModule:

Any corresponding Vulkan extension is enabled.
The corresponding core version is supported (as returned by VkPhysicalDeviceProperties::apiVersion).

Table 64. List of SPIR-V Extensions and corresponding Vulkan extensions or core version
SPIR-V `OpExtension` Vulkan extension or core version
`SPV_KHR_variable_pointers` VK_VERSION_1_1
`SPV_KHR_shader_draw_parameters` VK_VERSION_1_1
`SPV_KHR_8bit_storage` VK_VERSION_1_2
`SPV_KHR_16bit_storage` VK_VERSION_1_1
`SPV_KHR_float_controls` VK_VERSION_1_2
`SPV_KHR_storage_buffer_storage_class` VK_VERSION_1_1
`SPV_EXT_shader_viewport_index_layer` VK_VERSION_1_2
`SPV_EXT_descriptor_indexing` VK_VERSION_1_2
`SPV_KHR_vulkan_memory_model` VK_VERSION_1_2
`SPV_KHR_physical_storage_buffer` VK_VERSION_1_2
`SPV_EXT_demote_to_helper_invocation` VK_VERSION_1_3
`SPV_KHR_non_semantic_info` VK_VERSION_1_3
`SPV_KHR_terminate_invocation` VK_VERSION_1_3
`SPV_KHR_multiview` VK_VERSION_1_1
`SPV_KHR_subgroup_uniform_control_flow` VK_VERSION_1_3
`SPV_KHR_integer_dot_product` VK_VERSION_1_3
`SPV_KHR_device_group` VK_VERSION_1_1

Validation Rules Within a Module

A SPIR-V module passed to vkCreateShaderModule must conform to the following rules:

Standalone SPIR-V Validation

The following rules can be validated with only the SPIR-V module itself. They do not depend on knowledge of the implementation and its capabilities or knowledge of runtime information, such as enabled features.

Valid Usage

VUID-StandaloneSpirv-None-04633
Every entry point must have no return value and accept no arguments
VUID-StandaloneSpirv-None-04634
The static function-call graph for an entry point must not contain cycles; that is, static recursion is not allowed
VUID-StandaloneSpirv-None-04635
The Logical or PhysicalStorageBuffer64 addressing model must be selected
VUID-StandaloneSpirv-None-04636
Scope for execution must be limited to Workgroup or Subgroup
VUID-StandaloneSpirv-None-04637
If the Scope for execution is Workgroup, then it must only be used in the task, mesh, tessellation control, or compute Execution Model
VUID-StandaloneSpirv-None-04638
Scope for memory must be limited to Device, QueueFamily, Workgroup, ShaderCallKHR, Subgroup, or Invocation
VUID-StandaloneSpirv-ExecutionModel-07320
If the Execution Model is TessellationControl, and the MemoryModel is GLSL450, the Scope for memory must not be Workgroup
VUID-StandaloneSpirv-None-07321
If the Scope for memory is Workgroup, then it must only be used in the task, mesh, tessellation control, or compute Execution Model
VUID-StandaloneSpirv-None-04640
If the Scope for memory is ShaderCallKHR, then it must only be used in ray generation, intersection, closest hit, any-hit, miss, and callable Execution Model
VUID-StandaloneSpirv-None-04641
If the Scope for memory is Invocation, then memory semantics must be None
VUID-StandaloneSpirv-None-04642
Scope for group operations must be limited to Subgroup
VUID-StandaloneSpirv-SubgroupVoteKHR-07951
If none of the SubgroupVoteKHR, GroupNonUniform, or SubgroupBallotKHR capabilities are declared, Scope for memory must not be Subgroup
VUID-StandaloneSpirv-None-04643
Storage Class must be limited to UniformConstant, Input, Uniform, Output, Workgroup, Private, Function, PushConstant, Image, StorageBuffer, RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, CallableDataKHR, IncomingCallableDataKHR, ShaderRecordBufferKHR, PhysicalStorageBuffer, or TileImageEXT
VUID-StandaloneSpirv-None-04644
If the Storage Class is Output, then it must not be used in the GlCompute, RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR Execution Model
VUID-StandaloneSpirv-None-04645
If the Storage Class is Workgroup, then it must only be used in the task, mesh, or compute Execution Model
VUID-StandaloneSpirv-None-08720
If the Storage Class is TileImageEXT, then it must only be used in the fragment execution model
VUID-StandaloneSpirv-OpAtomicStore-04730
OpAtomicStore must not use Acquire, AcquireRelease, or SequentiallyConsistent memory semantics
VUID-StandaloneSpirv-OpAtomicLoad-04731
OpAtomicLoad must not use Release, AcquireRelease, or SequentiallyConsistent memory semantics
VUID-StandaloneSpirv-OpMemoryBarrier-04732
OpMemoryBarrier must use one of Acquire, Release, AcquireRelease, or SequentiallyConsistent memory semantics
VUID-StandaloneSpirv-OpMemoryBarrier-04733
OpMemoryBarrier must include at least one Storage Class
VUID-StandaloneSpirv-OpControlBarrier-04650
If the semantics for OpControlBarrier includes one of Acquire, Release, AcquireRelease, or SequentiallyConsistent memory semantics, then it must include at least one Storage Class
VUID-StandaloneSpirv-OpVariable-04651
Any OpVariable with an Initializer operand must have Output, Private, Function, or Workgroup as its Storage Class operand
VUID-StandaloneSpirv-OpVariable-04734
Any OpVariable with an Initializer operand and Workgroup as its Storage Class operand must use OpConstantNull as the initializer
VUID-StandaloneSpirv-OpReadClockKHR-04652
Scope for OpReadClockKHR must be limited to Subgroup or Device
VUID-StandaloneSpirv-OriginLowerLeft-04653
The OriginLowerLeft Execution Mode must not be used; fragment entry points must declare OriginUpperLeft
VUID-StandaloneSpirv-PixelCenterInteger-04654
The PixelCenterInteger Execution Mode must not be used (pixels are always centered at half-integer coordinates)
VUID-StandaloneSpirv-UniformConstant-04655
Any variable in the UniformConstant Storage Class must be typed as either OpTypeImage, OpTypeSampler, OpTypeSampledImage, OpTypeAccelerationStructureKHR, or an array of one of these types
VUID-StandaloneSpirv-Uniform-06807
Any variable in the Uniform or StorageBuffer Storage Class must be typed as OpTypeStruct or an array of this type
VUID-StandaloneSpirv-PushConstant-06808
Any variable in the PushConstant Storage Class must be typed as OpTypeStruct
VUID-StandaloneSpirv-OpTypeImage-04656
OpTypeImage must declare a scalar 32-bit float, 64-bit integer, or 32-bit integer type for the “Sampled Type” (RelaxedPrecision can be applied to a sampling instruction and to the variable holding the result of a sampling instruction)
VUID-StandaloneSpirv-OpTypeImage-04657
OpTypeImage must have a “Sampled” operand of 1 (sampled image) or 2 (storage image)
VUID-StandaloneSpirv-OpTypeSampledImage-06671
OpTypeSampledImage must have a OpTypeImage with a “Sampled” operand of 1 (sampled image)
VUID-StandaloneSpirv-Image-04965
The SPIR-V Type of the Image Format operand of an OpTypeImage must match the Sampled Type, as defined in Image Format and Type Matching
VUID-StandaloneSpirv-OpImageTexelPointer-04658
If an OpImageTexelPointer is used in an atomic operation, the image type of the image parameter to OpImageTexelPointer must have an image format of R64i, R64ui, R32f, R32i, or R32ui
VUID-StandaloneSpirv-OpImageQuerySizeLod-04659
OpImageQuerySizeLod, OpImageQueryLod, and OpImageQueryLevels must only consume an “Image” operand whose type has its “Sampled” operand set to 1
VUID-StandaloneSpirv-OpTypeImage-09638
An OpTypeImage must not have a “Dim” operand of Rect
VUID-StandaloneSpirv-OpTypeImage-06214
An OpTypeImage with a “Dim” operand of SubpassData must have an “Arrayed” operand of 0 (non-arrayed) and a “Sampled” operand of 2 (storage image)
VUID-StandaloneSpirv-SubpassData-04660
The (u,v) coordinates used for a SubpassData must be the <id> of a constant vector (0,0).
VUID-StandaloneSpirv-OpTypeImage-06924
Objects of types OpTypeImage, OpTypeSampler, OpTypeSampledImage, OpTypeAccelerationStructureKHR, and arrays of these types must not be stored to or modified
VUID-StandaloneSpirv-Uniform-06925
Any variable in the Uniform Storage Class decorated as Block must not be stored to or modified
VUID-StandaloneSpirv-Offset-04663
Image operand Offset must only be used with OpImage*Gather instructions
VUID-StandaloneSpirv-Offset-04865
Any image instruction which uses an Offset, ConstOffset, or ConstOffsets image operand, must only consume a “Sampled Image” operand whose type has its “Sampled” operand set to 1
VUID-StandaloneSpirv-OpImageGather-04664
The “Component” operand of OpImageGather, and OpImageSparseGather must be the <id> of a constant instruction
VUID-StandaloneSpirv-OpImage-04777
OpImage*Dref* instructions must not consume an image whose Dim is 3D
VUID-StandaloneSpirv-None-04667
Structure types must not contain opaque types
VUID-StandaloneSpirv-BuiltIn-04668
Any BuiltIn decoration not listed in Built-In Variables must not be used
VUID-StandaloneSpirv-Location-06672
The Location or Component decorations must only be used with the Input, Output, RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, HitObjectAttributeNV, CallableDataKHR, IncomingCallableDataKHR, or ShaderRecordBufferKHR storage classes
VUID-StandaloneSpirv-Location-04915
The Location or Component decorations must not be used with BuiltIn
VUID-StandaloneSpirv-Location-04916
The Location decorations must be used on user-defined variables
VUID-StandaloneSpirv-Location-04917
If a user-defined variable is not a pointer to a Block decorated OpTypeStruct, then the OpVariable must have a Location decoration
VUID-StandaloneSpirv-Location-04918
If a user-defined variable has a Location decoration, and the variable is a pointer to a OpTypeStruct, then the members of that structure must not have Location decorations
VUID-StandaloneSpirv-Location-04919
If a user-defined variable does not have a Location decoration, and the variable is a pointer to a Block decorated OpTypeStruct, then each member of the struct must have a Location decoration
VUID-StandaloneSpirv-Component-04920
The Component decoration value must not be greater than 3
VUID-StandaloneSpirv-Component-04921
If the Component decoration is used on an OpVariable that has a OpTypeVector type with a Component Type with a Width that is less than or equal to 32, the sum of its Component Count and the Component decoration value must be less than or equal to 4
VUID-StandaloneSpirv-Component-04922
If the Component decoration is used on an OpVariable that has a OpTypeVector type with a Component Type with a Width that is equal to 64, the sum of two times its Component Count and the Component decoration value must be less than or equal to 4
VUID-StandaloneSpirv-Component-04923
The Component decorations value must not be 1 or 3 for scalar or two-component 64-bit data types
VUID-StandaloneSpirv-Component-04924
The Component decorations must not be used with any type that is not a scalar or vector, or an array of such a type
VUID-StandaloneSpirv-Component-07703
The Component decorations must not be used for a 64-bit vector type with more than two components
VUID-StandaloneSpirv-Input-09557
The pointers of any Input or Output Interface user-defined variables must not contain any PhysicalStorageBuffer Storage Class pointers
VUID-StandaloneSpirv-GLSLShared-04669
The GLSLShared and GLSLPacked decorations must not be used
VUID-StandaloneSpirv-Flat-04670
The Flat, NoPerspective, Sample, and Centroid decorations must only be used on variables with the Output or Input Storage Class
VUID-StandaloneSpirv-Flat-06201
The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Output storage class in a fragment shader
VUID-StandaloneSpirv-Flat-06202
The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Input storage class in a vertex shader
VUID-StandaloneSpirv-PerVertexKHR-06777
The PerVertexKHR decoration must only be used on variables with the Input Storage Class in a fragment shader
VUID-StandaloneSpirv-Flat-04744
Any variable with integer or double-precision floating-point type and with Input Storage Class in a fragment shader, must be decorated Flat
VUID-StandaloneSpirv-ViewportRelativeNV-04672
The ViewportRelativeNV decoration must only be used on a variable decorated with Layer in the vertex, tessellation evaluation, or geometry shader stages
VUID-StandaloneSpirv-ViewportRelativeNV-04673
The ViewportRelativeNV decoration must not be used unless a variable decorated with one of ViewportIndex or ViewportMaskNV is also statically used by the same OpEntryPoint
VUID-StandaloneSpirv-ViewportMaskNV-04674
The ViewportMaskNV and ViewportIndex decorations must not both be statically used by one or more OpEntryPoint’s that form the pre-rasterization shader stages of a graphics pipeline
VUID-StandaloneSpirv-FPRoundingMode-04675
Rounding modes other than round-to-nearest-even and round-towards-zero must not be used for the FPRoundingMode decoration
VUID-StandaloneSpirv-Invariant-04677
Variables decorated with Invariant and variables with structure types that have any members decorated with Invariant must be in the Output or Input Storage Class, Invariant used on an Input Storage Class variable or structure member has no effect
VUID-StandaloneSpirv-VulkanMemoryModel-04678
If the VulkanMemoryModel capability is not declared, the Volatile decoration must be used on any variable declaration that includes one of the SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations when used in the ray generation, closest hit, miss, intersection, or callable shaders, or with the RayTmaxKHR Builtin decoration when used in an intersection shader
VUID-StandaloneSpirv-VulkanMemoryModel-04679
If the VulkanMemoryModel capability is declared, the OpLoad instruction must use the Volatile memory semantics when it accesses into any variable that includes one of the SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations when used in the ray generation, closest hit, miss, intersection, or callable shaders, or with the RayTmaxKHR Builtin decoration when used in an intersection shader
VUID-StandaloneSpirv-OpTypeRuntimeArray-04680
OpTypeRuntimeArray must only be used for:
- the last member of a Block-decorated OpTypeStruct in StorageBuffer or PhysicalStorageBuffer storage Storage Class
- BufferBlock-decorated OpTypeStruct in the Uniform storage Storage Class
- the outermost dimension of an arrayed variable in the StorageBuffer, Uniform, or UniformConstant storage Storage Class
- variables in the NodePayloadAMDX storage Storage Class when the CoalescingAMDX Execution Mode is specified
VUID-StandaloneSpirv-Function-04681
A type T that is an array sized with a specialization constant must neither be, nor be contained in, the type T2 of a variable V, unless either: a) T is equal to T2, b) V is declared in the Function, or Private Storage Class, c) V is a non-Block variable in the Workgroup Storage Class, or d) V is an interface variable with an additional level of arrayness, as described in interface matching, and T is the member type of the array type T2
VUID-StandaloneSpirv-OpControlBarrier-04682
If OpControlBarrier is used in ray generation, intersection, any-hit, closest hit, miss, fragment, vertex, tessellation evaluation, or geometry shaders, the execution Scope must be Subgroup
VUID-StandaloneSpirv-LocalSize-06426
For each compute shader entry point, either a LocalSize or LocalSizeId Execution Mode, or an object decorated with the WorkgroupSize decoration must be specified
VUID-StandaloneSpirv-DerivativeGroupQuadsNV-04684
For compute shaders using the DerivativeGroupQuadsNV execution mode, the first two dimensions of the local workgroup size must be a multiple of two
VUID-StandaloneSpirv-DerivativeGroupLinearNV-04778
For compute shaders using the DerivativeGroupLinearNV execution mode, the product of the dimensions of the local workgroup size must be a multiple of four
VUID-StandaloneSpirv-OpGroupNonUniformBallotBitCount-04685
If OpGroupNonUniformBallotBitCount is used, the group operation must be limited to Reduce, InclusiveScan, or ExclusiveScan
VUID-StandaloneSpirv-None-04686
The Pointer operand of all atomic instructions must have a Storage Class limited to Uniform, Workgroup, Image, StorageBuffer, PhysicalStorageBuffer, or TaskPayloadWorkgroupEXT
VUID-StandaloneSpirv-Offset-04687
Output variables or block members decorated with Offset that have a 64-bit type, or a composite type containing a 64-bit type, must specify an Offset value aligned to a 8 byte boundary
VUID-StandaloneSpirv-Offset-04689
The size of any output block containing any member decorated with Offset that is a 64-bit type must be a multiple of 8
VUID-StandaloneSpirv-Offset-04690
The first member of an output block specifying a Offset decoration must specify a Offset value that is aligned to an 8 byte boundary if that block contains any member decorated with Offset and is a 64-bit type
VUID-StandaloneSpirv-Offset-04691
Output variables or block members decorated with Offset that have a 32-bit type, or a composite type contains a 32-bit type, must specify an Offset value aligned to a 4 byte boundary
VUID-StandaloneSpirv-Offset-04692
Output variables, blocks or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size
VUID-StandaloneSpirv-Offset-04716
Only variables or block members in the output interface decorated with Offset can be captured for transform feedback, and those variables or block members must also be decorated with XfbBuffer and XfbStride, or inherit XfbBuffer and XfbStride decorations from a block containing them
VUID-StandaloneSpirv-XfbBuffer-04693
All variables or block members in the output interface of the entry point being compiled decorated with a specific XfbBuffer value must all be decorated with identical XfbStride values
VUID-StandaloneSpirv-Stream-04694
If any variables or block members in the output interface of the entry point being compiled are decorated with Stream, then all variables belonging to the same XfbBuffer must specify the same Stream value
VUID-StandaloneSpirv-XfbBuffer-04696
For any two variables or block members in the output interface of the entry point being compiled with the same XfbBuffer value, the ranges determined by the Offset decoration and the size of the type must not overlap
VUID-StandaloneSpirv-XfbBuffer-04697
All block members in the output interface of the entry point being compiled that are in the same block and have a declared or inherited XfbBuffer decoration must specify the same XfbBuffer value
VUID-StandaloneSpirv-RayPayloadKHR-04698
RayPayloadKHR Storage Class must only be used in ray generation, closest hit or miss shaders
VUID-StandaloneSpirv-IncomingRayPayloadKHR-04699
IncomingRayPayloadKHR Storage Class must only be used in closest hit, any-hit, or miss shaders
VUID-StandaloneSpirv-IncomingRayPayloadKHR-04700
There must be at most one variable with the IncomingRayPayloadKHR Storage Class in the input interface of an entry point
VUID-StandaloneSpirv-HitAttributeKHR-04701
HitAttributeKHR Storage Class must only be used in intersection, any-hit, or closest hit shaders
VUID-StandaloneSpirv-HitAttributeKHR-04702
There must be at most one variable with the HitAttributeKHR Storage Class in the input interface of an entry point
VUID-StandaloneSpirv-HitAttributeKHR-04703
A variable with HitAttributeKHR Storage Class must only be written to in an intersection shader
VUID-StandaloneSpirv-CallableDataKHR-04704
CallableDataKHR Storage Class must only be used in ray generation, closest hit, miss, and callable shaders
VUID-StandaloneSpirv-IncomingCallableDataKHR-04705
IncomingCallableDataKHR Storage Class must only be used in callable shaders
VUID-StandaloneSpirv-IncomingCallableDataKHR-04706
There must be at most one variable with the IncomingCallableDataKHR Storage Class in the input interface of an entry point
VUID-StandaloneSpirv-ShaderRecordBufferKHR-07119
ShaderRecordBufferKHR Storage Class must only be used in ray generation, intersection, any-hit, closest hit, callable, or miss shaders
VUID-StandaloneSpirv-Base-07650
The Base operand of OpPtrAccessChain must have a storage class of Workgroup, StorageBuffer, or PhysicalStorageBuffer
VUID-StandaloneSpirv-Base-07651
If the Base operand of OpPtrAccessChain has a Workgroup Storage Class, then the VariablePointers capability must be declared
VUID-StandaloneSpirv-Base-07652
If the Base operand of OpPtrAccessChain has a StorageBuffer Storage Class, then the VariablePointers or VariablePointersStorageBuffer capability must be declared
VUID-StandaloneSpirv-PhysicalStorageBuffer64-04708
If the PhysicalStorageBuffer64 addressing model is enabled, all instructions that support memory access operands and that use a physical pointer must include the Aligned operand
VUID-StandaloneSpirv-PhysicalStorageBuffer64-04709
If the PhysicalStorageBuffer64 addressing model is enabled, any access chain instruction that accesses into a RowMajor matrix must only be used as the Pointer operand to OpLoad or OpStore
VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710
If the PhysicalStorageBuffer64 addressing model is enabled, OpConvertUToPtr and OpConvertPtrToU must use an integer type whose Width is 64
VUID-StandaloneSpirv-OpTypeForwardPointer-04711
OpTypeForwardPointer must have a Storage Class of PhysicalStorageBuffer
VUID-StandaloneSpirv-None-04745
All block members in a variable with a Storage Class of PushConstant declared as an array must only be accessed by dynamically uniform indices
VUID-StandaloneSpirv-OpVariable-06673
There must not be more than one OpVariable in the PushConstant Storage Class listed in the Interface for each OpEntryPoint
VUID-StandaloneSpirv-OpEntryPoint-06674
Each OpEntryPoint must not statically use more than one OpVariable in the PushConstant Storage Class
VUID-StandaloneSpirv-OpEntryPoint-08721
Each OpEntryPoint must not have more than one Input variable assigned the same Component word inside a Location slot, either explicitly or implicitly
VUID-StandaloneSpirv-OpEntryPoint-08722
Each OpEntryPoint must not have more than one Output variable assigned the same Component word inside a Location slot, either explicitly or implicitly
VUID-StandaloneSpirv-Result-04780
The Result Type operand of any OpImageRead or OpImageSparseRead instruction must be a vector of four components
VUID-StandaloneSpirv-Base-04781
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-StandaloneSpirv-PushConstant-06675
Any variable in the PushConstant or StorageBuffer storage class must be decorated as Block
VUID-StandaloneSpirv-Uniform-06676
Any variable in the Uniform Storage Class must be decorated as Block or BufferBlock
VUID-StandaloneSpirv-UniformConstant-06677
Any variable in the UniformConstant, StorageBuffer, or Uniform Storage Class must be decorated with DescriptorSet and Binding
VUID-StandaloneSpirv-InputAttachmentIndex-06678
Variables decorated with InputAttachmentIndex must be in the UniformConstant Storage Class
VUID-StandaloneSpirv-DescriptorSet-06491
If a variable is decorated by DescriptorSet or Binding, the Storage Class must correspond to an entry in Shader Resource and Storage Class Correspondence
VUID-StandaloneSpirv-Input-06778
Variables with a Storage Class of Input in a fragment shader stage that are decorated with PerVertexKHR must be declared as arrays
VUID-StandaloneSpirv-MeshEXT-07102
The module must not contain both an entry point that uses the TaskEXT or MeshEXT Execution Model and an entry point that uses the TaskNV or MeshNV Execution Model
VUID-StandaloneSpirv-MeshEXT-07106
In mesh shaders using the MeshEXT Execution Model OpSetMeshOutputsEXT must be called before any outputs are written
VUID-StandaloneSpirv-MeshEXT-07107
In mesh shaders using the MeshEXT Execution Model all variables declared as output must not be read from
VUID-StandaloneSpirv-MeshEXT-07108
In mesh shaders using the MeshEXT Execution Model for OpSetMeshOutputsEXT instructions, the “Vertex Count” and “Primitive Count” operands must not depend on ViewIndex
VUID-StandaloneSpirv-MeshEXT-07109
In mesh shaders using the MeshEXT Execution Model variables decorated with PrimitivePointIndicesEXT, PrimitiveLineIndicesEXT, or PrimitiveTriangleIndicesEXT declared as an array must not be accessed by indices that depend on ViewIndex
VUID-StandaloneSpirv-MeshEXT-07110
In mesh shaders using the MeshEXT Execution Model any values stored in variables decorated with PrimitivePointIndicesEXT, PrimitiveLineIndicesEXT, or PrimitiveTriangleIndicesEXT must not depend on ViewIndex
VUID-StandaloneSpirv-MeshEXT-07111
In mesh shaders using the MeshEXT Execution Model variables in workgroup or private Storage Class declared as or containing a composite type must not be accessed by indices that depend on ViewIndex
VUID-StandaloneSpirv-MeshEXT-07330
In mesh shaders using the MeshEXT Execution Model the OutputVertices Execution Mode must be greater than 0
VUID-StandaloneSpirv-MeshEXT-07331
In mesh shaders using the MeshEXT Execution Model the OutputPrimitivesEXT Execution Mode must be greater than 0
VUID-StandaloneSpirv-Input-07290
Variables with a Storage Class of Input or Output and a type of OpTypeBool must be decorated with the BuiltIn decoration
VUID-StandaloneSpirv-TileImageEXT-08723
The tile image variable declarations must obey the constraints on the TileImageEXT Storage Class and the Location decoration described in Fragment Tile Image Interface
VUID-StandaloneSpirv-None-08724
The TileImageEXT Storage Class must only be used for declaring tile image variables
VUID-StandaloneSpirv-Pointer-08973
The Storage Class of the Pointer operand to OpCooperativeMatrixLoadKHR or OpCooperativeMatrixStoreKHR must be limited to Workgroup, StorageBuffer, or PhysicalStorageBuffer

Runtime SPIR-V Validation

The following rules must be validated at runtime. These rules depend on knowledge of the implementation and its capabilities and knowledge of runtime information, such as enabled features.

Valid Usage

VUID-RuntimeSpirv-vulkanMemoryModel-06265
If vulkanMemoryModel is enabled and vulkanMemoryModelDeviceScope is not enabled, Device memory scope must not be used
VUID-RuntimeSpirv-vulkanMemoryModel-06266
If vulkanMemoryModel is not enabled, QueueFamily memory scope must not be used
VUID-RuntimeSpirv-None-09558
Any variable created with a “Type” of OpTypeImage that has a “Dim” operand of SubpassData must be decorated with InputAttachmentIndex
VUID-RuntimeSpirv-apiVersion-07952
If VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.3, and shaderStorageImageWriteWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonWritable
VUID-RuntimeSpirv-apiVersion-07953
If VkPhysicalDeviceProperties::apiVersion is less than Vulkan 1.3, and shaderStorageImageReadWithoutFormat is not enabled, any variable created with a “Type” of OpTypeImage that has a “Sampled” operand of 2 and an “Image Format” operand of Unknown must be decorated with NonReadable
VUID-RuntimeSpirv-OpImageWrite-07112
OpImageWrite to any Image whose Image Format is not Unknown must have the Texel operand contain at least as many components as the corresponding VkFormat as given in the SPIR-V Image Format compatibility table
VUID-RuntimeSpirv-Location-06272
The sum of Location and the number of locations the variable it decorates consumes must be less than or equal to the value for the matching Execution Model defined in 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-NonUniform-06274
If an instruction loads from or stores to a resource (including atomics and image instructions) and the resource descriptor being accessed is not dynamically uniform, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform
VUID-RuntimeSpirv-None-06275
shaderSubgroupExtendedTypes must be enabled for group operations to use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types
VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06276
If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Index” for OpGroupNonUniformQuadBroadcast must be dynamically uniform within the derivative group. Otherwise, “Index” must be a constant
VUID-RuntimeSpirv-subgroupBroadcastDynamicId-06277
If subgroupBroadcastDynamicId is VK_TRUE, and the shader module version is 1.5 or higher, the “Id” for OpGroupNonUniformBroadcast must be dynamically uniform within the subgroup. Otherwise, “Id” must be a constant
VUID-RuntimeSpirv-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-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-DescriptorSet-06323
DescriptorSet and Binding decorations must obey the constraints on Storage Class, type, and descriptor type described in DescriptorSet and Binding Assignment
VUID-RuntimeSpirv-NonWritable-06340
If fragmentStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the fragment stage must be decorated with the NonWritable decoration
VUID-RuntimeSpirv-NonWritable-06341
If vertexPipelineStoresAndAtomics is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the vertex, tessellation, and geometry stages must be decorated with the NonWritable decoration
VUID-RuntimeSpirv-None-06342
If subgroupQuadOperationsInAllStages is VK_FALSE, then quad subgroup operations must not be used except for in fragment and compute stages
VUID-RuntimeSpirv-None-06343
Group operations with subgroup scope must not be used if the shader stage is not in subgroupSupportedStages
VUID-RuntimeSpirv-Offset-06344
The first element of the Offset operand of InterpolateAtOffset must be greater than or equal to:
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-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 maintenance4 is not enabled, any OpTypeVector output interface variables must not have a higher Component Count than a matching OpTypeVector input interface variable
VUID-RuntimeSpirv-OpEntryPoint-08743
Any user-defined variables shared between the OpEntryPoint of two shader stages, and declared with Input as its Storage Class for the subsequent shader stage, must have all Location slots and Component words declared in the preceding shader stage’s OpEntryPoint with Output as the Storage Class
VUID-RuntimeSpirv-OpEntryPoint-07754
Any user-defined variables between the OpEntryPoint of two shader stages must have the same type and width for each Component
VUID-RuntimeSpirv-OpVariable-08746
Any OpVariable, Block-decorated OpTypeStruct, or Block-decorated OpTypeStruct members shared between the OpEntryPoint of two shader stages must have matching decorations as defined in interface matching
VUID-RuntimeSpirv-Workgroup-06530
The sum of size in bytes for variables and padding in the Workgroup Storage Class in the GLCompute Execution Model must be less than or equal to maxComputeSharedMemorySize
VUID-RuntimeSpirv-shaderZeroInitializeWorkgroupMemory-06372
If shaderZeroInitializeWorkgroupMemory is not enabled, any OpVariable with Workgroup as its Storage Class must not have an Initializer operand
VUID-RuntimeSpirv-OpImage-06376
If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be greater than or equal to minTexelGatherOffset
VUID-RuntimeSpirv-OpImage-06377
If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be less than or equal to maxTexelGatherOffset
VUID-RuntimeSpirv-OpImageSample-06435
If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be greater than or equal to minTexelOffset
VUID-RuntimeSpirv-OpImageSample-06436
If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be less than or equal to maxTexelOffset
VUID-RuntimeSpirv-samples-08725
If an OpTypeImage has an MS operand 0, its bound image must have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT
VUID-RuntimeSpirv-samples-08726
If an OpTypeImage has an MS operand 1, its bound image must not have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT
VUID-RuntimeSpirv-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-MeshEXT-09218
In mesh shaders using the MeshEXT or MeshNV Execution Model and the OutputPoints Execution Mode, if the number of output points is greater than 0, a PointSize decorated variable must be written to for each output point
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

Precision and Operation of SPIR-V Instructions

The following rules apply to half, single, and double-precision floating point instructions:

Positive and negative infinities and positive and negative zeros are generated as dictated by IEEE 754, but subject to the precisions allowed in the following table.
Dividing a non-zero by a zero results in the appropriately signed IEEE 754 infinity.
Signaling NaNs are not required to be generated and exceptions are never raised. Signaling NaN may be converted to quiet NaNs values by any floating point instruction.
By default, the implementation may perform optimizations on half, single, or double-precision floating-point instructions that ignore sign of a zero, or assume that arguments and results are not NaNs or infinities. If the entry point is declared with the SignedZeroInfNanPreserve Execution Mode, then NaNs, infinities, and the sign of zero must not be ignored.
- The following core SPIR-V instructions must respect the SignedZeroInfNanPreserve Execution Mode: OpPhi, OpSelect, OpReturnValue, OpVectorExtractDynamic, OpVectorInsertDynamic, OpVectorShuffle, OpCompositeConstruct, OpCompositeExtract, OpCompositeInsert, OpCopyObject, OpTranspose, OpFConvert, OpFNegate, OpFAdd, OpFSub, OpFMul, OpStore. This Execution Mode must also be respected by OpLoad except for loads from the Input Storage Class in the fragment shader stage with the floating-point result type. Other SPIR-V instructions may also respect the SignedZeroInfNanPreserve Execution Mode.
The following instructions must not flush denormalized values: OpConstant, OpConstantComposite, OpSpecConstant, OpSpecConstantComposite, OpLoad, OpStore, OpBitcast, OpPhi, OpSelect, OpFunctionCall, OpReturnValue, OpVectorExtractDynamic, OpVectorInsertDynamic, OpVectorShuffle, OpCompositeConstruct, OpCompositeExtract, OpCompositeInsert, OpCopyMemory, OpCopyObject.
Denormalized values are supported.
- By default, any half, single, or double-precision denormalized value input into a shader or potentially generated by any instruction (except those listed above) or any extended instructions for GLSL in a shader may be flushed to zero.
- If the entry point is declared with the DenormFlushToZero Execution Mode then for the affected instructions the denormalized result must be flushed to zero and the denormalized operands may be flushed to zero. Denormalized values obtained via unpacking an integer into a vector of values with smaller bit width and interpreting those values as floating-point numbers must be flushed to zero.
- The following core SPIR-V instructions must respect the DenormFlushToZero Execution Mode: OpSpecConstantOp (with opcode OpFConvert), OpFConvert, OpFNegate, OpFAdd, OpFSub, OpFMul, OpFDiv, OpFRem, OpFMod, OpVectorTimesScalar, OpMatrixTimesScalar, OpVectorTimesMatrix, OpMatrixTimesVector, OpMatrixTimesMatrix, OpOuterProduct, OpDot; and the following extended instructions for GLSL: Round, RoundEven, Trunc, FAbs, Floor, Ceil, Fract, Radians, Degrees, Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Asinh, Acosh, Atanh, Atan2, Pow, Exp, Log, Exp2, Log2, Sqrt, InverseSqrt, Determinant, MatrixInverse, Modf, ModfStruct, FMin, FMax, FClamp, FMix, Step, SmoothStep, Fma, UnpackHalf2x16, UnpackDouble2x32, Length, Distance, Cross, Normalize, FaceForward, Reflect, Refract, NMin, NMax, NClamp. Other SPIR-V instructions (except those excluded above) may also flush denormalized values.
- The following core SPIR-V instructions must respect the DenormPreserve Execution Mode: OpTranspose, OpSpecConstantOp, OpFConvert, OpFNegate, OpFAdd, OpFSub, OpFMul, OpVectorTimesScalar, OpMatrixTimesScalar, OpVectorTimesMatrix, OpMatrixTimesVector, OpMatrixTimesMatrix, OpOuterProduct, OpDot, OpFOrdEqual, OpFUnordEqual, OpFOrdNotEqual, OpFUnordNotEqual, OpFOrdLessThan, OpFUnordLessThan, OpFOrdGreaterThan, OpFUnordGreaterThan, OpFOrdLessThanEqual, OpFUnordLessThanEqual, OpFOrdGreaterThanEqual, OpFUnordGreaterThanEqual; and the following extended instructions for GLSL: FAbs, FSign, Radians, Degrees, FMin, FMax, FClamp, FMix, Fma, PackHalf2x16, PackDouble2x32, UnpackHalf2x16, UnpackDouble2x32, NMin, NMax, NClamp. Other SPIR-V instructions may also preserve denorm values.

The precision of double-precision instructions is at least that of single precision.

The precision of individual operations is defined in Precision of Individual Operations. Subject to the constraints below, however, implementations may reorder or combine operations, resulting in expressions exhibiting different precisions than might be expected from the constituent operations.

Evaluation of Expressions

Implementations may rearrange floating-point operations using any of the mathematical properties governing the expressions in precise arithmetic, even where the floating- point operations do not share these properties. This includes, but is not limited to, associativity and distributivity, and may involve a different number of rounding steps than would occur if the operations were not rearranged. In shaders that use the SignedZeroInfNanPreserve Execution Mode the values must be preserved if they are generated after any rearrangement but the Execution Mode does not change which rearrangements are valid. This rearrangement can be prevented for particular operations by using the NoContraction decoration.

Note

For example, in the absence of the NoContraction decoration implementations are allowed to implement a + b - a and $\frac{a \times b}{a}$ as b. The SignedZeroInfNanPreserve does not prevent these transformations, even though they may overflow to infinity or NaN when evaluated in floating-point.

If the NoContraction decoration is applied then operations may not be rearranged, so, for example, a + a - a must account for possible overflow to infinity. If infinities are not preserved then the expression may be replaced with a, since the replacement is exact when overflow does not occur and infinities may be replaced with undefined values. If both NoContraction and SignedZeroInfNanPreserve are used then the result must be infinity for sufficiently large a.

Precision of Individual Operations

The precision of individual operations is defined either in terms of rounding (correctly rounded), as an error bound in ULP, or as inherited from a formula as follows:

Correctly Rounded

Operations described as “correctly rounded” will return the infinitely precise result, x, rounded so as to be representable in floating-point. The rounding mode is not specified, unless the entry point is declared with the RoundingModeRTE or the RoundingModeRTZ Execution Mode. These execution modes affect only correctly rounded SPIR-V instructions. These execution modes do not affect OpQuantizeToF16. If the rounding mode is not specified then this rounding is implementation specific, subject to the following rules. If x is exactly representable then x will be returned. Otherwise, either the floating-point value closest to and no less than x or the value closest to and no greater than x will be returned.

ULP

Where an error bound of n ULP (units in the last place) is given, for an operation with infinitely precise result x the value returned must be in the range [x - n × ulp(x), x + n × ulp(x)]. The function ulp(x) is defined as follows:

: If there exist non-equal, finite floating-point numbers a and b such that a ≤ x ≤ b then ulp(x) is the minimum possible distance between such numbers, $u l p (x) = m i n_{a, b} ∣ b - a ∣$ . If such numbers do not exist then ulp(x) is defined to be the difference between the two non-equal, finite floating-point numbers nearest to x.

Where the range of allowed return values includes any value of magnitude larger than that of the largest representable finite floating-point number, operations may, additionally, return either an infinity of the appropriate sign or the finite number with the largest magnitude of the appropriate sign. If the infinitely precise result of the operation is not mathematically defined then the value returned is undefined.

Inherited From …

Where an operation’s precision is described as being inherited from a formula, the result returned must be at least as accurate as the result of computing an approximation to x using a formula equivalent to the given formula applied to the supplied inputs. Specifically, the formula given may be transformed using the mathematical associativity, commutativity and distributivity of the operators involved to yield an equivalent formula. The SPIR-V precision rules, when applied to each such formula and the given input values, define a range of permitted values. If NaN is one of the permitted values then the operation may return any result, otherwise let the largest permitted value in any of the ranges be F_max and the smallest be F_min. The operation must return a value in the range [x - E, x + E] where $E = m a x (∣ x - F_{m i n} ∣, ∣ x - F_{m a x} ∣)$ . If the entry point is declared with the DenormFlushToZero execution mode, then any intermediate denormal value(s) while evaluating the formula may be flushed to zero. Denormal final results must be flushed to zero. If the entry point is declared with the DenormPreserve Execution Mode, then denormals must be preserved throughout the formula.

For half- (16 bit) and single- (32 bit) precision instructions, precisions are required to be at least as follows:

Table 65. Precision of core SPIR-V Instructions
Instruction	Single precision, unless decorated with RelaxedPrecision	Half precision
`OpFAdd`	Correctly rounded.
`OpFSub`	Correctly rounded.
`OpFMul`, `OpVectorTimesScalar`, `OpMatrixTimesScalar`	Correctly rounded.
`OpDot`(x, y)	Inherited from $\sum_{i = 0}^{n - 1} x_{i} \times y_{i}$ .
`OpFOrdEqual`, `OpFUnordEqual`	Correct result.
`OpFOrdLessThan`, `OpFUnordLessThan`	Correct result.
`OpFOrdGreaterThan`, `OpFUnordGreaterThan`	Correct result.
`OpFOrdLessThanEqual`, `OpFUnordLessThanEqual`	Correct result.
`OpFOrdGreaterThanEqual`, `OpFUnordGreaterThanEqual`	Correct result.
`OpFDiv`(x,y)	2.5 ULP for \|y\| in the range [2^-126, 2¹²⁶].	2.5 ULP for \|y\| in the range [2^-14, 2¹⁴].
`OpFRem`(x,y)	Inherited from x - y × trunc(x/y).
`OpFMod`(x,y)	Inherited from x - y × floor(x/y).
conversions between types	Correctly rounded.

Note

The OpFRem and OpFMod instructions use cheap approximations of remainder, and the error can be large due to the discontinuity in trunc() and floor(). This can produce mathematically unexpected results in some cases, such as FMod(x,x) computing x rather than 0, and can also cause the result to have a different sign than the infinitely precise result.

Table 66. Precision of GLSL.std.450 Instructions
Instruction	Single precision, unless decorated with RelaxedPrecision	Half precision
`fma`()	Inherited from `OpFMul` followed by `OpFAdd`.
`exp`(x), `exp2`(x)	$3 + 2 \times ∣ x ∣$ ULP.	$1 + 2 \times ∣ x ∣$ ULP.
`log`(), `log2`()	3 ULP outside the range $[0.5, 2.0]$ . Absolute error < $2^{- 21}$ inside the range $[0.5, 2.0]$ .	3 ULP outside the range $[0.5, 2.0]$ . Absolute error < $2^{- 7}$ inside the range $[0.5, 2.0]$ .
`pow`(x, y)	Inherited from `exp2`(y × `log2`(x)).
`sqrt`()	Inherited from 1.0 / `inversesqrt`().
`inversesqrt`()	2 ULP.
`radians`(x)	Inherited from $x \times C_{π_180}$ , where $C_{π_180}$ is a correctly rounded approximation to $\frac{π}{1 8 0}$ .
`degrees`(x)	Inherited from $x \times C_{180_π}$ , where $C_{180_π}$ is a correctly rounded approximation to $\frac{1 8 0}{π}$ .
`sin`()	Absolute error $\leq 2^{- 11}$ inside the range $[- π, π]$ .	Absolute error $\leq 2^{- 7}$ inside the range $[- π, π]$ .
`cos`()	Absolute error $\leq 2^{- 11}$ inside the range $[- π, π]$ .	Absolute error $\leq 2^{- 7}$ inside the range $[- π, π]$ .
`tan`()	Inherited from $\frac{s i n ( )}{c o s ( )}$ .
`asin`(x)	Inherited from $a t a n 2 (x, s q r t (1.0 - x \times x))$ .
`acos`(x)	Inherited from $a t a n 2 (s q r t (1.0 - x \times x), x)$ .
`atan`(), `atan2`()	4096 ULP	5 ULP.
`sinh`(x)	Inherited from $(exp (x) - exp (- x)) \times 0.5$ .
`cosh`(x)	Inherited from $(exp (x) + exp (- x)) \times 0.5$ .
`tanh`()	Inherited from $\frac{s i n h ( )}{c o s h ( )}$ .
`asinh`(x)	Inherited from $lo g (x + s q r t (x \times x + 1.0))$ .
`acosh`(x)	Inherited from $lo g (x + s q r t (x \times x - 1.0))$ .
`atanh`(x)	Inherited from $lo g (\frac{1 . 0 + x}{1 . 0 - x}) \times 0.5$ .
`frexp`()	Correctly rounded.
`ldexp`()	Correctly rounded.
`length`(x)	Inherited from $s q r t (d o t (x, x))$ .
`distance`(x, y)	Inherited from $l e n g t h (x - y)$ .
`cross`()	Inherited from `OpFSub`(`OpFMul`, `OpFMul`).
`normalize`(x)	Inherited from $x \times i n v e r s e s q r t (d o t (x, x))$ .
`faceforward`(N, I, NRef)	Inherited from `dot`(NRef, I) < 0.0 ? N : -N.
`reflect`(x, y)	Inherited from x - 2.0 × `dot`(y, x) × y.
`refract`(I, N, eta)	Inherited from k < 0.0 ? 0.0 : eta × I - (eta × `dot`(N, I) + `sqrt`(k)) × N, where k = 1 - eta × eta × (1.0 - `dot`(N, I) × `dot`(N, I)).
`round`	Correctly rounded.
`roundEven`	Correctly rounded.
`trunc`	Correctly rounded.
`fabs`	Correctly rounded.
`fsign`	Correctly rounded.
`floor`	Correctly rounded.
`ceil`	Correctly rounded.
`fract`	Correctly rounded.
`modf`	Correctly rounded.
`fmin`	Correctly rounded.
`fmax`	Correctly rounded.
`fclamp`	Correctly rounded.
`fmix`(x, y, a)	Inherited from $x \times (1.0 - a) + y \times a$ .
`step`	Correctly rounded.
`smoothStep`(edge0, edge1, x)	Inherited from $t \times t \times (3.0 - 2.0 \times t)$ , where $t = c l a m p (\frac{x - e d g e 0}{e d g e 1 - e d g e 0}, 0.0, 1.0)$ .
`nmin`	Correctly rounded.
`nmax`	Correctly rounded.
`nclamp`	Correctly rounded.

GLSL.std.450 extended instructions specifically defined in terms of the above instructions inherit the above errors. GLSL.std.450 extended instructions not listed above and not defined in terms of the above have undefined precision.

For the OpSRem and OpSMod instructions, if either operand is negative the result is undefined.

Note

While the OpSRem and OpSMod instructions are supported by the Vulkan environment, they require non-negative values and thus do not enable additional functionality beyond what OpUMod provides.

Signedness of SPIR-V Image Accesses

SPIR-V associates a signedness with all integer image accesses. This is required in certain parts of the SPIR-V and the Vulkan image access pipeline to ensure defined results. The signedness is determined from a combination of the access instruction’s Image Operands and the underlying image’s Sampled Type as follows:

If the instruction’s Image Operands contains the SignExtend operand then the access is signed.
If the instruction’s Image Operands contains the ZeroExtend operand then the access is unsigned.
Otherwise, the image accesses signedness matches that of the Sampled Type of the OpTypeImage being accessed.

Image Format and Type Matching

When specifying the Image Format of an OpTypeImage, the converted bit width and type, as shown in the table below, must match the Sampled Type. The signedness must match the signedness of any access to the image.

Note

Formatted accesses are always converted from a shader readable type to the resource’s format or vice versa via Format Conversion for reads and Texel Output Format Conversion for writes. As such, the bit width and format below do not necessarily match 1:1 with what might be expected for some formats.

For a given Image Format, the Sampled Type must be the type described in the Type column of the below table, with its Literal Width set to that in the Bit Width column. Every access that is made to the image must have a signedness equal to that in the Signedness column (where applicable).

Image Format Type-Declaration instructions Bit Width Signedness

Image Format	Type-Declaration instructions	Bit Width	Signedness
`Unknown`	Any	Any	Any
`Rgba32f`	`OpTypeFloat`	32	N/A
`Rg32f`
`R32f`
`Rgba16f`
`Rg16f`
`R16f`
`Rgba16`
`Rg16`
`R16`
`Rgba16Snorm`
`Rg16Snorm`
`R16Snorm`
`Rgb10A2`
`R11fG11fB10f`
`Rgba8`
`Rg8`
`R8`
`Rgba8Snorm`
`Rg8Snorm`
`R8Snorm`
`Rgba32i`	`OpTypeInt`	32	1
`Rg32i`
`R32i`
`Rgba16i`
`Rg16i`
`R16i`
`Rgba8i`
`Rg8i`
`R8i`
`Rgba32ui`	0
`Rg32ui`
`R32ui`
`Rgba16ui`
`Rg16ui`
`R16ui`
`Rgb10a2ui`
`Rgba8ui`
`Rg8ui`
`R8ui`
`R64i`	`OpTypeInt`	64	1
`R64ui`	0

Unknown

Any

Rgba32f

OpTypeFloat

N/A

Rg32f

R32f

Rgba16f

Rg16f

R16f

Rgba16

Rg16

R16

Rgba16Snorm

Rg16Snorm

R16Snorm

Rgb10A2

R11fG11fB10f

Rgba8

Rg8

R8

Rgba8Snorm

Rg8Snorm

R8Snorm

Rgba32i

OpTypeInt

Rg32i

R32i

Rgba16i

Rg16i

R16i

Rgba8i

Rg8i

R8i

Rgba32ui

Rg32ui

R32ui

Rgba16ui

Rg16ui

R16ui

Rgb10a2ui

Rgba8ui

Rg8ui

R8ui

R64i

OpTypeInt

R64ui

The SPIR-V Type is defined by an instruction in SPIR-V, declared with the Type-Declaration Instruction, Bit Width, and Signedness from above.

Compatibility Between SPIR-V Image Formats and Vulkan Formats

SPIR-V Image Format values are compatible with VkFormat values as defined below:

Table 67. SPIR-V and Vulkan Image Format Compatibility
SPIR-V Image Format	Compatible Vulkan Format
`Unknown`	Any
`R8`	`VK_FORMAT_R8_UNORM`
`R8Snorm`	`VK_FORMAT_R8_SNORM`
`R8ui`	`VK_FORMAT_R8_UINT`
`R8i`	`VK_FORMAT_R8_SINT`
`Rg8`	`VK_FORMAT_R8G8_UNORM`
`Rg8Snorm`	`VK_FORMAT_R8G8_SNORM`
`Rg8ui`	`VK_FORMAT_R8G8_UINT`
`Rg8i`	`VK_FORMAT_R8G8_SINT`
`Rgba8`	`VK_FORMAT_R8G8B8A8_UNORM`
`Rgba8Snorm`	`VK_FORMAT_R8G8B8A8_SNORM`
`Rgba8ui`	`VK_FORMAT_R8G8B8A8_UINT`
`Rgba8i`	`VK_FORMAT_R8G8B8A8_SINT`
`Rgb10A2`	`VK_FORMAT_A2B10G10R10_UNORM_PACK32`
`Rgb10a2ui`	`VK_FORMAT_A2B10G10R10_UINT_PACK32`
`R16`	`VK_FORMAT_R16_UNORM`
`R16Snorm`	`VK_FORMAT_R16_SNORM`
`R16ui`	`VK_FORMAT_R16_UINT`
`R16i`	`VK_FORMAT_R16_SINT`
`R16f`	`VK_FORMAT_R16_SFLOAT`
`Rg16`	`VK_FORMAT_R16G16_UNORM`
`Rg16Snorm`	`VK_FORMAT_R16G16_SNORM`
`Rg16ui`	`VK_FORMAT_R16G16_UINT`
`Rg16i`	`VK_FORMAT_R16G16_SINT`
`Rg16f`	`VK_FORMAT_R16G16_SFLOAT`
`Rgba16`	`VK_FORMAT_R16G16B16A16_UNORM`
`Rgba16Snorm`	`VK_FORMAT_R16G16B16A16_SNORM`
`Rgba16ui`	`VK_FORMAT_R16G16B16A16_UINT`
`Rgba16i`	`VK_FORMAT_R16G16B16A16_SINT`
`Rgba16f`	`VK_FORMAT_R16G16B16A16_SFLOAT`
`R32ui`	`VK_FORMAT_R32_UINT`
`R32i`	`VK_FORMAT_R32_SINT`
`R32f`	`VK_FORMAT_R32_SFLOAT`
`Rg32ui`	`VK_FORMAT_R32G32_UINT`
`Rg32i`	`VK_FORMAT_R32G32_SINT`
`Rg32f`	`VK_FORMAT_R32G32_SFLOAT`
`Rgba32ui`	`VK_FORMAT_R32G32B32A32_UINT`
`Rgba32i`	`VK_FORMAT_R32G32B32A32_SINT`
`Rgba32f`	`VK_FORMAT_R32G32B32A32_SFLOAT`
`R64ui`	`VK_FORMAT_R64_UINT`
`R64i`	`VK_FORMAT_R64_SINT`
`R11fG11fB10f`	`VK_FORMAT_B10G11R11_UFLOAT_PACK32`