Fix crashes encountered during the compilation of Blender kernels utilizing the SPV_INTEL_bindless_images extension

The latest version of Blender utilizes the SPV_INTEL_bindless_images
extension in a moreadvanced manner, storing image and sampler handles
in a global variable. This approach has posed a challenging stress test
for the IGC's implementation of the SPV_INTEL_bindless_images extension,
leading to compilation crashes.

These crashes occur due to the use of ValueTracker, which is inappropriate
for the SPV_INTEL_bindless_images extension since images are runtime values
in this context.

Consequently, this change disables value tracking for the purposes of:
- handling SAMPLER_SNAP_WA
- Image3dToImage2darray pass

As a result, both the `SAMPLER_SNAP_WA` and `Image3dToImage2darray` pass
are disabled for kernels utilizing the `SPV_INTEL_bindless_images` extension.

Author: aratajew

IGC/AdaptorOCL/dllInterfaceCompute.cpp

@@ -458,6 +458,27 @@ bool CheckForImageUsage(const std::string & SPIRVBinary) {
     return it != textReport.Capabilities.end();
 }
 
+void GenerateSPIRVExtensionsMD(llvm::LLVMContext& C, llvm::Module& M, const std::string& SPIRVBinary)
+{
+    std::istringstream repIS(SPIRVBinary);
+    std::optional<SPIRV::SPIRVModuleReport> report = IGCLLVM::makeOptional(SPIRV::getSpirvReport(repIS));
+
+    if (!report.has_value())
+        return;
+
+    if (report->Extensions.empty())
+        return;
+
+    std::vector<llvm::Metadata*> ExtensionsVec;
+    for (const auto& E : report->Extensions)
+    {
+        ExtensionsVec.push_back(llvm::MDString::get(C, E));
+    }
+
+    llvm::NamedMDNode* SPIRVExtensionsMD = M.getOrInsertNamedMetadata("igc.spirv.extensions");
+    SPIRVExtensionsMD->addOperand(llvm::MDNode::get(C, ExtensionsVec));
+}
+
 // Translate SPIR-V binary to LLVM Module
 bool TranslateSPIRVToLLVM(
     const STB_TranslateInputArgs& InputArgs,
@@ -505,18 +526,21 @@ bool TranslateSPIRVToLLVM(
     // Actual translation from SPIR-V to LLVM
     success = llvm::readSpirv(Context, Opts, IS, LLVMModule, stringErrMsg);
 
-    // Handle OpenCL Compiler Options
     if (success)
     {
         AssignNamesToUnnamedGlobalVariables(*LLVMModule);
 
+        // Handle OpenCL Compiler Options
         GenerateCompilerOptionsMD(
             Context,
             *LLVMModule,
             llvm::StringRef(InputArgs.pOptions, InputArgs.OptionsSize));
 
-      if (IGC_IS_FLAG_ENABLED(ShaderDumpTranslationOnly))
-          LLVMModule->dump();
+        // Parse SPIRV extensions and encode them as 'igc.spirv.extensions' metadata
+        GenerateSPIRVExtensionsMD(Context, *LLVMModule, SPIRVBinary.str());
+
+        if (IGC_IS_FLAG_ENABLED(ShaderDumpTranslationOnly))
+            LLVMModule->dump();
     }
 
     return success;

IGC/Compiler/MetaDataApi/SpirMetaDataApi.h

@@ -44,6 +44,9 @@ namespace IGC::SPIRMD
     using InnerCompilerExternalOptionsMetaDataList = MetaDataList<std::string>;
     using InnerCompilerExternalOptionsMetaDataListHandle = MetaObjectHandle<InnerCompilerExternalOptionsMetaDataList>;
 
+    using SPIRVExtensionsMetaDataList = MetaDataList<std::string>;
+    using SPIRVExtensionsMetaDataListHandle = MetaObjectHandle<SPIRVExtensionsMetaDataList>;
+
     class VersionMetaData : public IMetaDataObject
     {
     public:
@@ -555,6 +558,7 @@ namespace IGC::SPIRMD
         using UsedKhrExtensionsList = NamedMDNodeList<InnerUsedKhrExtensionsMetaDataListHandle>;
         using SpirVersionsList = NamedMDNodeList<VersionMetaDataHandle>;
         using OpenCLVersionsList = NamedMDNodeList<VersionMetaDataHandle>;
+        using SPIRVExtensionsList = NamedMDNodeList<SPIRVExtensionsMetaDataListHandle>;
 
         // If using this constructor, setting the llvm module by the setModule
         // function is needed for correct operation.
@@ -569,6 +573,7 @@ namespace IGC::SPIRMD
             m_UsedKhrExtensions(pModule->getNamedMetadata("opencl.used.extensions")),
             m_SpirVersions(pModule->getNamedMetadata("opencl.spir.version")),
             m_OpenCLVersions(pModule->getNamedMetadata("opencl.ocl.version")),
+            m_SPIRVExtensions(pModule->getNamedMetadata("igc.spirv.extensions")),
             m_pModule(pModule)
         {}
 
@@ -581,6 +586,7 @@ namespace IGC::SPIRMD
             m_UsedKhrExtensions = pModule->getNamedMetadata("opencl.used.extensions");
             m_SpirVersions = pModule->getNamedMetadata("opencl.spir.version");
             m_OpenCLVersions = pModule->getNamedMetadata("opencl.ocl.version");
+            m_SPIRVExtensions = pModule->getNamedMetadata("igc.spirv.extensions");
             m_pModule = pModule;
         }
 
@@ -834,6 +840,37 @@ namespace IGC::SPIRMD
             return m_OpenCLVersions.getItem(index);
         }
 
+        // SPIRV Extensions
+        SPIRVExtensionsList::const_iterator begin_SPIRVExtensions() const
+        {
+            return m_SPIRVExtensions.begin();
+        }
+
+        SPIRVExtensionsList::const_iterator end_SPIRVExtensions() const
+        {
+            return m_SPIRVExtensions.end();
+        }
+
+        size_t size_SPIRVExtensions()  const
+        {
+            return m_SPIRVExtensions.size();
+        }
+
+        bool empty_SPIRVExtensions()  const
+        {
+            return m_SPIRVExtensions.empty();
+        }
+
+        bool isSPIRVExtensionsHasValue() const
+        {
+            return m_SPIRVExtensions.hasValue();
+        }
+
+        const SPIRVExtensionsList::item_type getSPIRVExtensionsItem(size_t index) const
+        {
+            return m_SPIRVExtensions.getItem(index);
+        }
+
         void deleteMetadata()
         {
             llvm::NamedMDNode* KernelsNode = m_pModule->getNamedMetadata("opencl.kernels");
@@ -897,5 +934,6 @@ namespace IGC::SPIRMD
         UsedKhrExtensionsList m_UsedKhrExtensions;
         SpirVersionsList m_SpirVersions;
         OpenCLVersionsList m_OpenCLVersions;
+        SPIRVExtensionsList m_SPIRVExtensions;
     };
 }

