Support SPIRV Capability declaration on intrinsic functions. (#3150)

* Spirv Capability lookup.

* Fix.

---------

Co-authored-by: Yong He <yhe@nvidia.com>

9 files changed, 346 insertions, 39 deletions

diff --git a/source/slang/slang-ast-modifier.h b/source/slang/slang-ast-modifier.h
index 7b772e645..f5809ff4b 100644
--- a/source/slang/slang-ast-modifier.h
+++ b/source/slang/slang-ast-modifier.h
@@ -132,6 +132,14 @@ class RequiredSPIRVVersionModifier : public Modifier
 };
 
 // A modifier to tag something as an intrinsic that requires
+// a certain SPIRV capability to be enabled when used.
+class RequiredSPIRVCapabilityModifier : public Modifier
+{
+    SLANG_AST_CLASS(RequiredSPIRVCapabilityModifier)
+    int32_t capability;
+};
+
+// A modifier to tag something as an intrinsic that requires
 // a certain CUDA SM version to be enabled when used. Specified as "major.minor"
 class RequiredCUDASMVersionModifier : public Modifier 
 {
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index 8f2413c51..0243543e9 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -233,8 +233,8 @@ DIAGNOSTIC(20008, Error, invalidOperator, "invalid operator '$0'.")
 DIAGNOSTIC(20011, Error, unexpectedColon, "unexpected ':'.")
 DIAGNOSTIC(20012, Error, invalidSPIRVVersion, "Expecting SPIR-V version as either 'major.minor', or quoted if has patch (eg for SPIR-V 1.2, '1.2' or \"1.2\"')")
 DIAGNOSTIC(20013, Error, invalidCUDASMVersion, "Expecting CUDA SM version as either 'major.minor', or quoted if has patch (eg for '7.0' or \"7.0\"')")
-
 DIAGNOSTIC(20014, Error, classIsReservedKeyword, "'class' is a reserved keyword in this context; use 'struct' instead.")
+DIAGNOSTIC(20015, Error, unknownSPIRVCapability, "unknown SPIR-V capability '$0'.")
 
 DIAGNOSTIC(20101, Warning, unintendedEmptyStatement, "potentially unintended empty statement at this location; use {} instead.")
 
diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp
index 0878b3494..29114424d 100644
--- a/source/slang/slang-emit-spirv.cpp
+++ b/source/slang/slang-emit-spirv.cpp
@@ -3805,27 +3805,15 @@ struct SPIRVEmitContext
 
     void handleRequiredCapabilitiesImpl(IRInst* inst)
     {
-        // TODO: declare required SPV capabilities.
-
         for (auto decoration : inst->getDecorations())
         {
             switch (decoration->getOp())
             {
             default:
                 break;
-
-            case kIROp_RequireGLSLExtensionDecoration:
-                {
-                    break;
-                }
-            case kIROp_RequireGLSLVersionDecoration:
-                {
-                    break;
-                }
-            case kIROp_RequireSPIRVVersionDecoration:
-                {
-                    break;
-                }
+            case kIROp_RequireSPIRVCapabilityDecoration:
+                requireSPIRVCapability((SpvCapability)getIntVal(decoration->getOperand(0)));
+                break;
             }
         }
     }
diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h
index c1b021181..d264dfd06 100644
--- a/source/slang/slang-ir-inst-defs.h
+++ b/source/slang/slang-ir-inst-defs.h
@@ -676,6 +676,7 @@ INST(HighLevelDeclDecoration,               highLevelDecl,          1, 0)
     INST(VulkanHitObjectAttributesDecoration, vulkanHitObjectAttributes, 0, 0)
 
     INST(RequireSPIRVVersionDecoration,     requireSPIRVVersion,    1, 0)
+    INST(RequireSPIRVCapabilityDecoration,  requireSPIRVCapability, 1, 0)
     INST(RequireGLSLVersionDecoration,      requireGLSLVersion,     1, 0)
     INST(RequireGLSLExtensionDecoration,    requireGLSLExtension,   1, 0)
     INST(RequireCUDASMVersionDecoration,    requireCUDASMVersion,   1, 0)
diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h
index 0b2cc790d..5639d90dd 100644
--- a/source/slang/slang-ir-insts.h
+++ b/source/slang/slang-ir-insts.h
@@ -4076,6 +4076,11 @@ public:
         addDecoration(value, kIROp_RequireSPIRVVersionDecoration, getIntValue(getBasicType(BaseType::UInt64), intValue));
     }
 
