SPIR-V extensions and capabilities support - per-device infrastructure

TableGen backend extended to emit a standalone C++ header exposing
per-device SPIR-V extension and capability support (query functions +
data).

Neo ↔ IGC interface updated: now passes a YAML blob enumerating
supported SPIR-V extensions/capabilities per device instead of a
single global set.

Added (disabled-by-default) validation in dllInterfaceCompute to
reject SPIR-V modules containing any unsupported extension on the
target device.

Markdown documentation generation enhanced: now lists platform
support for each extension and capability.

Current .td extension/capability lists and platform support tags are
provisional/incomplete; validation remains off until lists are
finalized.

Author: aratajew

IGC/AdaptorOCL/CMakeLists.txt

@@ -128,7 +128,7 @@ set_target_properties("${IGC_BUILD__PROJ__AdaptorOCL}" PROPERTIES FOLDER "Librar
 
 add_dependencies("${IGC_BUILD__PROJ__AdaptorOCL}" "${IGC_BUILD__PROJ__GenISAIntrinsics}")
 if(USE_SPIRV_EXTENSIONS_YAML_GENERATOR)
-  add_dependencies(${IGC_BUILD__PROJ__AdaptorOCL} IGCCSPIRVExtensionsYaml)
+  add_dependencies(${IGC_BUILD__PROJ__AdaptorOCL} SPIRVExtensionsSupportGen)
 endif()
 set_property(TARGET "${IGC_BUILD__PROJ__AdaptorOCL}" PROPERTY PROJECT_LABEL "${IGC_BUILD__PROJ_LABEL__AdaptorOCL}")
 

IGC/AdaptorOCL/Utils/YamlAndDocsTblgen/CMakeLists.txt renamed to IGC/AdaptorOCL/Utils/IGCCSPIRVSupportTblGen/CMakeLists.txt

@@ -8,20 +8,20 @@
 
 include(TableGen)
 
-add_tablegen(igcc-yaml-docs-tblgen IGCC_YAML_DOCS_TBLGEN
-    IGCCOptionsAndCapabilitiesEmitter.cpp
+add_tablegen(igcc-spirv-support-tblgen IGCC_YAML_DOCS_TBLGEN
+    IGCCSPIRVSupportTblGen.cpp
 )
 
 set(LLVM_LINK_COMPONENTS
   Support
   TableGen
 )
 
-llvm_update_compile_flags(igcc-yaml-docs-tblgen)
+llvm_update_compile_flags(igcc-spirv-support-tblgen)
 
 # Always link static TableGen explicitly — never rely on libLLVM.so here
 # TableGen is never part of libLLVM.so (ref: llvm-project/llvm/tools/llvm-shlib/CMakeLists.txt)
-target_link_libraries(igcc-yaml-docs-tblgen PRIVATE
+target_link_libraries(igcc-spirv-support-tblgen PRIVATE
   LLVMSupport
   LLVMTableGen
 )

IGC/AdaptorOCL/Utils/IGCCSPIRVSupportTblGen/IGCCSPIRVPlatformSupport.h

@@ -0,0 +1,145 @@
+/*========================== begin_copyright_notice ============================
+
+Copyright (C) 2025 Intel Corporation
+
+SPDX-License-Identifier: MIT
+
+============================= end_copyright_notice ===========================*/
+
+/*==============================================================================
+ * Platform support types and helpers for IGCCSPIRVSupportTblGen
+ *============================================================================*/
+#pragma once
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/Error.h"
+
+namespace IGCCSPIRVPlatformSupport {
+// Selective LLVM symbols imported to avoid polluting including translation units.
+using llvm::PrintFatalError;
+using llvm::Record;
+using llvm::RecordKeeper;
+using llvm::SmallVector;
+using llvm::StringRef;
+
+// Classification of platform support descriptors.
+enum class PlatformSupportKind {
+  All,
+  NotSupported,
+  InheritFromExtension,
+  CoreChildOf,
+  ExactPlatform,
+  InGroup,
+  AnyOf,
+  Unknown
+};
+
+// Capability entry for an extension.
+struct CapabilityEntry {
+  StringRef Name;
+  const Record *Root;              // original capability record
+  const Record *EffectivePlatform; // resolved support (extension or capability)
+};
+
+struct ExtensionEntry {
+  StringRef Name;
+  StringRef SpecURL;
+  const Record *Root;                 // original extension record
+  const Record *Platforms;            // extension support record (raw)
+  bool IsInheritFromCapabilitiesMode; // true if extSupport == InheritFromCapabilities (aggregated capability mode)
+  SmallVector<CapabilityEntry, 8> Capabilities;
+};
+
+// Container alias for list of extensions
+using SPIRVExtensions = SmallVector<ExtensionEntry, 64>;
+
+inline PlatformSupportKind classifyPlatformSupport(const Record *R) {
+  StringRef Name = R->getName();
+  if (Name == "AllPlatformSupport")
+    return PlatformSupportKind::All;
+  if (Name == "NotSupported")
+    return PlatformSupportKind::NotSupported;
+  if (Name == "InheritFromExtension")
+    return PlatformSupportKind::InheritFromExtension;
+  if (R->isSubClassOf("isCoreChildOf"))
+    return PlatformSupportKind::CoreChildOf;
+  if (R->isSubClassOf("ExactPlatform"))
+    return PlatformSupportKind::ExactPlatform;
+  if (R->isSubClassOf("isInGroup"))
+    return PlatformSupportKind::InGroup;
+  if (R->isSubClassOf("AnyOf"))
+    return PlatformSupportKind::AnyOf;
+  return PlatformSupportKind::Unknown;
+}
+
+static void validateExtensionPlatformSupport(const Record *Ext) {
+  const Record *ExtSupport = Ext->getValueAsDef("ExtSupport");
+  const StringRef ExtSupportName = ExtSupport->getName();
+  const StringRef ExtName = Ext->getValueAsString("ExtName");
+  const bool IsAggregateMode = (ExtSupportName == "InheritFromCapabilities");
+
+  if (ExtSupportName == "InheritFromExtension") {
+    PrintFatalError(
+        Ext->getLoc(),
+        "Extension '" + ExtName.str() +
+            "' cannot use InheritFromExtension; specify explicit platform support or InheritFromCapabilities.");
+  }
+
+  auto Caps = Ext->getValueAsListOfDefs("ExtCapabilities");
+  for (const Record *Cap : Caps) {
+    const Record *CapSupport = Cap->getValueAsDef("Support");
+    const StringRef CapSupportName = CapSupport->getName();
+    const StringRef CapName = Cap->getValueAsString("Name");
+
+    if (CapSupportName == "InheritFromCapabilities") {
+      PrintFatalError(Cap->getLoc(), "Capability '" + CapName + "' in extension '" + ExtName +
+                                         "' cannot use InheritFromCapabilities.");
+    }
+    if (IsAggregateMode) {
+      if (CapSupportName == "InheritFromExtension") {
+        PrintFatalError(Cap->getLoc(), "Capability '" + CapName + "' in extension '" + ExtName +
+                                           "' must specify explicit platform support.");
+      }
+    } else {
+      if (CapSupportName != "InheritFromExtension") {
+        PrintFatalError(Cap->getLoc(),
+                        "Capability '" + CapName + "' in extension '" + ExtName +
+                            "' sets explicit Support; set extension platform support to InheritFromCapabilities.");
+      }
+    }
+  }
+}
+
+static SPIRVExtensions collectSPIRVExtensionSupport(const RecordKeeper &Records) {
+  SPIRVExtensions Result;
+  auto AllExtensions = Records.getAllDerivedDefinitions("SPIRVExtension");
+  Result.reserve(AllExtensions.size());
+  for (const Record *Ext : AllExtensions) {
+    validateExtensionPlatformSupport(Ext);
+    ExtensionEntry Entry;
+    Entry.Name = Ext->getValueAsString("ExtName");
+    Entry.SpecURL = Ext->getValueAsString("ExtSpecURL");
+    Entry.Root = Ext;
+    Entry.Platforms = Ext->getValueAsDef("ExtSupport");
+    Entry.IsInheritFromCapabilitiesMode = Entry.Platforms->getName() == "InheritFromCapabilities";
+    auto Caps = Ext->getValueAsListOfDefs("ExtCapabilities");
+    for (const Record *Cap : Caps) {
+      CapabilityEntry CapEntry;
+      CapEntry.Name = Cap->getValueAsString("Name");
+      CapEntry.Root = Cap;
+      const Record *CapSupport = Cap->getValueAsDef("Support");
+      if (CapSupport->getName() == "InheritFromExtension" && Entry.Platforms->getName() != "InheritFromCapabilities") {
+        CapEntry.EffectivePlatform = Entry.Platforms;
+      } else {
+        CapEntry.EffectivePlatform = CapSupport; // explicit capability support or InheritFromCapabilities mode
+      }
+      Entry.Capabilities.push_back(CapEntry);
+    }
+    Result.push_back(std::move(Entry));
+  }
+  return Result;
+}
+
+} // namespace IGCCSPIRVPlatformSupport