IGC/Compiler/Optimizer/OpenCLPasses/Image3dToImage2darray/Image3dToImage2darray.cpp

@@ -152,6 +152,15 @@ bool Image3dToImage2darray::runOnFunction(Function& F)
     m_MetadataUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
     m_modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
 
+    // This pass is not compatible with the SPV_INTEL_bindless_images extension.
+    // The incompatibility arises because this pass requires images to be trackable
+    // at compile time, a condition that bindless images from the SPV_INTEL_bindless_images
+    // extension do not satisfy.
+    if (m_modMD->extensions.spvINTELBindlessImages)
+    {
+        return false;
+    }
+
     if (m_MetadataUtils->findFunctionsInfoItem(&F) == m_MetadataUtils->end_FunctionsInfo())
     {
         return false;

IGC/Compiler/Optimizer/OpenCLPasses/ImageFuncs/ImageFuncResolution.cpp

@@ -210,6 +210,27 @@ Value* ImageFuncResolution::getSamplerProperty(CallInst& CI)
 {
     MetaDataUtils* pMdUtils = getAnalysis<MetaDataUtilsWrapper>().getMetaDataUtils();
     ModuleMetaData* modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
+
+    if (ArgTy == ImplicitArg::SAMPLER_SNAP_WA && modMD->extensions.spvINTELBindlessImages)
+    {
+        // The snap_wa workaround is disabled for bindless images from the SPV_INTEL_bindless_images extension.
+        // This is because the current implementation of the workaround requires the sampler to be known at compile-time,
+        // either as an inline sampler or a kernel argument. This allows the UMD to program the
+        // SAMPLER_SNAP_WA implicit argument, which indicates whether the workaround should be enabled.
+        //
+        // For bindless images from SPV_INTEL_bindless_images, image is represented as an i64 handle (bindlessOffset)
+        // provided by the user. The handle is a runtime value and cannot be tracked to a kernel argument at compile-time.
+        // Therefore, implementing snap_wa would require a completely new approach.
+        //
+        // The absence of reported sampling issues with images from SPV_INTEL_bindless_images suggests that snap_wa
+        // might not be necessary. However, further investigation is required.
+        //
+        // If snap_wa is found to be unnecessary, the workaround for OpenCL images can be removed.
+        // Conversely, if hardware constraints necessitate it, the workaround must be enabled for
+        // images from from SPV_INTEL_bindless_images extension.
+        return ConstantInt::get(CI.getType(), 0);
+    }
+
     if (Value* sampler = ValueTracker::track(&CI, 0, pMdUtils, modMD))
     {
         auto *arg = dyn_cast<Argument>(sampler);

IGC/Compiler/Optimizer/OpenCLPasses/ImageFuncs/ImageFuncsAnalysis.cpp

@@ -59,6 +59,8 @@ bool ImageFuncsAnalysis::runOnModule(Module& M) {
     m_useAdvancedBindlessMode = ctx->getModuleMetaData()->compOpt.UseBindlessMode &&
                                 !ctx->getModuleMetaData()->compOpt.UseLegacyBindlessMode;
 
+    m_useSPVINTELBindlessImages = ctx->getModuleMetaData()->extensions.spvINTELBindlessImages;
+
     // Run on all functions defined in this module
     for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
         Function* pFunc = &(*I);
@@ -144,7 +146,9 @@ void ImageFuncsAnalysis::visitCallInst(CallInst& CI)
     {
         imageFunc = &m_argMap[ImplicitArg::SAMPLER_NORMALIZED];
     }
-    else if (funcName == GET_SAMPLER_SNAP_WA_REQUIRED)
+    // The SNAP_WA is disabled for SPV_INTEL_bindless_images extension.
+    // For further information, refer to the ImageFuncResolution.cpp file.
+    else if (funcName == GET_SAMPLER_SNAP_WA_REQUIRED && !m_useSPVINTELBindlessImages)
     {
         imageFunc = &m_argMap[ImplicitArg::SAMPLER_SNAP_WA];
     }

IGC/Compiler/Optimizer/OpenCLPasses/ImageFuncs/ImageFuncsAnalysis.hpp

@@ -107,6 +107,18 @@ namespace IGC
         ///        If false, implicit image args for information like width, height, etc.
         ///        will be added to m_argMap
         bool m_useAdvancedBindlessMode{};
+
+        // @brief Handling of image/sampler properties query functions varies based on image type.
+        //
+        //        This distinction arises between standard OpenCL images and bindless images
+        //        from the SPV_INTEL_bindless_images extension.
+        //
+        //        For example: the __builtin_IB_get_snap_wa_reqd function is lowered to an
+        //        implicit argument, SAMPLER_SNAP_WA, for standard OpenCL images.
+        //        However, for bindless images from the SPV_INTEL_bindless_images extension,
+        //        the snap_wa is unsupported. Consequently, it is effectively disabled
+        //        by being lowered to a ConstantInt value of 0.
+        bool m_useSPVINTELBindlessImages{};
     };
 
 } // namespace IGC

IGC/Compiler/SPIRMetaDataTranslation.cpp

@@ -389,6 +389,20 @@ bool SPIRMetaDataTranslation::runOnModule(Module& M)
         modMD->compOpt.MadEnable = true;
     }
 
+    // Ensure that the extensions listed in the 'igc.spirv.extensions' metadata are
+    // reflected within the ModuleMetaData->extensions
+    if (!spirMDUtils.empty_SPIRVExtensions())
+    {
+        auto extensions = spirMDUtils.getSPIRVExtensionsItem(0);
+        for (const auto& spirvExtension : *extensions)
+        {
+            if (spirvExtension == "SPV_INTEL_bindless_images")
+            {
+                modMD->extensions.spvINTELBindlessImages = true;
+            }
+        }
+    }
+
     spirMDUtils.deleteMetadata();
 
     pIgcMDUtils->save(M.getContext());

IGC/Compiler/tests/ImageFuncResolution/get_image_snap_wa_required_spv_intel_bindless_images.ll

@@ -0,0 +1,44 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; This test verifies if snap_wa is effectively disabled for SPV_INTEL_bindless_images extension.
+
+; The snap_wa workaround is disabled for bindless images from the SPV_INTEL_bindless_images extension.
+; This is because the current implementation of the workaround requires the sampler to be known at compile-time,
+; either as an inline sampler or a kernel argument. This allows the UMD to program the
+; SAMPLER_SNAP_WA implicit argument, which indicates whether the workaround should be enabled.
+;
+; For bindless images from SPV_INTEL_bindless_images, image is represented as an i64 handle (bindlessOffset)
+; provided by the user. The handle is a runtime value and cannot be tracked to a kernel argument at compile-time.
+; Therefore, implementing snap_wa would require a completely new approach.
+
+; REQUIRES: llvm-14-plus
+; RUN: igc_opt --opaque-pointers -igc-image-func-resolution -S %s -o %t.ll
+; RUN: FileCheck %s --input-file=%t.ll
+
+%spirv.Sampler = type opaque
+
+declare i32 @__builtin_IB_get_snap_wa_reqd(i32)
+
+define i32 @foo(i32 %sampler_handle) nounwind {
+; CHECK-NOT:     call i32 @__builtin_IB_get_snap_wa_reqd(i32 %sampler_handle)
+  %id = call i32 @__builtin_IB_get_snap_wa_reqd(i32 %sampler_handle)
+; CHECK:         ret i32 0
+  ret i32 %id
+}
+
+!IGCMetadata = !{!0}
+!igc.functions = !{!3}
+
+!0 = !{!"ModuleMD", !1}
+!1 = !{!"extensions", !2}
+!2 = !{!"spvINTELBindlessImages", i1 true}
+!3 = !{i32 (i32)* @foo, !1}
+!4 = !{ptr @foo, !5}
+!5 = !{!5, !6}
+!6 = !{!"function_type", i32 0}

IGC/common/MDFrameWork.h

@@ -709,10 +709,22 @@ enum class ShaderTypeMD
 
     struct SPIRVCapabilities
     {
-
         bool globalVariableDecorationsINTEL = false;
     };
 
+    struct SPIRVExtensions
+    {
+        // IGC must distinguish between SPIRV compilations that utilize standard
+        // OpenCL images and those using Bindless images from the
+        // SPV_INTEL_bindless_images extension. Currently, OpenCL images require the
+        // valueTracker to be addressed using the bindless addressing model. This is
+        // because IGC needs to insert a bindlessOffset as an implicit argument for
+        // tracked images. Conversely, for bindless images originating from
+        // SPV_INTEL_bindless_images, the bindlessOffset is supplied by the user as a
+        // kernel argument, eliminating the need for IGC to perform tracking.
+        bool spvINTELBindlessImages = false;
+    };
+
     //metadata for the entire module
     struct ModuleMetaData
     {
@@ -783,6 +795,7 @@ enum class ShaderTypeMD
         std::set<std::string> m_OptsToDisable;
 
         SPIRVCapabilities capabilities;
+        SPIRVExtensions extensions;
 
         std::array<uint64_t, NUM_SHADER_RESOURCE_VIEW_SIZE> m_ShaderResourceViewMcsMask{};
         unsigned int computedDepthMode = 0; //Defaults to 0 meaning depth mode is off

IGC/ocloc_tests/SPIRV-extenstions/SPV_INTEL_bindless_images/bindless_images_metadata.ll

@@ -0,0 +1,35 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; REQUIRES: llvm-spirv, regkeys, dg2-supported
+
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_bindless_images -o %t.spv
+; RUN: ocloc compile -spirv_input -file %t.spv -device dg2 -options " -igc_opts 'PrintToConsole=1 PrintAfter=igc-spir-metadata-translation'" 2>&1 | FileCheck %s
+
+; CHECK: !{!"spvINTELBindlessImages", i1 true}
+
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
+target triple = "spir64-unknown-unknown"
+
+%spirv.SampledImage._void_1_0_0_0_0_0_0 = type opaque
+
+define spir_func void @foo(i64 %in) {
+  %img = call spir_func %spirv.SampledImage._void_1_0_0_0_0_0_0 addrspace(1)* @_Z90__spirv_ConvertHandleToSampledImageINTEL_RPU3AS140__spirv_SampledImage__void_1_0_0_0_0_0_0m(i64 %in)
+  ret void
+}
+
+declare spir_func %spirv.SampledImage._void_1_0_0_0_0_0_0 addrspace(1)* @_Z90__spirv_ConvertHandleToSampledImageINTEL_RPU3AS140__spirv_SampledImage__void_1_0_0_0_0_0_0m(i64)
+
+!opencl.spir.version = !{!0}
+!spirv.Source = !{!1}
+!llvm.ident = !{!2}
+
+!0 = !{i32 1, i32 2}
+!1 = !{i32 4, i32 100000}
+!2 = !{!"clang version 14.0.0"}