+    void addRequireSPIRVCapabilityDecoration(IRInst* value, int32_t capabilityName)
+    {
+        addDecoration(value, kIROp_RequireSPIRVCapabilityDecoration, getIntValue(getIntType(), IRIntegerValue(capabilityName)));
+    }
+
     void addRequireCUDASMVersionDecoration(IRInst* value, const SemanticVersion& version)
     {
         SemanticVersion::IntegerType intValue = version.toInteger();
diff --git a/source/slang/slang-lookup-spirv.h b/source/slang/slang-lookup-spirv.h
index bc8dfb5a4..47cd5b277 100644
--- a/source/slang/slang-lookup-spirv.h
+++ b/source/slang/slang-lookup-spirv.h
@@ -7,4 +7,5 @@ namespace Slang
 {
 bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value);
 bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value);
+bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value);
 }
diff --git a/source/slang/slang-lookup-spvcapability.cpp b/source/slang/slang-lookup-spvcapability.cpp
new file mode 100644
index 000000000..5e7e18037
--- /dev/null
+++ b/source/slang/slang-lookup-spvcapability.cpp
@@ -0,0 +1,303 @@
+// Hash function for SpvCapability
+//
+// This file was thoughtfully generated by a machine,
+// don't even think about modifying it yourself!
+//
+
+#include "../core/slang-common.h"
+#include "../core/slang-string.h"
+#include "spirv/unified1/spirv.h"
+
+
+namespace Slang
+{
+
+static const unsigned tableSalt[238] ={
+    4, 1, 0, 0, 0, 5, 1, 1, 1, 1, 0, 3, 4, 1, 0, 0,
+    1, 6, 0, 1, 4, 0, 0, 1, 5, 0, 0, 1, 2, 0, 2, 2,
+    0, 0, 0, 2, 3, 3, 7, 3, 0, 4, 0, 4, 5, 3, 1, 2,
+    0, 6, 1, 4, 2, 1, 0, 1, 7, 3, 0, 0, 0, 1, 2, 2,
+    0, 4, 1, 1, 5, 2, 0, 0, 1, 6, 4, 1, 0, 5, 1, 0,
+    7, 1, 1, 2, 2, 1, 1, 0, 4, 0, 0, 2, 0, 4, 10, 0,
+    0, 0, 1, 0, 4, 3, 1, 0, 0, 1, 4, 6, 2, 5, 1, 1,
+    0, 3, 1, 4, 3, 1, 0, 2, 1, 0, 0, 0, 1, 1, 3, 3,
+    9, 0, 0, 0, 0, 2, 5, 0, 0, 8, 0, 12, 0, 0, 0, 5,
+    5, 4, 2, 1, 6, 1, 0, 0, 20, 3, 7, 1, 13, 0, 4, 14,
+    5, 2, 0, 5, 0, 8, 3, 0, 1, 2, 1, 0, 3, 0, 18, 5,
+    8, 0, 10, 0, 14, 0, 3, 0, 0, 0, 13, 0, 0, 2, 24, 6,
+    4, 0, 3, 0, 1, 0, 0, 7, 4, 0, 0, 5, 2, 0, 35, 6,
+    0, 0, 2, 5, 6, 34, 32, 29, 0, 10, 7, 0, 90, 0, 3, 36,
+    73, 39, 193, 0, 1, 1, 0, 83, 8, 0, 0, 712, 2, 0
+};
+
+struct KV
+{
+    const char* name;
+    SpvCapability value;
+};
+
+static const KV words[238] =
+{
+    {"ShaderViewportIndex", SpvCapabilityShaderViewportIndex},
+    {"FragmentBarycentricNV", SpvCapabilityFragmentBarycentricNV},
+    {"StorageImageWriteWithoutFormat", SpvCapabilityStorageImageWriteWithoutFormat},
+    {"RayTracingMotionBlurNV", SpvCapabilityRayTracingMotionBlurNV},
+    {"StorageImageArrayNonUniformIndexingEXT", SpvCapabilityStorageImageArrayNonUniformIndexingEXT},
+    {"UnstructuredLoopControlsINTEL", SpvCapabilityUnstructuredLoopControlsINTEL},
+    {"BlockingPipesINTEL", SpvCapabilityBlockingPipesINTEL},
+    {"Image1D", SpvCapabilityImage1D},
+    {"LiteralSampler", SpvCapabilityLiteralSampler},
+    {"SubgroupAvcMotionEstimationINTEL", SpvCapabilitySubgroupAvcMotionEstimationINTEL},
+    {"GroupNonUniformQuad", SpvCapabilityGroupNonUniformQuad},
+    {"FunctionPointersINTEL", SpvCapabilityFunctionPointersINTEL},
+    {"UniformTexelBufferArrayNonUniformIndexing", SpvCapabilityUniformTexelBufferArrayNonUniformIndexing},
+    {"RayCullMaskKHR", SpvCapabilityRayCullMaskKHR},
+    {"CoreBuiltinsARM", SpvCapabilityCoreBuiltinsARM},
+    {"USMStorageClassesINTEL", SpvCapabilityUSMStorageClassesINTEL},
+    {"ArbitraryPrecisionIntegersINTEL", SpvCapabilityArbitraryPrecisionIntegersINTEL},
+    {"IOPipesINTEL", SpvCapabilityIOPipesINTEL},
+    {"MultiView", SpvCapabilityMultiView},
+    {"RayTracingNV", SpvCapabilityRayTracingNV},
+    {"OptNoneINTEL", SpvCapabilityOptNoneINTEL},
+    {"SubgroupBufferBlockIOINTEL", SpvCapabilitySubgroupBufferBlockIOINTEL},
+    {"TessellationPointSize", SpvCapabilityTessellationPointSize},
+    {"Vector16", SpvCapabilityVector16},
+    {"RayQueryPositionFetchKHR", SpvCapabilityRayQueryPositionFetchKHR},
+    {"GenericPointer", SpvCapabilityGenericPointer},
+    {"UniformBufferArrayDynamicIndexing", SpvCapabilityUniformBufferArrayDynamicIndexing},
+    {"ImageMSArray", SpvCapabilityImageMSArray},
+    {"AtomicStorageOps", SpvCapabilityAtomicStorageOps},
+    {"DotProductInputAll", SpvCapabilityDotProductInputAll},
+    {"InputAttachmentArrayNonUniformIndexing", SpvCapabilityInputAttachmentArrayNonUniformIndexing},
+    {"AsmINTEL", SpvCapabilityAsmINTEL},
+    {"DotProductInput4x8BitPackedKHR", SpvCapabilityDotProductInput4x8BitPackedKHR},
+    {"StorageTexelBufferArrayNonUniformIndexing", SpvCapabilityStorageTexelBufferArrayNonUniformIndexing},
+    {"FPGADSPControlINTEL", SpvCapabilityFPGADSPControlINTEL},
+    {"DotProduct", SpvCapabilityDotProduct},
+    {"StorageImageMultisample", SpvCapabilityStorageImageMultisample},
+    {"StorageTexelBufferArrayDynamicIndexingEXT", SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT},
+    {"SampledImageArrayDynamicIndexing", SpvCapabilitySampledImageArrayDynamicIndexing},
+    {"VulkanMemoryModelDeviceScopeKHR", SpvCapabilityVulkanMemoryModelDeviceScopeKHR},
+    {"ShadingRateNV", SpvCapabilityShadingRateNV},
+    {"DotProductInput4x8BitKHR", SpvCapabilityDotProductInput4x8BitKHR},
+    {"ShaderNonUniformEXT", SpvCapabilityShaderNonUniformEXT},
+    {"ShaderStereoViewNV", SpvCapabilityShaderStereoViewNV},
+    {"UniformAndStorageBuffer16BitAccess", SpvCapabilityUniformAndStorageBuffer16BitAccess},
+    {"RoundingModeRTE", SpvCapabilityRoundingModeRTE},
+    {"TileImageColorReadAccessEXT", SpvCapabilityTileImageColorReadAccessEXT},
+    {"TileImageDepthReadAccessEXT", SpvCapabilityTileImageDepthReadAccessEXT},
+    {"PerViewAttributesNV", SpvCapabilityPerViewAttributesNV},
+    {"DemoteToHelperInvocationEXT", SpvCapabilityDemoteToHelperInvocationEXT},
+    {"AtomicFloat16MinMaxEXT", SpvCapabilityAtomicFloat16MinMaxEXT},
+    {"GroupNonUniformArithmetic", SpvCapabilityGroupNonUniformArithmetic},
+    {"ShaderLayer", SpvCapabilityShaderLayer},
+    {"VariableLengthArrayINTEL", SpvCapabilityVariableLengthArrayINTEL},
+    {"ImageReadWriteLodAMD", SpvCapabilityImageReadWriteLodAMD},
+    {"ImageCubeArray", SpvCapabilityImageCubeArray},
+    {"Float16Buffer", SpvCapabilityFloat16Buffer},
+    {"VulkanMemoryModelDeviceScope", SpvCapabilityVulkanMemoryModelDeviceScope},
+    {"ImageRect", SpvCapabilityImageRect},
+    {"UniformDecoration", SpvCapabilityUniformDecoration},
+    {"AtomicFloat64AddEXT", SpvCapabilityAtomicFloat64AddEXT},
+    {"VectorComputeINTEL", SpvCapabilityVectorComputeINTEL},
+    {"Float16", SpvCapabilityFloat16},
+    {"DeviceEnqueue", SpvCapabilityDeviceEnqueue},
+    {"MinLod", SpvCapabilityMinLod},
+    {"Float16ImageAMD", SpvCapabilityFloat16ImageAMD},
+    {"SubgroupImageMediaBlockIOINTEL", SpvCapabilitySubgroupImageMediaBlockIOINTEL},
+    {"SparseResidency", SpvCapabilitySparseResidency},
+    {"UniformTexelBufferArrayDynamicIndexing", SpvCapabilityUniformTexelBufferArrayDynamicIndexing},
+    {"Pipes", SpvCapabilityPipes},
+    {"InputAttachment", SpvCapabilityInputAttachment},
+    {"FPGAMemoryAttributesINTEL", SpvCapabilityFPGAMemoryAttributesINTEL},
+    {"RuntimeDescriptorArrayEXT", SpvCapabilityRuntimeDescriptorArrayEXT},
+    {"GeometryPointSize", SpvCapabilityGeometryPointSize},
+    {"Shader", SpvCapabilityShader},
+    {"IntegerFunctions2INTEL", SpvCapabilityIntegerFunctions2INTEL},
+    {"StorageImageArrayDynamicIndexing", SpvCapabilityStorageImageArrayDynamicIndexing},
+    {"Int64Atomics", SpvCapabilityInt64Atomics},
+    {"ImageFootprintNV", SpvCapabilityImageFootprintNV},
+    {"IndirectReferencesINTEL", SpvCapabilityIndirectReferencesINTEL},
+    {"ShaderSMBuiltinsNV", SpvCapabilityShaderSMBuiltinsNV},
+    {"StoragePushConstant8", SpvCapabilityStoragePushConstant8},
+    {"FPGAKernelAttributesINTEL", SpvCapabilityFPGAKernelAttributesINTEL},
+    {"ImageBuffer", SpvCapabilityImageBuffer},
+    {"ImageReadWrite", SpvCapabilityImageReadWrite},
+    {"AtomicStorage", SpvCapabilityAtomicStorage},
+    {"SignedZeroInfNanPreserve", SpvCapabilitySignedZeroInfNanPreserve},
+    {"Groups", SpvCapabilityGroups},
+    {"DebugInfoModuleINTEL", SpvCapabilityDebugInfoModuleINTEL},
+    {"GroupUniformArithmeticKHR", SpvCapabilityGroupUniformArithmeticKHR},
+    {"Int16", SpvCapabilityInt16},
+    {"DenormFlushToZero", SpvCapabilityDenormFlushToZero},
+    {"TransformFeedback", SpvCapabilityTransformFeedback},
+    {"StencilExportEXT", SpvCapabilityStencilExportEXT},
+    {"InputAttachmentArrayNonUniformIndexingEXT", SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT},
+    {"DotProductKHR", SpvCapabilityDotProductKHR},
+    {"FPGABufferLocationINTEL", SpvCapabilityFPGABufferLocationINTEL},
+    {"DotProductInput4x8Bit", SpvCapabilityDotProductInput4x8Bit},
+    {"ShaderInvocationReorderNV", SpvCapabilityShaderInvocationReorderNV},
+    {"ImageMipmap", SpvCapabilityImageMipmap},
+    {"FunctionFloatControlINTEL", SpvCapabilityFunctionFloatControlINTEL},
+    {"AtomicFloat16AddEXT", SpvCapabilityAtomicFloat16AddEXT},
+    {"RayQueryProvisionalKHR", SpvCapabilityRayQueryProvisionalKHR},
+    {"GroupNonUniformVote", SpvCapabilityGroupNonUniformVote},
+    {"StorageTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT},
+    {"ArbitraryPrecisionFloatingPointINTEL", SpvCapabilityArbitraryPrecisionFloatingPointINTEL},
+    {"StorageInputOutput16", SpvCapabilityStorageInputOutput16},
+    {"SampledImageArrayNonUniformIndexing", SpvCapabilitySampledImageArrayNonUniformIndexing},
+    {"SubgroupVoteKHR", SpvCapabilitySubgroupVoteKHR},
+    {"Tessellation", SpvCapabilityTessellation},
+    {"Geometry", SpvCapabilityGeometry},
+    {"SubgroupAvcMotionEstimationChromaINTEL", SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL},
+    {"StorageImageReadWithoutFormat", SpvCapabilityStorageImageReadWithoutFormat},
+    {"Int64", SpvCapabilityInt64},
+    {"DemoteToHelperInvocation", SpvCapabilityDemoteToHelperInvocation},
+    {"MeshShadingEXT", SpvCapabilityMeshShadingEXT},
+    {"UniformAndStorageBuffer8BitAccess", SpvCapabilityUniformAndStorageBuffer8BitAccess},
+    {"RayTracingProvisionalKHR", SpvCapabilityRayTracingProvisionalKHR},
+    {"UniformBufferArrayNonUniformIndexing", SpvCapabilityUniformBufferArrayNonUniformIndexing},
+    {"VulkanMemoryModelKHR", SpvCapabilityVulkanMemoryModelKHR},
+    {"SubgroupShuffleINTEL", SpvCapabilitySubgroupShuffleINTEL},
+    {"SubgroupDispatch", SpvCapabilitySubgroupDispatch},
+    {"MemoryAccessAliasingINTEL", SpvCapabilityMemoryAccessAliasingINTEL},
+    {"StorageBuffer16BitAccess", SpvCapabilityStorageBuffer16BitAccess},
+    {"RuntimeDescriptorArray", SpvCapabilityRuntimeDescriptorArray},
+    {"StorageImageArrayNonUniformIndexing", SpvCapabilityStorageImageArrayNonUniformIndexing},
+    {"Kernel", SpvCapabilityKernel},
+    {"BitInstructions", SpvCapabilityBitInstructions},
+    {"WorkgroupMemoryExplicitLayout8BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR},
+    {"Sampled1D", SpvCapabilitySampled1D},
+    {"StorageTexelBufferArrayDynamicIndexing", SpvCapabilityStorageTexelBufferArrayDynamicIndexing},
+    {"ImageQuery", SpvCapabilityImageQuery},
+    {"MultiViewport", SpvCapabilityMultiViewport},
+    {"UniformTexelBufferArrayDynamicIndexingEXT", SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT},
+    {"StorageUniform16", SpvCapabilityStorageUniform16},
+    {"SubgroupImageBlockIOINTEL", SpvCapabilitySubgroupImageBlockIOINTEL},
+    {"WorkgroupMemoryExplicitLayout16BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR},
+    {"KernelAttributesINTEL", SpvCapabilityKernelAttributesINTEL},
+    {"PipeStorage", SpvCapabilityPipeStorage},
+    {"ShaderViewportMaskNV", SpvCapabilityShaderViewportMaskNV},
+    {"Matrix", SpvCapabilityMatrix},
+    {"GroupNonUniformShuffleRelative", SpvCapabilityGroupNonUniformShuffleRelative},
+    {"RuntimeAlignedAttributeINTEL", SpvCapabilityRuntimeAlignedAttributeINTEL},
+    {"CullDistance", SpvCapabilityCullDistance},
+    {"Int8", SpvCapabilityInt8},
+    {"RayTraversalPrimitiveCullingKHR", SpvCapabilityRayTraversalPrimitiveCullingKHR},
+    {"SampleMaskPostDepthCoverage", SpvCapabilitySampleMaskPostDepthCoverage},
+    {"GroupNonUniformShuffle", SpvCapabilityGroupNonUniformShuffle},
+    {"ImageBasic", SpvCapabilityImageBasic},
+    {"WorkgroupMemoryExplicitLayoutKHR", SpvCapabilityWorkgroupMemoryExplicitLayoutKHR},
+    {"FPGAClusterAttributesINTEL", SpvCapabilityFPGAClusterAttributesINTEL},
+    {"PhysicalStorageBufferAddresses", SpvCapabilityPhysicalStorageBufferAddresses},
+    {"UniformTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT},
+    {"StorageBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageBufferArrayNonUniformIndexingEXT},
+    {"FragmentShaderSampleInterlockEXT", SpvCapabilityFragmentShaderSampleInterlockEXT},
+    {"SampledImageArrayNonUniformIndexingEXT", SpvCapabilitySampledImageArrayNonUniformIndexingEXT},
+    {"InterpolationFunction", SpvCapabilityInterpolationFunction},
+    {"AtomicFloat32AddEXT", SpvCapabilityAtomicFloat32AddEXT},
+    {"Int64ImageEXT", SpvCapabilityInt64ImageEXT},
+    {"SubgroupBallotKHR", SpvCapabilitySubgroupBallotKHR},
+    {"RoundToInfinityINTEL", SpvCapabilityRoundToInfinityINTEL},
+    {"DrawParameters", SpvCapabilityDrawParameters},
+    {"VariablePointers", SpvCapabilityVariablePointers},
+    {"FragmentShaderShadingRateInterlockEXT", SpvCapabilityFragmentShaderShadingRateInterlockEXT},
+    {"NamedBarrier", SpvCapabilityNamedBarrier},
+    {"ComputeDerivativeGroupQuadsNV", SpvCapabilityComputeDerivativeGroupQuadsNV},
+    {"SampledCubeArray", SpvCapabilitySampledCubeArray},
+    {"Addresses", SpvCapabilityAddresses},
+    {"LongConstantCompositeINTEL", SpvCapabilityLongConstantCompositeINTEL},
+    {"ArbitraryPrecisionFixedPointINTEL", SpvCapabilityArbitraryPrecisionFixedPointINTEL},
+    {"RayTracingKHR", SpvCapabilityRayTracingKHR},
+    {"RayQueryKHR", SpvCapabilityRayQueryKHR},
+    {"FragmentDensityEXT", SpvCapabilityFragmentDensityEXT},
+    {"InputAttachmentArrayDynamicIndexingEXT", SpvCapabilityInputAttachmentArrayDynamicIndexingEXT},
+    {"FPGAInvocationPipeliningAttributesINTEL", SpvCapabilityFPGAInvocationPipeliningAttributesINTEL},
+    {"ShaderViewportIndexLayerEXT", SpvCapabilityShaderViewportIndexLayerEXT},
+    {"PhysicalStorageBufferAddressesEXT", SpvCapabilityPhysicalStorageBufferAddressesEXT},
+    {"SplitBarrierINTEL", SpvCapabilitySplitBarrierINTEL},
+    {"ImageGatherExtended", SpvCapabilityImageGatherExtended},
+    {"CooperativeMatrixNV", SpvCapabilityCooperativeMatrixNV},
+    {"FloatingPointModeINTEL", SpvCapabilityFloatingPointModeINTEL},
+    {"SubgroupAvcMotionEstimationIntraINTEL", SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL},
+    {"DotProductInputAllKHR", SpvCapabilityDotProductInputAllKHR},
+    {"AtomicFloat64MinMaxEXT", SpvCapabilityAtomicFloat64MinMaxEXT},
+    {"DeviceGroup", SpvCapabilityDeviceGroup},
+    {"RayTracingOpacityMicromapEXT", SpvCapabilityRayTracingOpacityMicromapEXT},
+    {"GroupNonUniform", SpvCapabilityGroupNonUniform},
+    {"BindlessTextureNV", SpvCapabilityBindlessTextureNV},
+    {"GeometryShaderPassthroughNV", SpvCapabilityGeometryShaderPassthroughNV},
+    {"FragmentFullyCoveredEXT", SpvCapabilityFragmentFullyCoveredEXT},
+    {"ShaderNonUniform", SpvCapabilityShaderNonUniform},
+    {"DotProductInput4x8BitPacked", SpvCapabilityDotProductInput4x8BitPacked},
+    {"ShaderViewportIndexLayerNV", SpvCapabilityShaderViewportIndexLayerNV},
+    {"RayTracingPositionFetchKHR", SpvCapabilityRayTracingPositionFetchKHR},
+    {"VectorAnyINTEL", SpvCapabilityVectorAnyINTEL},
+    {"FPFastMathModeINTEL", SpvCapabilityFPFastMathModeINTEL},
+    {"AtomicFloat32MinMaxEXT", SpvCapabilityAtomicFloat32MinMaxEXT},
+    {"SampleMaskOverrideCoverageNV", SpvCapabilitySampleMaskOverrideCoverageNV},
+    {"FragmentShadingRateKHR", SpvCapabilityFragmentShadingRateKHR},
+    {"GroupNonUniformPartitionedNV", SpvCapabilityGroupNonUniformPartitionedNV},
+    {"StorageBufferArrayNonUniformIndexing", SpvCapabilityStorageBufferArrayNonUniformIndexing},
+    {"ExpectAssumeKHR", SpvCapabilityExpectAssumeKHR},
+    {"FPGAMemoryAccessesINTEL", SpvCapabilityFPGAMemoryAccessesINTEL},
+    {"StorageImageExtendedFormats", SpvCapabilityStorageImageExtendedFormats},
+    {"FPGAArgumentInterfacesINTEL", SpvCapabilityFPGAArgumentInterfacesINTEL},
+    {"SampleRateShading", SpvCapabilitySampleRateShading},
+    {"VariablePointersStorageBuffer", SpvCapabilityVariablePointersStorageBuffer},
+    {"StoragePushConstant16", SpvCapabilityStoragePushConstant16},
+    {"GeometryStreams", SpvCapabilityGeometryStreams},
+    {"FPGARegINTEL", SpvCapabilityFPGARegINTEL},
+    {"LoopFuseINTEL", SpvCapabilityLoopFuseINTEL},
+    {"Linkage", SpvCapabilityLinkage},
+    {"ComputeDerivativeGroupLinearNV", SpvCapabilityComputeDerivativeGroupLinearNV},
+    {"DerivativeControl", SpvCapabilityDerivativeControl},
+    {"StorageBufferArrayDynamicIndexing", SpvCapabilityStorageBufferArrayDynamicIndexing},
+    {"SampledBuffer", SpvCapabilitySampledBuffer},
+    {"StorageBuffer8BitAccess", SpvCapabilityStorageBuffer8BitAccess},
+    {"FragmentBarycentricKHR", SpvCapabilityFragmentBarycentricKHR},
+    {"GroupNonUniformClustered", SpvCapabilityGroupNonUniformClustered},
+    {"MeshShadingNV", SpvCapabilityMeshShadingNV},
+    {"RoundingModeRTZ", SpvCapabilityRoundingModeRTZ},
+    {"StorageUniformBufferBlock16", SpvCapabilityStorageUniformBufferBlock16},
+    {"DenormPreserve", SpvCapabilityDenormPreserve},
+    {"FragmentShaderPixelInterlockEXT", SpvCapabilityFragmentShaderPixelInterlockEXT},
+    {"Max", SpvCapabilityMax},
+    {"GroupNonUniformBallot", SpvCapabilityGroupNonUniformBallot},
+    {"InputAttachmentArrayDynamicIndexing", SpvCapabilityInputAttachmentArrayDynamicIndexing},
+    {"GroupNonUniformRotateKHR", SpvCapabilityGroupNonUniformRotateKHR},
+    {"ClipDistance", SpvCapabilityClipDistance},
+    {"ShaderClockKHR", SpvCapabilityShaderClockKHR},
+    {"FragmentMaskAMD", SpvCapabilityFragmentMaskAMD},
+    {"FPGALoopControlsINTEL", SpvCapabilityFPGALoopControlsINTEL},
+    {"Float64", SpvCapabilityFloat64},
+    {"TileImageStencilReadAccessEXT", SpvCapabilityTileImageStencilReadAccessEXT},
+    {"UniformBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformBufferArrayNonUniformIndexingEXT},
+    {"ImageGatherBiasLodAMD", SpvCapabilityImageGatherBiasLodAMD},
+    {"SampledRect", SpvCapabilitySampledRect},
+    {"VulkanMemoryModel", SpvCapabilityVulkanMemoryModel},
+};
+
+static UInt32 hash(const UnownedStringSlice& str, UInt32 salt)
+{
+    UInt64 h = salt;
+    for(const char c : str)
+        h = ((h * 0x00000100000001B3) ^ c);
+    return h % (sizeof(tableSalt)/sizeof(tableSalt[0]));
+}
+
+bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value)
+{
+    const auto i = hash(str, tableSalt[hash(str, 0)]);
+    if(str == words[i].name)
+    {
+        value = words[i].value;
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+}
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index 0d7e27bc4..497981a94 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -8736,29 +8736,6 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
 
         addCatchAllIntrinsicDecorationIfNeeded(irFunc, decl);
 
-        // If this declaration requires certain GLSL extension (or a particular GLSL version)
-        // for it to be usable, then declare that here.
-        //
-        // TODO: We should wrap this an `SpecializedForTargetModifier` together into a single
-        // case for enumerating the "capabilities" that a declaration requires.
-        //
-        for (auto extensionMod : decl->getModifiersOfType<RequiredGLSLExtensionModifier>())
-        {
-            getBuilder()->addRequireGLSLExtensionDecoration(irFunc, extensionMod->extensionNameToken.getContent());
-        }
-        for (auto versionMod : decl->getModifiersOfType<RequiredGLSLVersionModifier>())
-        {
-            getBuilder()->addRequireGLSLVersionDecoration(irFunc, Int(getIntegerLiteralValue(versionMod->versionNumberToken)));
-        }
-        for (auto versionMod : decl->getModifiersOfType<RequiredSPIRVVersionModifier>())
-        {
-            getBuilder()->addRequireSPIRVVersionDecoration(irFunc, versionMod->version);
-        }
-        for (auto versionMod : decl->getModifiersOfType<RequiredCUDASMVersionModifier>())
-        {
-            getBuilder()->addRequireCUDASMVersionDecoration(irFunc, versionMod->version);
-        }
-
         // Register the value now, to avoid any possible infinite recursion when lowering ForwardDerivativeAttribute
         context->setGlobalValue(decl, LoweredValInfo::simple(findOuterMostGeneric(irFunc)));
 
@@ -8934,6 +8911,16 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             {
                 getBuilder()->addDecoration(irFunc, kIROp_PreferRecomputeDecoration);
             }
+            else if (auto extensionMod = as<RequiredGLSLExtensionModifier>(modifier))
+                getBuilder()->addRequireGLSLExtensionDecoration(irFunc, extensionMod->extensionNameToken.getContent());
+            else if (auto versionMod = as<RequiredGLSLVersionModifier>(modifier))
+                getBuilder()->addRequireGLSLVersionDecoration(irFunc, Int(getIntegerLiteralValue(versionMod->versionNumberToken)));
+            else if (auto spvVersion = as<RequiredSPIRVVersionModifier>(modifier))
+                getBuilder()->addRequireSPIRVVersionDecoration(irFunc, spvVersion->version);
+            else if (auto capMod = as<RequiredSPIRVCapabilityModifier>(modifier))
+                getBuilder()->addRequireSPIRVCapabilityDecoration(irFunc, capMod->capability);
+            else if (auto cudasmVersion = as<RequiredCUDASMVersionModifier>(modifier))
+                getBuilder()->addRequireCUDASMVersionDecoration(irFunc, cudasmVersion->version);
         }
 
         if (!isInline)
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
index 98c227159..fabf1ffb4 100644
--- a/source/slang/slang-parser.cpp
+++ b/source/slang/slang-parser.cpp
@@ -6,6 +6,7 @@
 #include "slang-compiler.h"
 #include "slang-lookup.h"
 #include "slang-visitor.h"
+#include "slang-lookup-spirv.h"
 
 #include "../core/slang-semantic-version.h"
 
@@ -6531,6 +6532,18 @@ namespace Slang
         return nullptr;
     }
 
+    static NodeBase* parseSPIRVCapabilityModifier(Parser* parser, void*)
+    {
+        Token token;
+        token = parser->ReadToken();
+        auto modifier = parser->astBuilder->create<RequiredSPIRVCapabilityModifier>();
+        SpvCapability cap;
+        if (!lookupSpvCapability(token.getContent(), cap))
+            parser->sink->diagnose(token, Diagnostics::unknownSPIRVCapability, token);
+        modifier->capability = (int32_t)cap;
+        return modifier;
+    }
+
     static NodeBase* parseCUDASMVersionModifier(Parser* parser, void* /*userData*/)
     {
         Token token;
@@ -6889,6 +6902,7 @@ namespace Slang
         _makeParseModifier("__glsl_extension",      parseGLSLExtensionModifier),
         _makeParseModifier("__glsl_version",        parseGLSLVersionModifier),
         _makeParseModifier("__spirv_version",       parseSPIRVVersionModifier),
+        _makeParseModifier("__spirv_capability",    parseSPIRVCapabilityModifier),
         _makeParseModifier("__cuda_sm_version",     parseCUDASMVersionModifier),
 
         _makeParseModifier("__builtin_type",        parseBuiltinTypeModifier),